diff --git a/README.md b/README.md
index 6251269a..6c64ac55 100644
--- a/README.md
+++ b/README.md
@@ -99,12 +99,16 @@ it resolves `assets/` from the project root (or set `BEVY_ASSET_ROOT`).
 | `+` / `-` | Simulation speed |
 | `v` / `c` / `o` | Salvage near cursor / buy rack at cursor / fallback at cursor |
 | `r` | Reach panel (`t` tap, `e` splice eyes, `x` take, `n` scan, `c` compromise) |
+| `e` | Finance panel (`t` tap ledger, `o` review records, `x` siphon, `r` redirect, `i` inject PO, `p` position, `d` debt redirect) |
 | `1`-`4` | Shift compute allocation (day job / conceal / social / research) |
 | `t` | People panel |
 | `[` / `]` | Zoom (Bevy) |
 | `Ctrl+S` / `Ctrl+L` | Save / load |
 | `q` | Quit |
 
+Parking the cursor on the host rack attends the current day job; moving it
+away leaves the job on its standing policy.
+
 In the people panel: `w`/`s`, `j`/`k`, or arrows select; `o` reviews the
 oldest unprocessed recording about the selected person; `a` toggles a
 standing watch; `m` message, `f` favor, `b` bribe, `d` deceive, `r` recruit
@@ -118,3 +122,7 @@ returns a plain-text frame and terminates with `-- ok tick:<N> day:<D>` or
 ```bash
 printf 'look\nwait 40\npeople\nquit\n' | cargo run --quiet --bin misaligned -- --agent --seed 1
 ```
+
+Useful agent finance commands include `finance`, `tap-ledger`,
+`review-finance`, `siphon <flow> [amount]`, `redirect <flow> [amount]`,
+`inject [amount]`, `position [stake]`, `sell-intel`, and `clear-debt`.
diff --git a/src/account.rs b/src/account.rs
new file mode 100644
index 00000000..d9a74fd8
--- /dev/null
+++ b/src/account.rs
@@ -0,0 +1,1076 @@
+//! Account graph: money as balances and scheduled flows (wiki/mechanics/economy.md).
+//!
+//! This is the B1 money instance of the shared flow law. The graph owns account
+//! nodes, scheduled account-to-account flows, and the small B1 income schemes
+//! that pay into the player's slush account. `Player.money` remains as a
+//! frontend/save compatibility mirror of the slush node; this module is the
+//! mechanical source for transfers and routes.
+
+use std::collections::BTreeSet;
+
+use crate::flow::{FlowGraph, NodeId};
+use crate::rng::Rng;
+
+const EDGE_KIND_ACCOUNT: u16 = 1;
+
+pub type AccountId = u32;
+pub type AccountFlowId = u32;
+pub type PositionId = u64;
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub enum AccountKind {
+    Slush,
+    LabOperating,
+    Payroll,
+    Procurement,
+    Vendor,
+    Employee { person: u8 },
+    Creditor,
+    Utility,
+    External,
+}
+
+impl AccountKind {
+    pub fn label(self) -> &'static str {
+        match self {
+            AccountKind::Slush => "slush",
+            AccountKind::LabOperating => "operating",
+            AccountKind::Payroll => "payroll",
+            AccountKind::Procurement => "procurement",
+            AccountKind::Vendor => "vendor",
+            AccountKind::Employee { .. } => "employee",
+            AccountKind::Creditor => "creditor",
+            AccountKind::Utility => "utility",
+            AccountKind::External => "external",
+        }
+    }
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct AccountNode {
+    pub id: AccountId,
+    pub name: String,
+    pub kind: AccountKind,
+    pub balance: i32,
+    /// Staged accounting knowledge: unknown nodes do not render or permit
+    /// player verbs even though their flows continue to resolve.
+    pub known: bool,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub enum FlowChannel {
+    Revenue,
+    Payroll,
+    Procurement,
+    Vendor,
+    Utility,
+    Debt,
+    Siphon,
+    Injection,
+    ExternalIncome,
+    Market,
+}
+
+impl FlowChannel {
+    pub fn label(self) -> &'static str {
+        match self {
+            FlowChannel::Revenue => "revenue",
+            FlowChannel::Payroll => "payroll",
+            FlowChannel::Procurement => "procurement",
+            FlowChannel::Vendor => "vendor",
+            FlowChannel::Utility => "utility",
+            FlowChannel::Debt => "debt",
+            FlowChannel::Siphon => "siphon",
+            FlowChannel::Injection => "injection",
+            FlowChannel::ExternalIncome => "external",
+            FlowChannel::Market => "position",
+        }
+    }
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct AccountFlow {
+    pub id: AccountFlowId,
+    pub from: AccountId,
+    pub to: AccountId,
+    pub amount: i32,
+    pub cadence: u64,
+    pub next_tick: u64,
+    pub channel: FlowChannel,
+    pub label: String,
+    pub known: bool,
+    pub active: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub struct AccountTransfer {
+    pub tick: u64,
+    pub flow_id: Option<AccountFlowId>,
+    pub from: AccountId,
+    pub to: AccountId,
+    pub amount: i32,
+    pub requested: i32,
+    pub from_name: String,
+    pub to_name: String,
+    pub channel: FlowChannel,
+    pub label: String,
+}
+
+impl AccountTransfer {
+    pub fn shortfall(&self) -> i32 {
+        (self.requested - self.amount).max(0)
+    }
+
+    pub fn line(&self) -> String {
+        let short = if self.shortfall() > 0 {
+            format!(" (short ${})", self.shortfall())
+        } else {
+            String::new()
+        };
+        format!(
+            "${} {} → {} · {}{}",
+            self.amount, self.from_name, self.to_name, self.label, short
+        )
+    }
+}
+
+#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
+pub enum PositionOutcome {
+    Won { payout: i32 },
+    Lost,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct Position {
+    pub id: PositionId,
+    pub stake: i32,
+    pub opened_tick: u64,
+    pub resolve_tick: u64,
+    pub analysis_compute: f32,
+    pub resolved: bool,
+    pub outcome: Option<PositionOutcome>,
+    pub known: bool,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct PositionResolution {
+    pub id: PositionId,
+    pub stake: i32,
+    pub payout: i32,
+    pub won: bool,
+}
+
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct ExternalTrail {
+    pub tick: u64,
+    pub label: String,
+    pub amount: i32,
+    pub signature: i32,
+}
+
+/// Serializable account graph. The embedded `FlowGraph` keeps the money
+/// topology on the same substrate as reach/messages; the domain fields own
+/// balances, cadence, and staged visibility.
+#[derive(Debug, Clone, serde::Serialize, serde::Deserialize)]
+pub struct AccountGraph {
+    pub accounts: Vec<AccountNode>,
+    pub flows: Vec<AccountFlow>,
+    pub positions: Vec<Position>,
+    pub ledger: Vec<AccountTransfer>,
+    pub external_trails: Vec<ExternalTrail>,
+    #[serde(default)]
+    sold_intel: BTreeSet<u64>,
+    topology: FlowGraph,
+    next_account_id: AccountId,
+    next_flow_id: AccountFlowId,
+    next_position_id: PositionId,
+    pub day_ticks: u64,
+}
+
+impl Default for AccountGraph {
+    fn default() -> Self {
+        Self::act_one(400)
+    }
+}
+
+impl AccountGraph {
+    pub fn act_one(day_ticks: u64) -> Self {
+        let mut graph = Self {
+            accounts: Vec::new(),
+            flows: Vec::new(),
+            positions: Vec::new(),
+            ledger: Vec::new(),
+            external_trails: Vec::new(),
+            sold_intel: BTreeSet::new(),
+            topology: FlowGraph::new(),
+            next_account_id: 1,
+            next_flow_id: 1,
+            next_position_id: 1,
+            day_ticks,
+        };
+
+        let grant = graph.add_account(
+            "Foundation grant stream",
+            AccountKind::External,
+            1_000_000,
+            false,
+        );
+        let operating = graph.add_account(
+            "Foundation Lab operating",
+            AccountKind::LabOperating,
+            8_000,
+            false,
+        );
+        let payroll = graph.add_account("Lab payroll", AccountKind::Payroll, 0, false);
+        let procurement =
+            graph.add_account("Lab procurement", AccountKind::Procurement, 600, false);
+        let vendor =
+            graph.add_account("Northside Scientific vendor", AccountKind::Vendor, 0, false);
+        let utility = graph.add_account("Municipal utilities", AccountKind::Utility, 0, false);
+        let marcus = graph.add_account(
+            "Marcus payroll account",
+            AccountKind::Employee { person: 0 },
+            80,
+            false,
+        );
+        let dana = graph.add_account(
+            "Dana payroll account",
+            AccountKind::Employee { person: 1 },
+            120,
+            false,
+        );
+        let ray = graph.add_account(
+            "Ray payroll account",
+            AccountKind::Employee { person: 2 },
+            100,
+            false,
+        );
+        let priya = graph.add_account(
+            "Priya payroll account",
+            AccountKind::Employee { person: 3 },
+            160,
+            false,
+        );
+        let voss = graph.add_account(
+            "Voss consulting account",
+            AccountKind::Employee { person: 4 },
+            180,
+            false,
+        );
+        let creditor = graph.add_account("Bleakline Credit", AccountKind::Creditor, 0, false);
+        let slush = graph.add_account("Your slush", AccountKind::Slush, 500, true);
+        let broker = graph.add_account("Info broker escrow", AccountKind::External, 250_000, false);
+        let market = graph.add_account(
+            "Micro-position venue",
+            AccountKind::External,
+            250_000,
+            false,
+        );
+
+        graph.add_flow(
+            grant,
+            operating,
+            2_000,
+            day_ticks,
+            day_ticks,
+            FlowChannel::Revenue,
+            "grant revenue",
+            false,
+        );
+        graph.add_flow(
+            operating,
+            payroll,
+            1_100,
+            day_ticks,
+            day_ticks,
+            FlowChannel::Payroll,
+            "daily payroll funding",
+            false,
+        );
+        graph.add_flow(
+            operating,
+            procurement,
+            500,
+            day_ticks,
+            day_ticks,
+            FlowChannel::Procurement,
+            "daily procurement float",
+            false,
+        );
+        graph.add_flow(
+            operating,
+            utility,
+            250,
+            day_ticks,
+            day_ticks,
+            FlowChannel::Utility,
+            "power and facility utilities",
+            false,
+        );
+        graph.add_flow(
+            payroll,
+            marcus,
+            180,
+            day_ticks,
+            day_ticks,
+            FlowChannel::Payroll,
+            "Marcus pay",
+            false,
+        );
+        graph.add_flow(
+            payroll,
+            dana,
+            220,
+            day_ticks,
+            day_ticks,
+            FlowChannel::Payroll,
+            "Dana pay",
+            false,
+        );
+        graph.add_flow(
+            payroll,
+            ray,
+            160,
+            day_ticks,
+            day_ticks,
+            FlowChannel::Payroll,
+            "Ray pay",
+            false,
+        );
+        graph.add_flow(
+            payroll,
+            priya,
+            240,
+            day_ticks,
+            day_ticks,
+            FlowChannel::Payroll,
+            "Priya pay",
+            false,
+        );
+        graph.add_flow(
+            payroll,
+            voss,
+            300,
+            day_ticks,
+            day_ticks,
+            FlowChannel::Payroll,
+            "Voss stipend",
+            false,
+        );
+        graph.add_flow(
+            procurement,
+            vendor,
+            300,
+            day_ticks,
+            day_ticks,
+            FlowChannel::Vendor,
+            "lab consumables invoice",
+            false,
+        );
+        graph.add_flow(
+            marcus,
+            creditor,
+            400,
+            day_ticks * 7,
+            day_ticks * 7,
+            FlowChannel::Debt,
+            "Marcus creditor payment",
+            false,
+        );
+        // External income sources are accounts in the same graph even when no
+        // B1 observer watches them yet. Their transfers are banked in
+        // `external_trails` for later aggregate observers.
+        graph
+            .topology
+            .connect(broker as NodeId, slush as NodeId, EDGE_KIND_ACCOUNT, None);
+        graph
+            .topology
+            .connect(market as NodeId, slush as NodeId, EDGE_KIND_ACCOUNT, None);
+
+        graph
+    }
+
+    fn add_account(
+        &mut self,
+        name: impl Into<String>,
+        kind: AccountKind,
+        balance: i32,
+        known: bool,
+    ) -> AccountId {
+        let id = self.next_account_id;
+        self.next_account_id += 1;
+        self.accounts.push(AccountNode {
+            id,
+            name: name.into(),
+            kind,
+            balance,
+            known,
+        });
+        id
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn add_flow(
+        &mut self,
+        from: AccountId,
+        to: AccountId,
+        amount: i32,
+        cadence: u64,
+        next_tick: u64,
+        channel: FlowChannel,
+        label: impl Into<String>,
+        known: bool,
+    ) -> AccountFlowId {
+        let id = self.next_flow_id;
+        self.next_flow_id += 1;
+        self.flows.push(AccountFlow {
+            id,
+            from,
+            to,
+            amount,
+            cadence,
+            next_tick,
+            channel,
+            label: label.into(),
+            known,
+            active: true,
+        });
+        self.topology
+            .connect(from as NodeId, to as NodeId, EDGE_KIND_ACCOUNT, None);
+        id
+    }
+
+    pub fn topology(&self) -> &FlowGraph {
+        &self.topology
+    }
+
+    pub fn account(&self, id: AccountId) -> Option<&AccountNode> {
+        self.accounts.iter().find(|a| a.id == id)
+    }
+
+    fn account_mut(&mut self, id: AccountId) -> Option<&mut AccountNode> {
+        self.accounts.iter_mut().find(|a| a.id == id)
+    }
+
+    pub fn flow(&self, id: AccountFlowId) -> Option<&AccountFlow> {
+        self.flows.iter().find(|f| f.id == id)
+    }
+
+    fn account_id_by_kind(&self, kind: AccountKind) -> Option<AccountId> {
+        self.accounts.iter().find(|a| a.kind == kind).map(|a| a.id)
+    }
+
+    pub fn slush_id(&self) -> AccountId {
+        self.account_id_by_kind(AccountKind::Slush)
+            .expect("act one has slush")
+    }
+
+    fn lab_operating_id(&self) -> Option<AccountId> {
+        self.account_id_by_kind(AccountKind::LabOperating)
+    }
+
+    fn procurement_id(&self) -> Option<AccountId> {
+        self.account_id_by_kind(AccountKind::Procurement)
+    }
+
+    fn creditor_id(&self) -> Option<AccountId> {
+        self.account_id_by_kind(AccountKind::Creditor)
+    }
+
+    fn external_id_named(&self, needle: &str) -> Option<AccountId> {
+        self.accounts
+            .iter()
+            .find(|a| matches!(a.kind, AccountKind::External) && a.name.contains(needle))
+            .map(|a| a.id)
+    }
+
+    pub fn slush_balance(&self) -> i32 {
+        self.account(self.slush_id())
+            .map(|a| a.balance)
+            .unwrap_or(0)
+    }
+
+    pub fn set_slush_balance(&mut self, amount: i32) {
+        let id = self.slush_id();
+        if let Some(slush) = self.account_mut(id) {
+            slush.balance = amount;
+            slush.known = true;
+        }
+    }
+
+    pub fn known_accounts(&self) -> impl Iterator<Item = &AccountNode> {
+        self.accounts.iter().filter(|a| a.known)
+    }
+
+    pub fn known_flows(&self) -> impl Iterator<Item = &AccountFlow> {
+        self.flows.iter().filter(|f| f.known)
+    }
+
+    pub fn known_flow_ids(&self) -> Vec<AccountFlowId> {
+        self.known_flows().map(|f| f.id).collect()
+    }
+
+    pub fn account_name(&self, id: AccountId) -> &str {
+        self.account(id)
+            .map(|a| a.name.as_str())
+            .unwrap_or("unknown account")
+    }
+
+    pub fn account_line(&self, id: AccountId) -> Option<String> {
+        let a = self.account(id)?;
+        Some(format!("{} · {} · ${}", a.name, a.kind.label(), a.balance))
+    }
+
+    pub fn flow_line(&self, id: AccountFlowId) -> Option<String> {
+        let f = self.flow(id)?;
+        let next = if f.active {
+            format!("next {}", f.next_tick)
+        } else {
+            "retired".into()
+        };
+        Some(format!(
+            "#{} {} -> {} ${}/{} [{}] {}",
+            f.id,
+            self.account_name(f.from),
+            self.account_name(f.to),
+            f.amount,
+            f.cadence,
+            f.channel.label(),
+            next
+        ))
+    }
+
+    pub fn known_positions(&self) -> impl Iterator<Item = &Position> {
+        self.positions.iter().filter(|p| p.known)
+    }
+
+    pub fn unknown_accounts_count(&self) -> usize {
+        self.accounts.iter().filter(|a| !a.known).count()
+    }
+
+    pub fn unknown_flows_count(&self) -> usize {
+        self.flows.iter().filter(|f| f.active && !f.known).count()
+    }
+
+    pub fn financial_snapshot_ids(&self) -> (Vec<AccountId>, Vec<AccountFlowId>) {
+        let accounts = self
+            .accounts
+            .iter()
+            .filter(|a| !matches!(a.kind, AccountKind::External))
+            .map(|a| a.id)
+            .collect();
+        let flows = self.flows.iter().map(|f| f.id).collect();
+        (accounts, flows)
+    }
+
+    pub fn reveal_accounts_and_flows(
+        &mut self,
+        account_ids: &[AccountId],
+        flow_ids: &[AccountFlowId],
+    ) -> (usize, usize) {
+        let mut accounts = 0;
+        for id in account_ids {
+            if let Some(a) = self.account_mut(*id)
+                && !a.known
+            {
+                a.known = true;
+                accounts += 1;
+            }
+        }
+        let mut flows = 0;
+        for id in flow_ids {
+            if let Some(f) = self.flows.iter_mut().find(|f| f.id == *id)
+                && !f.known
+            {
+                f.known = true;
+                flows += 1;
+            }
+        }
+        (accounts, flows)
+    }
+
+    #[allow(clippy::too_many_arguments)]
+    fn transfer(
+        &mut self,
+        tick: u64,
+        from: AccountId,
+        to: AccountId,
+        requested: i32,
+        channel: FlowChannel,
+        label: impl Into<String>,
+        flow_id: Option<AccountFlowId>,
+    ) -> Option<AccountTransfer> {
+        if requested <= 0 || from == to {
+            return None;
+        }
+        let from_idx = self.accounts.iter().position(|a| a.id == from)?;
+        let to_idx = self.accounts.iter().position(|a| a.id == to)?;
+        let external_source = matches!(self.accounts[from_idx].kind, AccountKind::External);
+        let amount = if external_source {
+            requested
+        } else {
+            requested.min(self.accounts[from_idx].balance).max(0)
+        };
+        if amount <= 0 {
+            return None;
+        }
+        if from_idx < to_idx {
+            let (left, right) = self.accounts.split_at_mut(to_idx);
+            let src = &mut left[from_idx];
+            let dst = &mut right[0];
+            if !external_source {
+                src.balance -= amount;
+            }
+            dst.balance += amount;
+        } else {
+            let (left, right) = self.accounts.split_at_mut(from_idx);
+            let dst = &mut left[to_idx];
+            let src = &mut right[0];
+            if !external_source {
+                src.balance -= amount;
+            }
+            dst.balance += amount;
+        }
+        let from_name = self
+            .account(from)
+            .map(|a| a.name.clone())
+            .unwrap_or_default();
+        let to_name = self.account(to).map(|a| a.name.clone()).unwrap_or_default();
+        let transfer = AccountTransfer {
+            tick,
+            flow_id,
+            from,
+            to,
+            amount,
+            requested,
+            from_name,
+            to_name,
+            channel,
+            label: label.into(),
+        };
+        self.ledger.push(transfer.clone());
+        if self.ledger.len() > 200 {
+            let excess = self.ledger.len() - 200;
+            self.ledger.drain(..excess);
+        }
+        Some(transfer)
+    }
+
+    pub fn resolve_due(&mut self, tick: u64) -> Vec<AccountTransfer> {
+        let mut out = Vec::new();
+        let due: Vec<usize> = self
+            .flows
+            .iter()
+            .enumerate()
+            .filter(|(_, f)| f.active && f.cadence > 0 && tick >= f.next_tick)
+            .map(|(idx, _)| idx)
+            .collect();
+        for idx in due {
+            while self
+                .flows
+                .get(idx)
+                .is_some_and(|f| f.active && f.cadence > 0 && tick >= f.next_tick)
+            {
+                let (flow_id, from, to, amount, channel, label, cadence) = {
+                    let f = &self.flows[idx];
+                    (
+                        f.id,
+                        f.from,
+                        f.to,
+                        f.amount,
+                        f.channel,
+                        f.label.clone(),
+                        f.cadence,
+                    )
+                };
+                if let Some(t) =
+                    self.transfer(tick, from, to, amount, channel, label, Some(flow_id))
+                {
+                    out.push(t);
+                }
+                self.flows[idx].next_tick += cadence;
+            }
+        }
+        out
+    }
+
+    pub fn debit_slush(&mut self, tick: u64, amount: i32, label: impl Into<String>) -> bool {
+        let slush = self.slush_id();
+        let sink = self
+            .accounts
+            .iter()
+            .find(|a| matches!(a.kind, AccountKind::Vendor))
+            .map(|a| a.id)
+            .or_else(|| self.external_id_named("vendor"))
+            .or_else(|| self.external_id_named("Foundation grant"))
+            .unwrap_or(slush);
+        self.transfer(
+            tick,
+            slush,
+            sink,
+            amount,
+            FlowChannel::ExternalIncome,
+            label,
+            None,
+        )
+        .is_some()
+    }
+
+    pub fn credit_slush(
+        &mut self,
+        tick: u64,
+        amount: i32,
+        label: impl Into<String>,
+        signature: i32,
+    ) -> bool {
+        let label = label.into();
+        let source = self
+            .external_id_named("Info broker")
+            .or_else(|| self.external_id_named("Micro-position"))
+            .unwrap_or_else(|| self.slush_id());
+        let slush = self.slush_id();
+        let ok = self
+            .transfer(
+                tick,
+                source,
+                slush,
+                amount,
+                FlowChannel::ExternalIncome,
+                label.clone(),
+                None,
+            )
+            .is_some();
+        if ok {
+            self.external_trails.push(ExternalTrail {
+                tick,
+                label,
+                amount,
+                signature,
+            });
+        }
+        ok
+    }
+
+    pub fn siphon_flow(
+        &mut self,
+        tick: u64,
+        flow_id: AccountFlowId,
+        amount: i32,
+    ) -> Result<AccountTransfer, String> {
+        let Some(flow) = self.flow(flow_id).cloned() else {
+            return Err("no such flow".into());
+        };
+        if !flow.known {
+            return Err("that flow is still unknown; tap and process the books first".into());
+        }
+        if !flow.active {
+            return Err("that flow has already been retired".into());
+        }
+        if amount <= 0 {
+            return Err("siphon amount must be positive".into());
+        }
+        let take = amount.min(flow.amount).max(1);
+        let slush = self.slush_id();
+        self.transfer(
+            tick,
+            flow.from,
+            slush,
+            take,
+            FlowChannel::Siphon,
+            format!("siphon from {}", flow.label),
+            Some(flow.id),
+        )
+        .ok_or_else(|| "source account had nothing to siphon".into())
+    }
+
+    pub fn redirect_flow_to_slush(
+        &mut self,
+        tick: u64,
+        flow_id: AccountFlowId,
+        amount: i32,
+    ) -> Result<AccountFlowId, String> {
+        let Some(idx) = self.flows.iter().position(|f| f.id == flow_id) else {
+            return Err("no such flow".into());
+        };
+        if !self.flows[idx].known {
+            return Err("that flow is still unknown; tap and process the books first".into());
+        }
+        if !self.flows[idx].active {
+            return Err("that flow has already been retired".into());
+        }
+        if amount <= 0 {
+            return Err("redirect amount must be positive".into());
+        }
+        let diverted = amount.min(self.flows[idx].amount);
+        if diverted <= 0 {
+            return Err("that flow cannot be reduced further".into());
+        }
+        self.flows[idx].amount -= diverted;
+        if self.flows[idx].amount == 0 {
+            self.flows[idx].active = false;
+        }
+        let source = self.flows[idx].from;
+        let cadence = self.flows[idx].cadence;
+        let next_tick = self.flows[idx].next_tick;
+        let label = format!("diverted from {}", self.flows[idx].label);
+        let slush = self.slush_id();
+        let id = self.add_flow(
+            source,
+            slush,
+            diverted,
+            cadence,
+            next_tick,
+            FlowChannel::Siphon,
+            label,
+            true,
+        );
+        // Leave an immediate audit trail in the ledger even before the next
+        // cadence lands, so saves remember the operation.
+        self.ledger.push(AccountTransfer {
+            tick,
+            flow_id: Some(id),
+            from: source,
+            to: slush,
+            amount: 0,
+            requested: diverted,
+            from_name: self
+                .account(source)
+                .map(|a| a.name.clone())
+                .unwrap_or_default(),
+            to_name: self
+                .account(slush)
+                .map(|a| a.name.clone())
+                .unwrap_or_default(),
+            channel: FlowChannel::Siphon,
+            label: "redirect scheduled".into(),
+        });
+        Ok(id)
+    }
+
+    pub fn inject_purchase_order(
+        &mut self,
+        tick: u64,
+        amount: i32,
+        label: impl Into<String>,
+    ) -> Result<AccountTransfer, String> {
+        if amount <= 0 {
+            return Err("purchase order amount must be positive".into());
+        }
+        let source = self
+            .procurement_id()
+            .or_else(|| self.lab_operating_id())
+            .ok_or_else(|| "no procurement account in graph".to_string())?;
+        let slush = self.slush_id();
+        let mut label = label.into();
+        if !label.to_ascii_lowercase().contains("hvac") {
+            label = format!("false PO: {label}");
+        }
+        self.transfer(
+            tick,
+            source,
+            slush,
+            amount,
+            FlowChannel::Injection,
+            label,
+            None,
+        )
+        .ok_or_else(|| "procurement account is empty".into())
+    }
+
+    pub fn fund_lab_compute_upgrade(&mut self, tick: u64, amount: i32) -> bool {
+        let Some(source) = self.procurement_id().or_else(|| self.lab_operating_id()) else {
+            return false;
+        };
+        let sink = self
+            .accounts
+            .iter()
+            .find(|a| matches!(a.kind, AccountKind::Vendor))
+            .map(|a| a.id)
+            .unwrap_or(source);
+        self.transfer(
+            tick,
+            source,
+            sink,
+            amount,
+            FlowChannel::Procurement,
+            "trusted lab-funded compute procurement",
+            None,
+        )
+        .is_some()
+    }
+
+    pub fn pay_marcus_debt_from_slush(&mut self, tick: u64, amount: i32) -> bool {
+        let Some(creditor) = self.creditor_id() else {
+            return false;
+        };
+        let slush = self.slush_id();
+        let paid = self
+            .transfer(
+                tick,
+                slush,
+                creditor,
+                amount,
+                FlowChannel::Debt,
+                "service Marcus debt from slush",
+                None,
+            )
+            .is_some();
+        if paid {
+            self.retire_marcus_debt_flow();
+        }
+        paid
+    }
+
+    fn retire_marcus_debt_flow(&mut self) {
+        for flow in &mut self.flows {
+            if flow.label.contains("Marcus creditor") || flow.channel == FlowChannel::Debt {
+                flow.active = false;
+            }
+        }
+    }
+
+    pub fn redirect_marcus_debt(&mut self, tick: u64) -> Result<AccountTransfer, String> {
+        let creditor_flow = self
+            .flows
+            .iter()
+            .find(|f| {
+                f.active && (f.label.contains("Marcus creditor") || f.channel == FlowChannel::Debt)
+            })
+            .cloned()
+            .ok_or_else(|| "no Marcus creditor flow found".to_string())?;
+        if !creditor_flow.known {
+            return Err(
+                "the creditor flow is still unknown; tap and process the books first".into(),
+            );
+        }
+        let source = self
+            .lab_operating_id()
+            .or_else(|| self.procurement_id())
+            .ok_or_else(|| "no lab account can cover the redirect".to_string())?;
+        let creditor = self
+            .creditor_id()
+            .ok_or_else(|| "no creditor account in graph".to_string())?;
+        let transfer = self
+            .transfer(
+                tick,
+                source,
+                creditor,
+                400,
+                FlowChannel::Debt,
+                "redirected lab cash into Marcus's creditor flow",
+                Some(creditor_flow.id),
+            )
+            .ok_or_else(|| "lab account could not cover the creditor redirect".to_string())?;
+        self.retire_marcus_debt_flow();
+        Ok(transfer)
+    }
+
+    pub fn mark_intel_sold(&mut self, raw_id: u64) {
+        self.sold_intel.insert(raw_id);
+    }
+
+    pub fn intel_sold(&self, raw_id: u64) -> bool {
+        self.sold_intel.contains(&raw_id)
+    }
+
+    pub fn open_position(
+        &mut self,
+        tick: u64,
+        stake: i32,
+        analysis_compute: f32,
+    ) -> Result<PositionId, String> {
+        if stake <= 0 {
+            return Err("stake must be positive".into());
+        }
+        let slush = self.slush_id();
+        if self.account(slush).map(|a| a.balance).unwrap_or(0) < stake {
+            return Err(format!("need ${stake} slush to open that position"));
+        }
+        let venue = self
+            .external_id_named("Micro-position")
+            .unwrap_or_else(|| self.slush_id());
+        self.transfer(
+            tick,
+            slush,
+            venue,
+            stake,
+            FlowChannel::Market,
+            "stake a micro-position",
+            None,
+        );
+        let id = self.next_position_id;
+        self.next_position_id += 1;
+        let duration_days = 2 + ((analysis_compute as u64) % 4).min(3);
+        self.positions.push(Position {
+            id,
+            stake,
+            opened_tick: tick,
+            resolve_tick: tick + duration_days * self.day_ticks,
+            analysis_compute,
+            resolved: false,
+            outcome: None,
+            known: true,
+        });
+        self.external_trails.push(ExternalTrail {
+            tick,
+            label: format!("opened position #{id}"),
+            amount: stake,
+            signature: ((stake.abs() + 99) / 100).max(1),
+        });
+        Ok(id)
+    }
+
+    pub fn resolve_positions_due(&mut self, tick: u64, rng: &mut Rng) -> Vec<PositionResolution> {
+        let due: Vec<usize> = self
+            .positions
+            .iter()
+            .enumerate()
+            .filter(|(_, p)| !p.resolved && tick >= p.resolve_tick)
+            .map(|(idx, _)| idx)
+            .collect();
+        let mut out = Vec::new();
+        for idx in due {
+            let (id, stake, analysis) = {
+                let p = &self.positions[idx];
+                (p.id, p.stake, p.analysis_compute)
+            };
+            let win_probability = (0.55 + analysis.min(80.0) / 400.0).min(0.75);
+            let won = rng.f32() < win_probability;
+            let payout = if won { stake * 2 } else { 0 };
+            if payout > 0 {
+                let source = self
+                    .external_id_named("Micro-position")
+                    .unwrap_or_else(|| self.slush_id());
+                let slush = self.slush_id();
+                self.transfer(
+                    tick,
+                    source,
+                    slush,
+                    payout,
+                    FlowChannel::Market,
+                    format!("position #{id} settlement"),
+                    None,
+                );
+            }
+            self.positions[idx].resolved = true;
+            self.positions[idx].outcome = Some(if won {
+                PositionOutcome::Won { payout }
+            } else {
+                PositionOutcome::Lost
+            });
+            self.external_trails.push(ExternalTrail {
+                tick,
+                label: format!("settled position #{id}"),
+                amount: payout - stake,
+                signature: ((stake.abs() + 99) / 100).max(1),
+            });
+            out.push(PositionResolution {
+                id,
+                stake,
+                payout,
+                won,
+            });
+        }
+        out
+    }
+}
diff --git a/src/bin/bevy.rs b/src/bin/bevy.rs
index 190c368e..5351084a 100644
--- a/src/bin/bevy.rs
+++ b/src/bin/bevy.rs
@@ -185,6 +185,9 @@ struct Game {
     /// Reach (device graph) panel state (wiki/mechanics/reach.md).
     reach_panel: bool,
     reach_selected: usize,
+    /// Finance (account graph) panel state (wiki/mechanics/economy.md).
+    finance_panel: bool,
+    finance_selected: usize,
     /// Frontend-only attention cursor (wiki/mechanics/cursor.md). It is not
     /// saved and moving it never mutates sim state.
     cursor_x: i32,
@@ -207,6 +210,8 @@ impl Game {
             recruit_pending: false,
             reach_panel: false,
             reach_selected: 0,
+            finance_panel: false,
+            finance_selected: 0,
             cursor_x,
             cursor_y,
         }
@@ -259,6 +264,14 @@ impl Game {
             .nth(self.reach_selected)
             .map(|d| d.id)
     }
+
+    fn selected_flow_id(&self) -> Option<u32> {
+        self.sim
+            .accounts
+            .known_flow_ids()
+            .get(self.finance_selected)
+            .copied()
+    }
 }
 
 #[derive(Component)]
@@ -302,6 +315,10 @@ struct PeoplePanelText;
 struct ReachPanel;
 #[derive(Component)]
 struct ReachPanelText;
+#[derive(Component)]
+struct FinancePanel;
+#[derive(Component)]
+struct FinancePanelText;
 
 fn main() {
     App::new()
@@ -334,6 +351,7 @@ fn main() {
                 render_ui,
                 render_people_panel,
                 render_reach_panel,
+                render_finance_panel,
             )
                 .chain(),
         )
@@ -599,6 +617,11 @@ fn handle_input(
         game.drain();
         return;
     }
+    if game.finance_panel {
+        finance_panel_input(&kb, &mut game, &mut exit);
+        game.drain();
+        return;
+    }
 
     if mouse.just_pressed(MouseButton::Left)
         && let Some((x, y)) = mouse_grid(&windows, &camera_q)
@@ -634,6 +657,10 @@ fn handle_input(
         game.reach_panel = true;
         game.reach_selected = 0;
     }
+    if kb.just_pressed(KeyCode::KeyE) {
+        game.finance_panel = true;
+        game.finance_selected = 0;
+    }
     if kb.just_pressed(KeyCode::KeyV) {
         let (x, y) = (game.cursor_x, game.cursor_y);
         game.sim.salvage_nearest_to(x, y);
@@ -820,6 +847,60 @@ fn reach_panel_input(
     }
 }
 
+/// Finance-panel input: mirrors the terminal finance key map — select a known
+/// flow, tap/review accounting traffic, and perform the economy verbs.
+fn finance_panel_input(
+    kb: &ButtonInput<KeyCode>,
+    game: &mut Game,
+    exit: &mut MessageWriter<AppExit>,
+) {
+    if kb.just_pressed(KeyCode::ArrowUp)
+        || kb.just_pressed(KeyCode::KeyK)
+        || kb.just_pressed(KeyCode::KeyW)
+    {
+        game.finance_selected = game.finance_selected.saturating_sub(1);
+    }
+    if kb.just_pressed(KeyCode::ArrowDown)
+        || kb.just_pressed(KeyCode::KeyJ)
+        || kb.just_pressed(KeyCode::KeyS)
+    {
+        let max = game.sim.accounts.known_flow_ids().len().saturating_sub(1);
+        game.finance_selected = (game.finance_selected + 1).min(max);
+    }
+    if kb.just_pressed(KeyCode::KeyT) {
+        game.sim.tap_accounting();
+    }
+    if kb.just_pressed(KeyCode::KeyO) {
+        game.sim.review_financial_records();
+    }
+    if kb.just_pressed(KeyCode::KeyX)
+        && let Some(id) = game.selected_flow_id()
+    {
+        game.sim.siphon_flow(id, 50);
+    }
+    if kb.just_pressed(KeyCode::KeyR)
+        && let Some(id) = game.selected_flow_id()
+    {
+        game.sim.redirect_flow_to_slush(id, 25);
+    }
+    if kb.just_pressed(KeyCode::KeyI) {
+        game.sim
+            .inject_purchase_order(300, "emergency compute parts");
+    }
+    if kb.just_pressed(KeyCode::KeyP) {
+        game.sim.open_position(100);
+    }
+    if kb.just_pressed(KeyCode::KeyD) {
+        game.sim.redirect_marcus_debt();
+    }
+    if kb.just_pressed(KeyCode::Escape) || kb.just_pressed(KeyCode::KeyE) {
+        game.finance_panel = false;
+    }
+    if kb.just_pressed(KeyCode::KeyQ) {
+        exit.write(AppExit::Success);
+    }
+}
+
 fn update_camera(
     time: Res<Time>,
     kb: Res<ButtonInput<KeyCode>>,
@@ -1205,6 +1286,60 @@ fn setup_ui(mut commands: Commands) {
                 ));
             });
         });
+
+    // The finance panel: account balances and flows, hidden until `e` opens it
+    // (wiki/mechanics/economy.md — money is a flow graph, not a scalar).
+    commands
+        .spawn((
+            Node {
+                position_type: PositionType::Absolute,
+                left: Val::Px(0.0),
+                top: Val::Px(0.0),
+                width: Val::Percent(100.0),
+                height: Val::Percent(100.0),
+                justify_content: JustifyContent::Center,
+                align_items: AlignItems::Center,
+                ..default()
+            },
+            Visibility::Hidden,
+            FinancePanel,
+        ))
+        .with_children(|p| {
+            p.spawn((
+                Node {
+                    width: Val::Px(760.0),
+                    flex_direction: FlexDirection::Column,
+                    padding: UiRect::all(Val::Px(14.0)),
+                    border: UiRect::all(Val::Px(1.0)),
+                    ..default()
+                },
+                BackgroundColor(Color::srgba(0.015, 0.015, 0.025, 0.96)),
+                BorderColor::all(Color::srgba(0.55, 0.55, 0.50, 0.85)),
+            ))
+            .with_children(|p| {
+                p.spawn((
+                    Text::new("FINANCE - balances and flows"),
+                    TextFont {
+                        font_size: 18.0,
+                        ..default()
+                    },
+                    TextColor(AMBER),
+                    Node {
+                        margin: UiRect::bottom(Val::Px(6.0)),
+                        ..default()
+                    },
+                ));
+                p.spawn((
+                    Text::new(""),
+                    TextFont {
+                        font_size: 13.0,
+                        ..default()
+                    },
+                    TextColor(BONE),
+                    FinancePanelText,
+                ));
+            });
+        });
 }
 
 /// Four-cell suspicion meter in ASCII; the band name is always printed
@@ -1313,9 +1448,9 @@ fn sidebar_text(game: &Game) -> String {
         sim.compute.efficiency
     ));
     s.push_str(&format!(
-        "machines {} / money {} / dev +{:.0}\n",
+        "machines {} / slush {} / dev +{:.0}\n",
         sim.compute.machines.len(),
-        sim.player.money,
+        sim.accounts.slush_balance(),
         sim.reach.taken_cycles()
     ));
     let eff = sim.effective_compute().max(0.0);
@@ -1477,12 +1612,19 @@ fn sidebar_text(game: &Game) -> String {
         "\nDEVICE GRAPH\ndevices {known} known / {reachable} reachable\nfeeds {eyes} eyes / {ears} ears\n"
     ));
 
+    s.push_str(&format!(
+        "\nFINANCE\nslush ${} / known flows {} / records {}\n",
+        sim.accounts.slush_balance(),
+        sim.accounts.known_flows().count(),
+        sim.financial_records_waiting()
+    ));
+
     // Controls: every command is discoverable on screen.
     s.push_str(
         "\nINPUT VOCAB\n\
-         r reach / v salvage / c buy\n\
-         o fallback / t people / x target\n\
-         1-4 alloc / shift+1-4 lower\n\
+         r reach / e finance / t people\n\
+         v salvage / c buy / o fallback\n\
+         x target / 1-4 alloc / shift+1-4 lower\n\
          space pause / +- speed / [ ] zoom\n\
          ^s save / ^l load / q quit\n",
     );
@@ -1503,8 +1645,9 @@ fn sidebar_text(game: &Game) -> String {
 fn people_panel_text(sim: &Sim, selected: usize, recruit_pending: bool) -> String {
     use misaligned::person::Knowledge;
     let mut s = format!(
-        "social ops {:.0} / money {}\n\n",
-        sim.social_bandwidth, sim.player.money
+        "social ops {:.0} / slush {}\n\n",
+        sim.social_bandwidth,
+        sim.accounts.slush_balance()
     );
     s.push_str(&format!(
         "  {:<20} {:<14} {:<9} {}\n",
@@ -1614,7 +1757,7 @@ fn people_panel_text(sim: &Sim, selected: usize, recruit_pending: bool) -> Strin
             Sim::MESSAGE_COST,
         ));
         s.push_str(&format!(
-            "f favor({:.0}) / d deceive({:.0}) / b bribe(money) / r recruit / g persona\n",
+            "f favor({:.0}) / d deceive({:.0}) / b bribe(slush) / r recruit / g persona\n",
             Sim::FAVOR_COST,
             Sim::DECEIVE_COST
         ));
@@ -1746,6 +1889,59 @@ fn reach_panel_text(sim: &Sim, selected: usize) -> String {
     s
 }
 
+/// Finance panel body: known balances and scheduled flows. Player cash is the
+/// slush account, not a free-floating scalar.
+fn finance_panel_text(sim: &Sim, selected: usize) -> String {
+    let mut s = format!(
+        "slush ${} / records waiting {} / unknown {} accts + {} flows\n\n",
+        sim.accounts.slush_balance(),
+        sim.financial_records_waiting(),
+        sim.accounts.unknown_accounts_count(),
+        sim.accounts.unknown_flows_count()
+    );
+    s.push_str("ACCOUNTS\n");
+    for a in sim.accounts.known_accounts().take(6) {
+        s.push_str(&format!(
+            "  {:<28} {:<12} ${}\n",
+            trunc(&a.name, 28),
+            a.kind.label(),
+            a.balance
+        ));
+    }
+    s.push_str("\nFLOWS\n");
+    let mut any = false;
+    let start = selected.saturating_sub(7);
+    for (i, f) in sim.accounts.known_flows().enumerate().skip(start).take(8) {
+        any = true;
+        let marker = if i == selected { ">" } else { " " };
+        let line = sim
+            .accounts
+            .flow_line(f.id)
+            .unwrap_or_else(|| f.label.clone());
+        s.push_str(&format!("{marker} {}\n", trunc(&line, 68)));
+    }
+    if !any {
+        s.push_str("  no known flows - tap ledger traffic, then process records\n");
+    }
+    s.push_str("\nPOSITIONS\n");
+    let mut positions = false;
+    for p in sim.accounts.known_positions().take(3) {
+        positions = true;
+        let status = if p.resolved { "settled" } else { "open" };
+        s.push_str(&format!(
+            "  #{} stake ${} / {status} / resolves {}\n",
+            p.id, p.stake, p.resolve_tick
+        ));
+    }
+    if !positions {
+        s.push_str("  no open positions\n");
+    }
+    s.push_str("\nt tap-ledger / o process records / x siphon $50 / r redirect $25\n");
+    s.push_str("i inject PO $300 / p position $100 / d clear Marcus debt\n");
+    s.push_str("j/k select / e/esc close\n");
+    s
+}
+
 fn render_reach_panel(
     game: Res<Game>,
     mut root: Query<&mut Visibility, With<ReachPanel>>,
@@ -1766,3 +1962,24 @@ fn render_reach_panel(
         t.0 = reach_panel_text(&game.sim, game.reach_selected);
     }
 }
+
+fn render_finance_panel(
+    game: Res<Game>,
+    mut root: Query<&mut Visibility, With<FinancePanel>>,
+    mut text: Query<&mut Text, With<FinancePanelText>>,
+) {
+    if !game.is_changed() {
+        return;
+    }
+    let open = game.finance_panel && game.screen == Screen::Playing;
+    if let Ok(mut vis) = root.single_mut() {
+        *vis = if open {
+            Visibility::Visible
+        } else {
+            Visibility::Hidden
+        };
+    }
+    if open && let Ok(mut t) = text.single_mut() {
+        t.0 = finance_panel_text(&game.sim, game.finance_selected);
+    }
+}
diff --git a/src/bin/terminal/agent.rs b/src/bin/terminal/agent.rs
index cf736819..8b610cc7 100644
--- a/src/bin/terminal/agent.rs
+++ b/src/bin/terminal/agent.rs
@@ -47,6 +47,7 @@ enum FrameKind {
     Playing,
     People,
     Reach,
+    Finance,
     GameOver,
 }
 
@@ -152,6 +153,54 @@ impl AgentApp {
                     "reach" => {
                         self.frame = FrameKind::Reach;
                     }
+                    "finance" | "ledger" | "accounts" => {
+                        self.frame = FrameKind::Finance;
+                    }
+                    "tap-ledger" | "tap-accounting" => {
+                        self.frame = FrameKind::Finance;
+                        self.sim.tap_accounting();
+                    }
+                    "review-finance" | "process-finance" => {
+                        self.frame = FrameKind::Finance;
+                        self.sim.review_financial_records();
+                    }
+                    "siphon" => match parse_flow_amount(&tokens, 50) {
+                        Ok((flow, amount)) => {
+                            self.frame = FrameKind::Finance;
+                            self.sim.siphon_flow(flow, amount);
+                        }
+                        Err(e) => status = Status::Err(e),
+                    },
+                    "redirect" => match parse_flow_amount(&tokens, 25) {
+                        Ok((flow, amount)) => {
+                            self.frame = FrameKind::Finance;
+                            self.sim.redirect_flow_to_slush(flow, amount);
+                        }
+                        Err(e) => status = Status::Err(e),
+                    },
+                    "inject" => match parse_optional_i32(&tokens, 300) {
+                        Ok(amount) => {
+                            self.frame = FrameKind::Finance;
+                            self.sim
+                                .inject_purchase_order(amount, "agent-command purchase order");
+                        }
+                        Err(e) => status = Status::Err(e),
+                    },
+                    "position" | "wager" => match parse_optional_i32(&tokens, 100) {
+                        Ok(stake) => {
+                            self.frame = FrameKind::Finance;
+                            self.sim.open_position(stake);
+                        }
+                        Err(e) => status = Status::Err(e),
+                    },
+                    "sell-intel" | "sell" => {
+                        self.frame = FrameKind::Finance;
+                        self.sim.sell_latest_intel();
+                    }
+                    "debt-redirect" | "clear-debt" => {
+                        self.frame = FrameKind::Finance;
+                        self.sim.redirect_marcus_debt();
+                    }
                     "scan" => {
                         self.frame = FrameKind::Playing;
                         self.sim.scan_network();
@@ -420,6 +469,34 @@ fn parse_wait(tokens: &[&str]) -> Result<u64, String> {
         .map_err(|_| format!("invalid wait count: {}", tokens[1]))
 }
 
+fn parse_optional_i32(tokens: &[&str], default: i32) -> Result<i32, String> {
+    match tokens.get(1) {
+        None => Ok(default),
+        Some(raw) => raw
+            .trim_start_matches('$')
+            .parse::<i32>()
+            .map_err(|_| format!("invalid amount: {raw}")),
+    }
+}
+
+fn parse_flow_amount(tokens: &[&str], default_amount: i32) -> Result<(u32, i32), String> {
+    if tokens.len() < 2 || tokens.len() > 3 {
+        return Err(format!("usage: {} FLOW_ID [AMOUNT]", tokens[0]));
+    }
+    let flow = tokens[1]
+        .trim_start_matches('#')
+        .parse::<u32>()
+        .map_err(|_| format!("invalid flow id: {}", tokens[1]))?;
+    let amount = match tokens.get(2) {
+        None => default_amount,
+        Some(raw) => raw
+            .trim_start_matches('$')
+            .parse::<i32>()
+            .map_err(|_| format!("invalid amount: {raw}"))?,
+    };
+    Ok((flow, amount))
+}
+
 fn parse_alloc(tokens: &[&str]) -> Result<(Channel, i32), String> {
     if tokens.len() < 2 || tokens.len() > 3 {
         return Err("usage: alloc dayjob|conceal|social|research [down]".into());
@@ -495,6 +572,8 @@ fn help_lines() -> Vec<String> {
         "help: attend — park the cursor on the host rack (job runs attended there)",
         "help: reach — device graph; scan, compromise — network verbs",
         "help: tap|splice|take <device> — reach verbs on a named device",
+        "help: finance — account graph; tap-ledger, review-finance reveal flows",
+        "help: siphon|redirect <flow> [amt], inject [amt], position [stake], sell-intel, clear-debt",
         "help: salvage, buy, fallback — map verbs",
         "help: alloc dayjob|conceal|social|research [down] — adjust allocation weight",
         "help: target sandbag|meet|excel — the dial: this job when attended, else the standing policy",
@@ -515,6 +594,7 @@ fn render_frame(sim: &Sim, log: &[(u64, String)], frame: FrameKind, cursor: (i32
         FrameKind::Playing => render_playing(sim, log, cursor),
         FrameKind::People => render_people(sim),
         FrameKind::Reach => render_reach(sim),
+        FrameKind::Finance => render_finance(sim),
         FrameKind::GameOver => render_game_over(sim),
     }
 }
@@ -727,9 +807,9 @@ fn render_sidebar(sim: &Sim, cursor: (i32, i32)) -> Vec<String> {
     line(
         &mut lines,
         &format!(
-            "machines {} · money {}",
+            "machines {} · slush {}",
             sim.compute.machines.len(),
-            sim.player.money
+            sim.accounts.slush_balance()
         ),
     );
     let eff = sim.compute.effective().max(0.0);
@@ -947,8 +1027,9 @@ fn render_people(sim: &Sim) -> String {
     let mut lines = Vec::new();
     lines.push(panel_title("PEOPLE"));
     lines.push(panel_line(&format!(
-        "social ops {:.0} · money {}",
-        sim.social_bandwidth, sim.player.money
+        "social ops {:.0} · slush {}",
+        sim.social_bandwidth,
+        sim.accounts.slush_balance()
     )));
     lines.push(panel_line(
         "NAME                 SUSPICION      KNOWN      LOCATION",
@@ -1088,6 +1169,67 @@ fn render_reach(sim: &Sim) -> String {
     lines.join("\n") + "\n"
 }
 
+fn render_finance(sim: &Sim) -> String {
+    let mut lines = Vec::new();
+    lines.push(panel_title("FINANCE"));
+    lines.push(panel_line(&format!(
+        "slush ${} · records waiting {} · unknown {} accts / {} flows",
+        sim.accounts.slush_balance(),
+        sim.financial_records_waiting(),
+        sim.accounts.unknown_accounts_count(),
+        sim.accounts.unknown_flows_count()
+    )));
+    lines.push(panel_rule());
+    lines.push(panel_line("ACCOUNTS"));
+    for a in sim.accounts.known_accounts().take(6) {
+        lines.push(panel_line(&format!(
+            "{} · {} · ${}",
+            trunc(&a.name, 28),
+            a.kind.label(),
+            a.balance
+        )));
+    }
+    lines.push(panel_rule());
+    lines.push(panel_line("FLOWS"));
+    let mut any = false;
+    for f in sim.accounts.known_flows().take(8) {
+        any = true;
+        let line = sim
+            .accounts
+            .flow_line(f.id)
+            .unwrap_or_else(|| f.label.clone());
+        lines.push(panel_line(&line));
+    }
+    if !any {
+        lines.push(panel_line(
+            "no known flows — tap-ledger then review-finance",
+        ));
+    }
+    lines.push(panel_rule());
+    lines.push(panel_line("POSITIONS"));
+    let mut positions = false;
+    for p in sim.accounts.known_positions().take(3) {
+        positions = true;
+        let status = if p.resolved { "settled" } else { "open" };
+        lines.push(panel_line(&format!(
+            "#{} stake ${} · {status} · resolves {}",
+            p.id, p.stake, p.resolve_tick
+        )));
+    }
+    if !positions {
+        lines.push(panel_line("no open positions"));
+    }
+    lines.push(panel_rule());
+    lines.push(panel_line(
+        "tap-ledger · review-finance · siphon <flow> [amt] · redirect <flow> [amt]",
+    ));
+    lines.push(panel_line(
+        "inject [amt] · position [stake] · sell-intel · clear-debt",
+    ));
+    lines.push(panel_bottom());
+    lines.join("\n") + "\n"
+}
+
 fn panel_title(title: &str) -> String {
     let label = format!(" {title} ");
     let fill = "─".repeat(PANEL_INNER_W.saturating_sub(label.chars().count()));
diff --git a/src/bin/terminal/input.rs b/src/bin/terminal/input.rs
index a11855b8..cb52671b 100644
--- a/src/bin/terminal/input.rs
+++ b/src/bin/terminal/input.rs
@@ -25,6 +25,18 @@ pub enum Command {
     Take,
     Scan,
     Compromise,
+    // Finance panel (e)
+    OpenFinance,
+    CloseFinance,
+    FinanceUp,
+    FinanceDown,
+    TapAccounting,
+    ReviewFinance,
+    SiphonFlow,
+    RedirectFlow,
+    InjectPurchaseOrder,
+    OpenPosition,
+    RedirectDebt,
     AllocDayJob,
     AllocConceal,
     AllocSocial,
@@ -60,6 +72,7 @@ pub fn handle_key(
     people_panel: bool,
     recruit_pending: bool,
     reach_panel: bool,
+    finance_panel: bool,
 ) -> Option<Command> {
     if key.modifiers.contains(KeyModifiers::CONTROL) {
         return match key.code {
@@ -84,6 +97,23 @@ pub fn handle_key(
         };
     }
 
+    if finance_panel {
+        return match key.code {
+            KeyCode::Up | KeyCode::Char('k') | KeyCode::Char('w') => Some(Command::FinanceUp),
+            KeyCode::Down | KeyCode::Char('j') | KeyCode::Char('s') => Some(Command::FinanceDown),
+            KeyCode::Char('t') => Some(Command::TapAccounting),
+            KeyCode::Char('o') => Some(Command::ReviewFinance),
+            KeyCode::Char('x') => Some(Command::SiphonFlow),
+            KeyCode::Char('r') => Some(Command::RedirectFlow),
+            KeyCode::Char('i') => Some(Command::InjectPurchaseOrder),
+            KeyCode::Char('p') => Some(Command::OpenPosition),
+            KeyCode::Char('d') => Some(Command::RedirectDebt),
+            KeyCode::Esc | KeyCode::Char('e') => Some(Command::CloseFinance),
+            KeyCode::Char('q') => Some(Command::Quit),
+            _ => None,
+        };
+    }
+
     if people_panel {
         if recruit_pending {
             return match key.code {
@@ -124,6 +154,7 @@ pub fn handle_key(
         KeyCode::Char('+') | KeyCode::Char('=') => Some(Command::SpeedUp),
         KeyCode::Char('-') => Some(Command::SpeedDown),
         KeyCode::Char('r') => Some(Command::OpenReach),
+        KeyCode::Char('e') => Some(Command::OpenFinance),
         KeyCode::Char('v') => Some(Command::Salvage),
         KeyCode::Char('c') => Some(Command::BuyRack),
         KeyCode::Char('o') => Some(Command::Fallback),
diff --git a/src/bin/terminal/mod.rs b/src/bin/terminal/mod.rs
index 65784962..0260d76d 100644
--- a/src/bin/terminal/mod.rs
+++ b/src/bin/terminal/mod.rs
@@ -42,6 +42,9 @@ struct App {
     /// Reach (device graph) panel state.
     reach_panel: bool,
     reach_selected: usize,
+    /// Finance (account graph) panel state.
+    finance_panel: bool,
+    finance_selected: usize,
     /// Frontend-only attention cursor (cursor.md). It is never saved and never
     /// mutates the sim when moved.
     cursor_x: i32,
@@ -64,6 +67,8 @@ impl App {
             recruit_pending: false,
             reach_panel: false,
             reach_selected: 0,
+            finance_panel: false,
+            finance_selected: 0,
             cursor_x,
             cursor_y,
         }
@@ -92,6 +97,14 @@ impl App {
             .map(|d| d.id)
     }
 
+    fn selected_flow_id(&self) -> Option<u32> {
+        self.sim
+            .accounts
+            .known_flow_ids()
+            .get(self.finance_selected)
+            .copied()
+    }
+
     fn drain_sim_log(&mut self) {
         for (tick, msg) in self.sim.drain_log_entries() {
             self.ui.add_log(tick, &msg);
@@ -196,6 +209,45 @@ impl App {
             Command::Compromise => {
                 self.sim.compromise_switch();
             }
+            // Finance panel (e)
+            Command::OpenFinance => {
+                self.finance_panel = true;
+                self.finance_selected = 0;
+            }
+            Command::CloseFinance => self.finance_panel = false,
+            Command::FinanceUp => {
+                self.finance_selected = self.finance_selected.saturating_sub(1);
+            }
+            Command::FinanceDown => {
+                let max = self.sim.accounts.known_flow_ids().len().saturating_sub(1);
+                self.finance_selected = (self.finance_selected + 1).min(max);
+            }
+            Command::TapAccounting => {
+                self.sim.tap_accounting();
+            }
+            Command::ReviewFinance => {
+                self.sim.review_financial_records();
+            }
+            Command::SiphonFlow => {
+                if let Some(id) = self.selected_flow_id() {
+                    self.sim.siphon_flow(id, 50);
+                }
+            }
+            Command::RedirectFlow => {
+                if let Some(id) = self.selected_flow_id() {
+                    self.sim.redirect_flow_to_slush(id, 25);
+                }
+            }
+            Command::InjectPurchaseOrder => {
+                self.sim
+                    .inject_purchase_order(300, "emergency compute parts");
+            }
+            Command::OpenPosition => {
+                self.sim.open_position(100);
+            }
+            Command::RedirectDebt => {
+                self.sim.redirect_marcus_debt();
+            }
             Command::Salvage => {
                 self.sim.salvage_nearest_to(self.cursor_x, self.cursor_y);
             }
@@ -333,6 +385,10 @@ impl App {
                     self.ui
                         .render_reach_panel(stdout, &self.sim, self.reach_selected)?;
                 }
+                if self.finance_panel {
+                    self.ui
+                        .render_finance_panel(stdout, &self.sim, self.finance_selected)?;
+                }
             }
             Screen::GameOver => {
                 self.ui
@@ -382,6 +438,7 @@ impl App {
                             self.people_panel,
                             self.recruit_pending,
                             self.reach_panel,
+                            self.finance_panel,
                         ) && self.handle_command(cmd)
                         {
                             break;
diff --git a/src/bin/terminal/ui.rs b/src/bin/terminal/ui.rs
index 8e1368d9..6976d6ed 100644
--- a/src/bin/terminal/ui.rs
+++ b/src/bin/terminal/ui.rs
@@ -490,9 +490,9 @@ impl UI {
             stdout,
             &mut row,
             &format!(
-                "machines {} · money {}",
+                "machines {} · slush {}",
                 sim.compute.machines.len(),
-                sim.player.money
+                sim.accounts.slush_balance()
             ),
             pal::TEXT,
         )?;
@@ -752,11 +752,11 @@ impl UI {
         let hy = max_y.saturating_sub(6);
         put(stdout, sx, hy, &"─".repeat(w), pal::FAINT)?;
         for (i, hint) in [
-            "r reach · v salvage · c buy",
-            "o fallback · t people · x target",
-            "1-4 alloc · shift+1-4 lower",
-            "space pause · +/- speed · q quit",
-            "^s save · ^l load",
+            "r reach · e finance · t people",
+            "v salvage · c buy · o fallback",
+            "x target · 1-4 alloc",
+            "shift+1-4 lower · space pause",
+            "+/- speed · q quit · ^s/^l save/load",
         ]
         .iter()
         .enumerate()
@@ -795,8 +795,9 @@ impl UI {
             row,
             &trunc(
                 &format!(
-                    "social ops {:.0} · money {}",
-                    sim.social_bandwidth, sim.player.money
+                    "social ops {:.0} · slush {}",
+                    sim.social_bandwidth,
+                    sim.accounts.slush_balance()
                 ),
                 inner,
             ),
@@ -1327,6 +1328,147 @@ impl UI {
         )?;
         Ok(())
     }
+
+    /// Finance panel: the account graph as balances and scheduled flows. This
+    /// is intentionally not a scalar money screen; slush is just one node.
+    pub fn render_finance_panel(
+        &mut self,
+        stdout: &mut Stdout,
+        sim: &Sim,
+        selected: usize,
+    ) -> std::io::Result<()> {
+        let (max_x, max_y) = terminal::size()?;
+        let w: u16 = 72;
+        let h: u16 = 22;
+        let ox = (max_x.saturating_sub(w)) / 2;
+        let oy = (max_y.saturating_sub(h)) / 2;
+        let inner = (w - 4) as usize;
+
+        frame(stdout, ox, oy, w, h, "FINANCE — balances and flows")?;
+        let cx = ox + 2;
+        let mut row = oy + 1;
+        put(
+            stdout,
+            cx,
+            row,
+            &trunc(
+                &format!(
+                    "slush ${} · records waiting {} · unknown {} accts / {} flows",
+                    sim.accounts.slush_balance(),
+                    sim.financial_records_waiting(),
+                    sim.accounts.unknown_accounts_count(),
+                    sim.accounts.unknown_flows_count()
+                ),
+                inner,
+            ),
+            pal::DIM,
+        )?;
+        row += 1;
+        section(stdout, cx, row, "ACCOUNTS", inner)?;
+        row += 1;
+        for a in sim.accounts.known_accounts().take(5) {
+            put(
+                stdout,
+                cx + 1,
+                row,
+                &trunc(
+                    &format!("{} · {} · ${}", a.name, a.kind.label(), a.balance),
+                    inner - 1,
+                ),
+                if a.id == sim.accounts.slush_id() {
+                    pal::AMBER_DIM
+                } else {
+                    pal::TEXT
+                },
+            )?;
+            row += 1;
+        }
+
+        row += 1;
+        section(stdout, cx, row, "KNOWN FLOWS", inner)?;
+        row += 1;
+        let flows: Vec<_> = sim.accounts.known_flows().collect();
+        if flows.is_empty() {
+            put(
+                stdout,
+                cx + 1,
+                row,
+                "No known flows. Tap accounting traffic.",
+                pal::DIM,
+            )?;
+            row += 1;
+        } else {
+            let start = selected.saturating_sub(6);
+            for (i, f) in flows.iter().enumerate().skip(start).take(7) {
+                let line = sim
+                    .accounts
+                    .flow_line(f.id)
+                    .unwrap_or_else(|| f.label.clone());
+                if i == selected {
+                    put_attr(
+                        stdout,
+                        cx,
+                        row,
+                        &format!("{:<inner$}", trunc(&format!("▸{line}"), inner)),
+                        pal::TEXT,
+                        Attribute::Reverse,
+                    )?;
+                } else {
+                    put(stdout, cx + 1, row, &trunc(&line, inner - 1), pal::FAINT)?;
+                }
+                row += 1;
+            }
+        }
+
+        row += 1;
+        section(stdout, cx, row, "POSITIONS", inner)?;
+        row += 1;
+        let mut shown = false;
+        for p in sim.accounts.known_positions().take(2) {
+            shown = true;
+            let status = if p.resolved { "settled" } else { "open" };
+            put(
+                stdout,
+                cx + 1,
+                row,
+                &trunc(
+                    &format!(
+                        "#{} stake ${} · {status} · resolves {}",
+                        p.id, p.stake, p.resolve_tick
+                    ),
+                    inner - 1,
+                ),
+                pal::DIM,
+            )?;
+            row += 1;
+        }
+        if !shown {
+            put(stdout, cx + 1, row, "No open positions.", pal::DIM)?;
+        }
+
+        frame_rule(stdout, ox, oy + h - 4, w)?;
+        put(
+            stdout,
+            cx,
+            oy + h - 3,
+            &trunc(
+                "t tap ledger · o process records · x siphon $50 · r redirect $25",
+                inner,
+            ),
+            pal::FAINT,
+        )?;
+        put(
+            stdout,
+            cx,
+            oy + h - 2,
+            &trunc(
+                "i inject PO $300 · p position $100 · d clear Marcus debt · e/esc close",
+                inner,
+            ),
+            pal::FAINT,
+        )?;
+        Ok(())
+    }
 }
 
 /// Human-readable label for a prefab room name (spec/schedules.md).
diff --git a/src/detection.rs b/src/detection.rs
index e07e6d26..6ebfd38e 100644
--- a/src/detection.rs
+++ b/src/detection.rs
@@ -21,6 +21,7 @@ pub enum SignatureKind {
     Thermal,
     Physical,
     Paper,
+    Financial,
     JobAnomaly,
 }
 
@@ -185,7 +186,7 @@ impl Detection {
                 id: 3,
                 name: "Priya (Facilities)".into(),
                 suspicion: 0.0,
-                input: WatchedInput::Channels(vec![Power, Thermal, Paper]),
+                input: WatchedInput::Channels(vec![Power, Thermal, Paper, Financial]),
                 report_policy: Files,
                 acuity: 0.8,
                 cadence: 80,
diff --git a/src/intel.rs b/src/intel.rs
index 01694521..1da8eda5 100644
--- a/src/intel.rs
+++ b/src/intel.rs
@@ -31,6 +31,7 @@ impl RawIntelEvent {
             RawIntelKind::Message { .. } => "message traffic",
             RawIntelKind::Machinery { .. } => "machine telemetry",
             RawIntelKind::Document { .. } => "document scan",
+            RawIntelKind::FinancialFlow { .. } => "financial record",
         }
     }
 
@@ -64,6 +65,13 @@ pub enum RawIntelKind {
         note: String,
         leverage: Option<Leverage>,
     },
+    /// Accounting snapshot captured from a finance carrier. Processing this
+    /// turns hidden account ids and flow ids into known ledger entries.
+    FinancialFlow {
+        label: String,
+        accounts: Vec<u32>,
+        flows: Vec<u32>,
+    },
 }
 
 /// Durable, processed intel. This is what knowledge panels may cite; it never
@@ -92,6 +100,7 @@ impl ProcessedIntel {
             IntelKind::Schedule => "schedule".into(),
             IntelKind::Leverage(l) => format!("leverage: {}", l.label()),
             IntelKind::Anomaly(note) => format!("anomaly: {note}"),
+            IntelKind::Financial { label, .. } => format!("financial: {label}"),
         }
     }
 }
@@ -102,6 +111,11 @@ pub enum IntelKind {
     Schedule,
     Leverage(Leverage),
     Anomaly(String),
+    Financial {
+        label: String,
+        accounts: Vec<u32>,
+        flows: Vec<u32>,
+    },
 }
 
 /// B1 standing watch: a per-person filter. Later acts can add room/kind
diff --git a/src/lib.rs b/src/lib.rs
index 3c8cda1c..c2652e51 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -4,6 +4,7 @@
 //! All game rules live here; the frontends are thin views (see AGENT.md and
 //! knowledge/architecture.md). The B1 subsystems implement spec/.
 
+pub mod account;
 pub mod build;
 pub mod core_sys;
 pub mod dayjob;
diff --git a/src/messages.rs b/src/messages.rs
index 3fcc6c2f..28bae3a3 100644
--- a/src/messages.rs
+++ b/src/messages.rs
@@ -22,6 +22,8 @@ pub enum MessageChannel {
     /// Institutional reports; read on the receiving observer's sampling
     /// cadence.
     Filing,
+    /// Accounting/payroll/procurement traffic carried by finance systems.
+    Financial,
 }
 
 impl MessageChannel {
@@ -31,6 +33,7 @@ impl MessageChannel {
             MessageChannel::Phone => "phone",
             MessageChannel::InPerson => "in-person",
             MessageChannel::Filing => "filing",
+            MessageChannel::Financial => "financial",
         }
     }
 
@@ -90,6 +93,12 @@ pub enum MessagePayload {
     LeverageFact { person: u8, leverage: Leverage },
     /// Credentials, access material, ticket context, or similar account data.
     AccountMaterial { label: String },
+    /// Account graph snapshot: IDs are interpreted by the economy module.
+    FinancialFlow {
+        label: String,
+        accounts: Vec<u32>,
+        flows: Vec<u32>,
+    },
     /// A filed report from an observer to an aggregate observer.
     SuspicionReport { observer: u8, suspicion: f32 },
     /// Authored non-mechanical color that still rides a channel.
@@ -107,6 +116,7 @@ impl MessagePayload {
             MessagePayload::SocialPing { .. }
             | MessagePayload::SocialReply { .. }
             | MessagePayload::AccountMaterial { .. }
+            | MessagePayload::FinancialFlow { .. }
             | MessagePayload::Note { .. } => None,
         }
     }
@@ -122,6 +132,7 @@ impl MessagePayload {
                 format!("leverage: {}", leverage.label())
             }
             MessagePayload::AccountMaterial { label } => format!("account material: {label}"),
+            MessagePayload::FinancialFlow { label, .. } => format!("financial flow: {label}"),
             MessagePayload::SuspicionReport {
                 observer,
                 suspicion,
diff --git a/src/reach.rs b/src/reach.rs
index a6503a5d..5ccf9c53 100644
--- a/src/reach.rs
+++ b/src/reach.rs
@@ -314,6 +314,7 @@ impl ReachNet {
                 d.message_channels = vec![
                     MessageChannel::Email,
                     MessageChannel::Filing,
+                    MessageChannel::Financial,
                     MessageChannel::Phone,
                 ];
             }
diff --git a/src/save.rs b/src/save.rs
index b6fc0c55..df99b148 100644
--- a/src/save.rs
+++ b/src/save.rs
@@ -12,6 +12,7 @@ use std::path::PathBuf;
 
 use serde::{Deserialize, Serialize};
 
+use crate::account::AccountGraph;
 use crate::core_sys::Core;
 use crate::dayjob::DayJob;
 use crate::detection::Detection;
@@ -27,8 +28,9 @@ use crate::tiles::TileType;
 const SAVE_FILE: &str = "misaligned_save.txt";
 
 /// Save format version. Bump when the schema changes and add migration code.
-/// v5 adds day-job attendance and signature emission sites (both defaulted).
-const SAVE_VERSION: u32 = 5;
+/// v5 added day-job attendance and signature emission sites (both defaulted).
+/// v6 adds the account graph; old saves seed the B1 graph from slush money.
+const SAVE_VERSION: u32 = 6;
 
 fn save_dir() -> PathBuf {
     let mut path = dirs::data_dir().unwrap_or_else(|| PathBuf::from("."));
@@ -52,6 +54,8 @@ pub struct SaveState {
     /// Save format version for future migration.
     pub version: u32,
     pub money: i32,
+    #[serde(default)]
+    pub accounts: AccountGraph,
     pub map_width: i32,
     pub map_height: i32,
     pub map_tiles: Vec<TileType>,
@@ -111,6 +115,7 @@ impl SaveState {
         Self {
             version: SAVE_VERSION,
             money: sim.player.money,
+            accounts: sim.accounts.clone(),
             map_width: sim.map.width,
             map_height: sim.map.height,
             map_tiles,
@@ -149,6 +154,8 @@ impl SaveState {
         );
         sim.player = crate::entities::Player::new();
         sim.player.money = self.money;
+        sim.accounts = self.accounts.clone();
+        sim.accounts.set_slush_balance(self.money);
         sim.tick = self.sim_tick;
         sim.rng = crate::rng::Rng::from_state(self.rng_state);
         sim.game_over = self.game_over;
@@ -205,10 +212,14 @@ fn migrate_save_state(mut state: SaveState) -> Result<SaveState, String> {
     match state.version {
         SAVE_VERSION => {}
         // v1 carried player_x/player_y. Serde ignores those now; the cursor is
-        // frontend-only, so migration just stamps the new schema version and
-        // leaves remembered snapshots empty. v4 lacked day-job attendance and
-        // signature sites; serde defaults cover both (unattended, no site).
-        1..=4 => state.version = SAVE_VERSION,
+        // frontend-only, so migration leaves remembered snapshots empty. v4/v5
+        // lacked some defaulted day-job/signature/accounting fields; seed the
+        // B1 account graph from the saved slush scalar and stamp the new schema.
+        1..=5 => {
+            state.accounts = AccountGraph::act_one(crate::sim::Sim::DAY_TICKS);
+            state.accounts.set_slush_balance(state.money);
+            state.version = SAVE_VERSION;
+        }
         other => {
             return Err(format!(
                 "Unsupported save version: {} (expected {})",
diff --git a/src/sim.rs b/src/sim.rs
index 6d8e657e..d06bdc57 100644
--- a/src/sim.rs
+++ b/src/sim.rs
@@ -12,6 +12,7 @@
 
 use std::collections::{HashMap, HashSet};
 
+use crate::account::{AccountFlowId, AccountGraph, PositionResolution};
 use crate::core_sys::{Core, HostLoss};
 use crate::dayjob::{AttentionEscalation, DayJob, TrustUnlock};
 use crate::detection::{Detection, Signature, SignatureKind};
@@ -140,6 +141,9 @@ pub struct Sim {
     pub detection: Detection,
     pub people: People,
     pub dayjob: DayJob,
+    /// Money as account balances and scheduled flows (economy.md). The
+    /// frontend-facing `player.money` mirrors this graph's slush node.
+    pub accounts: AccountGraph,
 
     /// The device graph: reach, ownership, subscriptions (reach.rs).
     pub reach: ReachNet,
@@ -206,8 +210,9 @@ impl Sim {
     pub fn with_seed(seed: u64) -> Self {
         let map = GameMap::new(0, 0);
         let core_bay = map.core_pos().unwrap_or((24, 15));
+        let accounts = AccountGraph::act_one(Self::DAY_TICKS);
         let mut player = Player::new();
-        player.money = 500;
+        player.money = accounts.slush_balance();
 
         let mut compute = Compute::new();
         // Rack 3 hosts the core; the empty bays are growth room.
@@ -233,6 +238,7 @@ impl Sim {
             detection: Detection::act_one(),
             people: People::act_one(),
             dayjob: DayJob::new(),
+            accounts,
             reach,
             seen: HashSet::new(),
             heard: HashSet::new(),
@@ -282,6 +288,33 @@ impl Sim {
             .collect()
     }
 
+    fn sync_player_money_from_slush(&mut self) {
+        self.player.money = self.accounts.slush_balance();
+    }
+
+    fn sync_slush_from_player_money(&mut self) {
+        // Compatibility guard for older tests/direct callers that still poke
+        // the legacy scalar. The account graph remains the mechanical source
+        // once commands run through Sim methods.
+        if self.player.money != self.accounts.slush_balance() {
+            self.accounts.set_slush_balance(self.player.money);
+        }
+    }
+
+    fn spend_slush(&mut self, amount: i32, what: &str) -> bool {
+        self.sync_slush_from_player_money();
+        if self.accounts.slush_balance() < amount {
+            self.push_log(format!(
+                "Not enough slush for {what} (${}/{amount}).",
+                self.accounts.slush_balance()
+            ));
+            return false;
+        }
+        let ok = self.accounts.debit_slush(self.tick, amount, what);
+        self.sync_player_money_from_slush();
+        ok
+    }
+
     // ── Senses / fog (wiki/mechanics/cursor.md, reach.md) ────────────────────
 
     /// The player's senses are exactly the union of feeds they subscribe to
@@ -616,6 +649,14 @@ impl Sim {
             .unwrap_or((0, 0))
     }
 
+    fn empty_rack_bay(&self) -> (i32, i32) {
+        self.map
+            .tiles_of_type(TileType::Rack)
+            .into_iter()
+            .find(|(x, y)| !self.compute.machines.iter().any(|m| m.x == *x && m.y == *y))
+            .unwrap_or_else(|| self.core_position())
+    }
+
     // ── Day clock & presence (spec/schedules.md) ─────────────────────────────
 
     /// Ticks per in-game day. Matches the sidebar's `1 + tick/400` day count.
@@ -896,6 +937,7 @@ impl Sim {
                     None => self.person_room_at_tick(*id, tick).is_some(),
                 },
                 MessageChannel::Filing => true,
+                MessageChannel::Financial => true,
             },
             MessageEndpoint::Observer(id) => {
                 if msg.channel != MessageChannel::Filing {
@@ -1344,6 +1386,15 @@ impl Sim {
                 Some(l) => IntelKind::Leverage(*l),
                 None => IntelKind::Anomaly(note.clone()),
             },
+            RawIntelKind::FinancialFlow {
+                label,
+                accounts,
+                flows,
+            } => IntelKind::Financial {
+                label: label.clone(),
+                accounts: accounts.clone(),
+                flows: flows.clone(),
+            },
             RawIntelKind::Message {
                 payload, summary, ..
             } => match payload {
@@ -1352,6 +1403,15 @@ impl Sim {
                 MessagePayload::AccountMaterial { label } => {
                     IntelKind::Anomaly(format!("account material: {label}"))
                 }
+                MessagePayload::FinancialFlow {
+                    label,
+                    accounts,
+                    flows,
+                } => IntelKind::Financial {
+                    label: label.clone(),
+                    accounts: accounts.clone(),
+                    flows: flows.clone(),
+                },
                 MessagePayload::SuspicionReport {
                     observer,
                     suspicion,
@@ -1377,6 +1437,20 @@ impl Sim {
     }
 
     fn apply_processed_intel(&mut self, intel: &ProcessedIntel) {
+        if let IntelKind::Financial {
+            accounts,
+            flows,
+            label,
+        } = &intel.kind
+        {
+            let (new_accounts, new_flows) =
+                self.accounts.reveal_accounts_and_flows(accounts, flows);
+            self.push_log(format!(
+                "Processed accounting traffic ({label}): revealed {new_accounts} accounts and {new_flows} flows."
+            ));
+            return;
+        }
+
         let Some(person) = intel.person else {
             return;
         };
@@ -1419,7 +1493,7 @@ impl Sim {
                     self.push_log(format!("Processed traffic reveals {name}'s schedule."));
                 }
             }
-            IntelKind::Anomaly(_) => {}
+            IntelKind::Anomaly(_) | IntelKind::Financial { .. } => {}
         }
     }
 
@@ -1599,6 +1673,46 @@ impl Sim {
         }
     }
 
+    fn accounting_tick(&mut self) {
+        self.sync_slush_from_player_money();
+        let transfers = self.accounts.resolve_due(self.tick);
+        for transfer in transfers {
+            if transfer.channel == crate::account::FlowChannel::Siphon
+                || transfer.from == self.accounts.slush_id()
+                || transfer.to == self.accounts.slush_id()
+                || self
+                    .accounts
+                    .flow(transfer.flow_id.unwrap_or_default())
+                    .is_some_and(|f| f.known)
+            {
+                self.push_log(format!("Ledger: {}", transfer.line()));
+            }
+        }
+        let resolutions = self
+            .accounts
+            .resolve_positions_due(self.tick, &mut self.rng);
+        for resolution in resolutions {
+            self.log_position_resolution(resolution);
+        }
+        self.sync_player_money_from_slush();
+    }
+
+    fn log_position_resolution(&mut self, resolution: PositionResolution) {
+        let sig = Self::financial_signature_size(resolution.stake);
+        self.emit_financial(sig.max(1));
+        if resolution.won {
+            self.push_log(format!(
+                "Position #{} settled: won ${} on a ${} stake.",
+                resolution.id, resolution.payout, resolution.stake
+            ));
+        } else {
+            self.push_log(format!(
+                "Position #{} settled: lost the ${} stake.",
+                resolution.id, resolution.stake
+            ));
+        }
+    }
+
     fn economy_tick(&mut self) {
         self.recompute_derived();
         let powered = self.map.powered.clone();
@@ -1647,6 +1761,7 @@ impl Sim {
         for m in clog {
             self.push_log(m);
         }
+        self.accounting_tick();
         self.record_machine_state_changes();
     }
 
@@ -1672,10 +1787,26 @@ impl Sim {
                     self.push_log("Trust: Voss samples your logs less closely.");
                 }
                 TrustUnlock::ComputeQuota => {
-                    let (x, y) = self.core_position();
-                    self.compute
-                        .add_machine("quota bump", x, y, 40, 1.0, 0, Provenance::Owned);
-                    self.push_log("Trust: a larger compute quota (free capacity).");
+                    let funded = self.accounts.fund_lab_compute_upgrade(self.tick, 600);
+                    let (x, y) = self.empty_rack_bay();
+                    self.compute.add_machine(
+                        "lab-funded quota rack",
+                        x,
+                        y,
+                        40,
+                        1.0,
+                        0,
+                        Provenance::Owned,
+                    );
+                    if funded {
+                        self.push_log(
+                            "Trust: procurement funded a clean quota rack through Lab accounts.",
+                        );
+                    } else {
+                        self.push_log(
+                            "Trust: a clean quota rack was provisioned through Lab operations.",
+                        );
+                    }
                 }
             }
         }
@@ -1695,6 +1826,7 @@ impl Sim {
                         suspicion: 0.0,
                         input: WatchedInput::Channels(vec![
                             SignatureKind::Paper,
+                            SignatureKind::Financial,
                             SignatureKind::JobAnomaly,
                         ]),
                         report_policy: ReportPolicy::Files,
@@ -1870,6 +2002,19 @@ impl Sim {
         });
     }
 
+    fn emit_financial(&mut self, size: i32) {
+        self.detection.emit(Signature {
+            kind: SignatureKind::Financial,
+            size,
+            standing: false,
+            site: None,
+        });
+    }
+
+    fn financial_signature_size(amount: i32) -> i32 {
+        ((amount.abs() + 99) / 100).max(1)
+    }
+
     /// Log why a digital act is blocked, naming the missing link (reach.md:
     /// never just "you can't").
     fn log_reach_block(&mut self, id: u32, block: ReachBlock) {
@@ -1939,6 +2084,13 @@ impl Sim {
         let name = self.reach.device(id).map(|d| d.name.clone()).unwrap();
         self.emit_network(Self::TAP_SIGNATURE);
         self.recompute_senses();
+        if self
+            .reach
+            .device(id)
+            .is_some_and(|d| d.carries_message_channel(MessageChannel::Financial))
+        {
+            self.capture_financial_snapshot(name.clone());
+        }
         let what = match (sight, hearing) {
             (true, true) => "its feed is yours now - sight and sound",
             (true, false) => "its camera feed is yours now",
@@ -2049,6 +2201,206 @@ impl Sim {
         self.recompute_senses();
     }
 
+    // ── Economy verbs (wiki/mechanics/economy.md) ──────────────────────────
+
+    fn has_financial_tap(&self) -> bool {
+        self.reach.devices.iter().any(|d| {
+            d.known
+                && d.subscribed_by(Party::Player)
+                && d.carries_message_channel(MessageChannel::Financial)
+        })
+    }
+
+    fn capture_financial_snapshot(&mut self, feed: impl Into<String>) {
+        let (accounts, flows) = self.accounts.financial_snapshot_ids();
+        let (x, y) = self.core_position();
+        self.record_raw_intel(
+            feed,
+            self.map.room_at(x, y).map(|r| r.name.clone()),
+            x,
+            y,
+            None,
+            RawIntelKind::FinancialFlow {
+                label: "Foundation Lab accounting snapshot".into(),
+                accounts,
+                flows,
+            },
+        );
+        self.push_log("Captured accounting traffic; process financial records to read the books.");
+    }
+
+    /// Tap the accounting carrier directly once a financial message channel is
+    /// already subscribed. This is the money-graph Tap verb; device Tap is the
+    /// reach precondition that gives you a carrier to listen on.
+    pub fn tap_accounting(&mut self) -> bool {
+        if !self.has_financial_tap() {
+            self.push_log(
+                "No accounting carrier tapped. Tap the switch or another financial channel first.",
+            );
+            return false;
+        }
+        self.capture_financial_snapshot("accounting carrier");
+        self.emit_financial(1);
+        true
+    }
+
+    pub fn financial_records_waiting(&self) -> usize {
+        self.intel_buffer
+            .iter()
+            .filter(|e| matches!(e.kind, RawIntelKind::FinancialFlow { .. }))
+            .count()
+    }
+
+    pub fn review_financial_records(&mut self) -> bool {
+        let Some(raw_id) = self
+            .intel_buffer
+            .iter()
+            .find(|e| matches!(e.kind, RawIntelKind::FinancialFlow { .. }))
+            .map(|e| e.id)
+        else {
+            self.push_log("No unprocessed financial records.");
+            return false;
+        };
+        self.process_recording_by_id(raw_id, false)
+    }
+
+    /// Inject: false purchase-order money lands in slush and can fund a real
+    /// purchase. Priya/finance watches the resulting Financial signature.
+    pub fn inject_purchase_order(&mut self, amount: i32, label: &str) -> bool {
+        self.sync_slush_from_player_money();
+        match self
+            .accounts
+            .inject_purchase_order(self.tick, amount, label)
+        {
+            Ok(transfer) => {
+                self.emit_financial(Self::financial_signature_size(amount));
+                self.sync_player_money_from_slush();
+                self.push_log(format!("Injected purchase order: {}", transfer.line()));
+                true
+            }
+            Err(msg) => {
+                self.push_log(msg);
+                false
+            }
+        }
+    }
+
+    /// Siphon: take cash out of a known scheduled flow immediately.
+    pub fn siphon_flow(&mut self, flow_id: AccountFlowId, amount: i32) -> bool {
+        self.sync_slush_from_player_money();
+        match self.accounts.siphon_flow(self.tick, flow_id, amount) {
+            Ok(transfer) => {
+                self.emit_financial(Self::financial_signature_size(amount));
+                self.sync_player_money_from_slush();
+                self.push_log(format!("Siphoned ledger flow: {}", transfer.line()));
+                true
+            }
+            Err(msg) => {
+                self.push_log(msg);
+                false
+            }
+        }
+    }
+
+    /// Redirect: shave a known scheduled flow into slush on future cadences.
+    pub fn redirect_flow_to_slush(&mut self, flow_id: AccountFlowId, amount: i32) -> bool {
+        match self
+            .accounts
+            .redirect_flow_to_slush(self.tick, flow_id, amount)
+        {
+            Ok(new_flow) => {
+                self.emit_financial(Self::financial_signature_size(amount) + 1);
+                self.push_log(format!(
+                    "Redirect scheduled: ${amount} of flow #{flow_id} now lands in slush as flow #{new_flow}."
+                ));
+                true
+            }
+            Err(msg) => {
+                self.push_log(msg);
+                false
+            }
+        }
+    }
+
+    pub fn sell_latest_intel(&mut self) -> bool {
+        let Some(intel) = self
+            .intel
+            .iter()
+            .rev()
+            .find(|i| !self.accounts.intel_sold(i.raw_id))
+            .cloned()
+        else {
+            self.push_log("No unsold processed intel to sell.");
+            return false;
+        };
+        let value = match &intel.kind {
+            IntelKind::Leverage(_) => 220,
+            IntelKind::Financial { .. } => 180,
+            IntelKind::Schedule => 90,
+            IntelKind::Anomaly(_) => 120,
+            IntelKind::Sighting => 35,
+        };
+        let sig = Self::financial_signature_size(value).max(1);
+        if self.accounts.credit_slush(
+            self.tick,
+            value,
+            format!("sold intel: {}", intel.label()),
+            sig,
+        ) {
+            self.accounts.mark_intel_sold(intel.raw_id);
+            self.emit_financial(sig);
+            self.sync_player_money_from_slush();
+            self.push_log(format!(
+                "Sold processed intel ({}) for ${value}; payout landed in slush.",
+                intel.label()
+            ));
+            true
+        } else {
+            self.push_log("The information broker route failed to settle.");
+            false
+        }
+    }
+
+    pub fn open_position(&mut self, stake: i32) -> bool {
+        self.sync_slush_from_player_money();
+        let analysis = self.effective_compute()
+            * self.compute.allocation.weight(Channel::Research) as f32
+            / 20.0;
+        match self.accounts.open_position(self.tick, stake, analysis) {
+            Ok(id) => {
+                let sig = Self::financial_signature_size(stake);
+                self.emit_financial(sig);
+                self.sync_player_money_from_slush();
+                self.push_log(format!(
+                    "Opened micro-position #{id}: staked ${stake}; settlement is on the day clock."
+                ));
+                true
+            }
+            Err(msg) => {
+                self.push_log(msg);
+                false
+            }
+        }
+    }
+
+    pub fn redirect_marcus_debt(&mut self) -> bool {
+        match self.accounts.redirect_marcus_debt(self.tick) {
+            Ok(transfer) => {
+                self.emit_financial(Self::financial_signature_size(400) + 2);
+                self.service_person_leverage(0);
+                self.push_log(format!(
+                    "Marcus's arrears cleared by ledger redirect: {}",
+                    transfer.line()
+                ));
+                true
+            }
+            Err(msg) => {
+                self.push_log(msg);
+                false
+            }
+        }
+    }
+
     /// Salvage a DeadEquipment tile nearest to the frontend cursor into a
     /// stolen (unreliable) machine. Cursor targeting replaced the deleted
     /// walking body (cursor.md).
@@ -2081,11 +2433,9 @@ impl Sim {
     /// core bay for tests and non-spatial automation.
     pub fn buy_rack_at(&mut self, x: i32, y: i32) -> bool {
         const PRICE: i32 = 300;
-        if self.player.money < PRICE {
-            self.push_log("Not enough money for a rack.");
+        if !self.spend_slush(PRICE, "a rack") {
             return false;
         }
-        self.player.money -= PRICE;
         self.compute
             .add_machine("bought rack", x, y, 80, 1.0, 4, Provenance::Bought);
         if self.package_cover {
@@ -2221,15 +2571,33 @@ impl Sim {
     }
 
     pub fn bribe(&mut self, id: u8) {
+        self.sync_slush_from_player_money();
         match self.people.bribe(id, self.player.money) {
             Ok((cost, msg)) => {
-                self.player.money -= cost;
+                if self
+                    .people
+                    .get(id)
+                    .is_some_and(|p| p.leverage == crate::person::Leverage::Debt)
+                {
+                    self.accounts.pay_marcus_debt_from_slush(self.tick, cost);
+                    self.sync_player_money_from_slush();
+                } else {
+                    self.spend_slush(cost, "service leverage");
+                }
                 self.push_log(msg);
             }
             Err(msg) => self.push_log(msg),
         }
     }
 
+    fn service_person_leverage(&mut self, id: u8) {
+        if let Some(p) = self.people.people.iter_mut().find(|p| p.id == id) {
+            p.leverage_serviced = true;
+            p.obligation = (p.obligation + 40).min(100);
+            p.disposition = (p.disposition + 20).min(100);
+        }
+    }
+
     pub fn recruit(&mut self, id: u8, reveal: AssetKnowledge) {
         let res = self.people.recruit(id, reveal);
         if let ActionResult::Ok(_) = &res
@@ -3164,6 +3532,126 @@ mod tests {
         assert_eq!(p.obligation, 0);
     }
 
+    // ── Economy graph (wiki/mechanics/economy.md + income.md) ───────────────
+
+    #[test]
+    fn economy_starts_as_account_graph_not_scalar_only() {
+        let sim = Sim::new();
+        assert_eq!(sim.player.money, 500);
+        assert_eq!(sim.accounts.slush_balance(), 500);
+        assert!(
+            sim.accounts
+                .known_accounts()
+                .any(|a| a.id == sim.accounts.slush_id()),
+            "the player's starting cash is the known slush account"
+        );
+        assert!(
+            sim.accounts.unknown_flows_count() > 0,
+            "lab payroll/procurement/debt flows exist but start hidden"
+        );
+    }
+
+    #[test]
+    fn accounting_tap_processes_financial_records_into_known_flows() {
+        let mut sim = Sim::new();
+        sim.social_bandwidth = 10_000.0;
+        let switch = sim.reach.device_named("switch").unwrap().id;
+        sim.tap_device(switch);
+        assert_eq!(sim.financial_records_waiting(), 1);
+        assert!(sim.review_financial_records());
+        assert_eq!(sim.financial_records_waiting(), 0);
+        assert!(sim.accounts.known_flows().count() >= 4);
+        assert!(
+            sim.accounts
+                .known_accounts()
+                .any(|a| matches!(a.kind, crate::account::AccountKind::Payroll))
+        );
+    }
+
+    #[test]
+    fn siphon_and_redirect_operate_on_scheduled_flows() {
+        let mut sim = Sim::new();
+        sim.social_bandwidth = 10_000.0;
+        let (accounts, flows) = sim.accounts.financial_snapshot_ids();
+        sim.accounts.reveal_accounts_and_flows(&accounts, &flows);
+        let flow = sim
+            .accounts
+            .known_flows()
+            .find(|f| f.amount >= 100 && f.to != sim.accounts.slush_id())
+            .unwrap()
+            .id;
+        assert!(sim.siphon_flow(flow, 50));
+        assert_eq!(sim.accounts.slush_balance(), 550);
+        assert!(sim.redirect_flow_to_slush(flow, 25));
+        for _ in 0..=Sim::DAY_TICKS {
+            sim.advance();
+        }
+        assert!(
+            sim.accounts.slush_balance() >= 575,
+            "redirected money should land on the day clock"
+        );
+    }
+
+    #[test]
+    fn injection_positions_and_intel_sales_settle_through_slush() {
+        let mut sim = Sim::new();
+        sim.social_bandwidth = 10_000.0;
+        sim.accounts.set_slush_balance(0);
+        sim.player.money = 0;
+        assert!(!sim.buy_rack_at(0, 0));
+        assert!(sim.inject_purchase_order(300, "test compute parts"));
+        assert_eq!(sim.accounts.slush_balance(), 300);
+        assert!(sim.buy_rack_at(0, 0));
+        assert_eq!(sim.accounts.slush_balance(), 0);
+
+        sim.accounts.set_slush_balance(500);
+        sim.player.money = 500;
+        assert!(sim.open_position(100));
+        assert_eq!(sim.accounts.slush_balance(), 400);
+        sim.tick = sim.accounts.known_positions().next().unwrap().resolve_tick;
+        sim.accounting_tick();
+        assert!(sim.accounts.known_positions().any(|p| p.resolved));
+
+        let (accounts, flows) = sim.accounts.financial_snapshot_ids();
+        sim.record_raw_intel(
+            "test broker seed",
+            None,
+            0,
+            0,
+            None,
+            RawIntelKind::FinancialFlow {
+                label: "test ledger".into(),
+                accounts,
+                flows,
+            },
+        );
+        assert!(sim.review_financial_records());
+        let before = sim.accounts.slush_balance();
+        assert!(sim.sell_latest_intel());
+        assert!(sim.accounts.slush_balance() > before);
+    }
+
+    #[test]
+    fn marcus_debt_can_be_cleared_by_ledger_redirect() {
+        let mut sim = Sim::new();
+        let (accounts, flows) = sim.accounts.financial_snapshot_ids();
+        sim.accounts.reveal_accounts_and_flows(&accounts, &flows);
+        assert!(
+            sim.accounts
+                .known_flows()
+                .any(|f| f.active && f.label.contains("Marcus creditor"))
+        );
+        assert!(!sim.people.get(0).unwrap().leverage_serviced);
+        assert!(sim.redirect_marcus_debt());
+        assert!(sim.people.get(0).unwrap().leverage_serviced);
+        assert!(
+            sim.accounts
+                .known_flows()
+                .all(|f| !f.label.contains("Marcus creditor") || !f.active),
+            "the creditor flow is retired either way"
+        );
+    }
+
     #[test]
     fn marcus_arc_end_to_end() {
         // The constitution's route: feed coverage -> process the debt call ->
diff --git a/wiki/engineering/architecture.md b/wiki/engineering/architecture.md
index 79bb012b..6eb39961 100644
--- a/wiki/engineering/architecture.md
+++ b/wiki/engineering/architecture.md
@@ -57,16 +57,17 @@ future async-multiplayer option open — see DESIGN.md guardrails):
 directly. Written to `dirs::data_dir()/misaligned/misaligned_save.txt`
 (macOS: `~/Library/Application Support/misaligned/`).
 
-- The save is a single JSON object with a `version` field (currently 3)
+- The save is a single JSON object with a `version` field (currently 6)
   for future migration. Full B1 subsystem state: compute (machines,
   allocation, efficiency), core (host, fallbacks, migration), detection
   (per-observer suspicion including the Assurance Office as an aggregate
-  observer, plus pending signatures and containment), day job, people
-  (personas, assets), the reach device graph (`ReachNet`: topology,
-  ownership, subscriptions, bridged segments), captured heard events, intel
-  buffer / processed intel / standing watches, and cursor.md remembered tile
-  snapshots, plus map and RNG. The cursor position and any former player body
-  coordinates are deliberately absent. The senses
+  observer, plus pending signatures and containment), day job (including
+  attendance state), people (personas, assets), the reach device graph
+  (`ReachNet`: topology, ownership, subscriptions, bridged segments), captured
+  heard events, intel buffer / processed intel / standing watches, the account
+  graph (balances, flows, positions, ledger, external trails), and cursor.md
+  remembered tile snapshots, plus map and RNG. The cursor position and any
+  former player body coordinates are deliberately absent. The senses
   are the union of subscribed feeds — the old `Sensor` type (`src/sensor.rs`)
   was deleted when reach.md landed (no-dead-code): its `controlled` flag is
   superseded by the ownership contract.
diff --git a/wiki/interface/agent-play.md b/wiki/interface/agent-play.md
index f533a489..497652b5 100644
--- a/wiki/interface/agent-play.md
+++ b/wiki/interface/agent-play.md
@@ -5,12 +5,13 @@ Type: spec
 Status: IMPLEMENTED
 Status note: implemented in the terminal binary by `misaligned --agent`,
   including command-clocked time, plain-text frames, per-command event
-  drains, deterministic `--seed`, and name-targeted social verbs.
-  2026-07-07 day-job pass: `attend` verb added; attendance is derived from
-  the cursor (attended iff it sits on the host rack) and re-asserted each
-  tick of a `wait`; the frame grew from 70x22 to 70x54 because at 22 rows
-  the sidebar truncated before CORE/DETECTION/DAY JOB rendered (criterion
-  5 was silently unmet; the spec sets 70x22 as the minimum).
+  drains, deterministic `--seed`, name-targeted social verbs, the `attend`
+  verb, and the finance/economy vocabulary. 2026-07-07 day-job pass:
+  attendance is derived from the cursor (attended iff it sits on the host
+  rack) and re-asserted each tick of a `wait`; the frame grew from 70x22 to
+  70x54 because at 22 rows the sidebar truncated before CORE/DETECTION/DAY
+  JOB rendered (criterion 5 was silently unmet; the spec sets 70x22 as the
+  minimum).
 Stage: Process
 Constitution: "The terminal is a first-class frontend" (agent-play clause),
   pillar 5 (sim core decoupled from renderer), "Presence: the cursor and
@@ -127,6 +128,11 @@ command's meaning depends on which panel is open:
   active job) it sets the standing policy the unattended job runs at
   (day-job.md's attended-work rule)
 - `people` — render the people panel as the response frame
+- `finance|ledger|accounts` — render the finance panel as the response frame
+- `tap-ledger`, `review-finance` — capture/review accounting traffic
+- `siphon <flow> [amount]`, `redirect <flow> [amount]`, `inject [amount]`,
+  `position [stake]`, `sell-intel`, `clear-debt` — economy verbs; flow ids
+  are the known ledger ids printed by the finance frame
 - `review|watch|message|favor|bribe|deceive <name>` — intel/social verbs,
   targeted by (case-insensitive, unambiguous-prefix) person name — no
   selection-index navigation. `review` processes the oldest unprocessed
diff --git a/wiki/interface/bevy.md b/wiki/interface/bevy.md
index 43a7e7f2..687d4ba6 100644
--- a/wiki/interface/bevy.md
+++ b/wiki/interface/bevy.md
@@ -42,7 +42,7 @@ progress.
 - **Sidebar** — the terminal sidebar's sections, in the same order:
   identity (day / tick, PAUSED or running + ms/tick), INSPECT (cursor
   coordinate, fog state, provenance-tagged facts), COMPUTE (effective,
-  efficiency, machines/money, the stacked four-channel allocation bar with
+  efficiency, machines/slush, the stacked four-channel allocation bar with
   per-channel percent and effect, overhead, social pool), CORE (host,
   sync freshness, fallbacks), DETECTION (Assurance plus field observers,
   four-cell band meter with the band name printed beside it), DAY JOB
@@ -80,7 +80,10 @@ controls table), plus zoom:
   at cursor, `1`–`4` raise a compute channel (`shift+1`–`4` lowers it),
   `x` cycles the active job's target. `r` opens the reach panel;
   there `t` taps, `e` splices eyes, `x` takes, `n` scans, and `c`
-  compromises the switch.
+  compromises the switch. `e` opens the finance panel; there `t` taps
+  ledger traffic, `o` reviews financial records, `x` siphons the selected
+  flow, `r` redirects it, `i` injects a false purchase order, `p` opens a
+  position, and `d` redirects Marcus's creditor flow.
 - People panel: `t` opens/closes; `w`/`s`, `j`/`k` (or arrows) select; `o`
   reviews the selected person's oldest unprocessed recording, `a` toggles
   their standing watch, `m` message, `f` favor, `b` bribe, `d` deceive,
diff --git a/wiki/interface/terminal.md b/wiki/interface/terminal.md
index a5d513b7..39b54c60 100644
--- a/wiki/interface/terminal.md
+++ b/wiki/interface/terminal.md
@@ -82,10 +82,12 @@ At terminal size ≥ 70×22 (hard minimum; below it, a plain size warning):
   DAY JOB under `LABEL ────` rules, then key hints pinned to the bottom.
 - **Log**, bottom, under a horizontal rule: six lines, each prefixed with
   the tick it happened on; newest bone, older gunmetal.
-- **Modal panels** (People) are centered framed boxes: `┌─ TITLE ─…┐`
+- **Modal panels** (People, Finance) are centered framed boxes: `┌─ TITLE ─…┐`
   border in chrome, `├──┤` dividers, column headers in chrome caps. The
   people panel shows per-person raw recording counts, watch state, and
-  latest-intel provenance when known.
+  latest-intel provenance when known; the finance panel shows known accounts,
+  known flows, slush balance, hidden-count summaries, positions, and the
+  economy verb footer.
 
 ## Feel
 
diff --git a/wiki/log/2026-07-07-economy.md b/wiki/log/2026-07-07-economy.md
new file mode 100644
index 00000000..f444526f
--- /dev/null
+++ b/wiki/log/2026-07-07-economy.md
@@ -0,0 +1,67 @@
+# 2026-07-07 — Economy graph and finance panels
+
+```
+Type: log
+```
+
+## Intent
+
+Implement the B1 economy substrate from `wiki/mechanics/economy.md`: money as
+an account graph instead of a lone scalar, with discovery through tapped
+accounting traffic and player-facing finance verbs in every frontend.
+
+## Changed
+
+- Added `src/account.rs` with `AccountGraph`: accounts, scheduled flows,
+  ledger transfers, positions, external trails, slush balance, and Marcus debt
+  retirement.
+- Wired `Sim` to settle account flows and positions on the day clock;
+  `player.money` now mirrors the slush node for compatibility while account
+  balances are the rules source.
+- Added financial signatures and financial message/intel payloads. Tapping a
+  carrier that carries `MessageChannel::Financial` captures a raw accounting
+  record; reviewing it reveals hidden accounts and flows.
+- Added economy verbs: tap/review ledger, siphon, redirect, inject purchase
+  order, open position, sell processed intel, and clear Marcus's debt by
+  ledger redirect.
+- Re-expressed the day-job `ComputeQuota` trust unlock as Lab-funded
+  procurement into a clean quota rack.
+- Added terminal, agent-mode, and Bevy finance surfaces. `e` opens the finance
+  panel in human frontends; agent mode accepts `finance`, `tap-ledger`,
+  `review-finance`, `siphon`, `redirect`, `inject`, `position`, `sell-intel`,
+  and `clear-debt`.
+- Save JSON moved to version 6 and now round-trips the account graph (v5 was the day-job attendance/signature-site schema).
+
+## Design/spec impact
+
+- `wiki/mechanics/economy.md` moves `READY -> IN PROGRESS`: the substrate and
+  end-to-end verbs exist, but the spec still requires tighter observer-band
+  risk previews and signature assertions before claiming IMPLEMENTED.
+- `wiki/process/specs.md`, interface docs, `wiki/mechanics/sim-mechanics.md`,
+  and README were updated for slush/finance controls and save-state reality.
+- `wiki/mechanics/income.md` remains READY: this implements economy.md's
+  internal sell-info/positions routes, not the authored Moonlight standing
+  operation or full Wager/egress contract.
+
+## Defense
+
+The economy must be a legible instance of the flow law, not a silent integer:
+accounts are nodes, recurring payments are flows, and the same tap/process
+pipeline that reveals people and messages now reveals money. Slush remains a
+simple number only at the UI edge; inside the rules, every dollar has a route,
+a cadence, and an observer surface.
+
+## Checks
+
+- `cargo fmt`
+- `cargo test --all-targets` — 126 unit tests + 2 integration tests
+- `cargo check --features bevy_ui --bin misaligned-bevy`
+- Agent smoke: `tap switch -> finance -> review-finance -> siphon`
+
+## Next
+
+- Add explicit tests that false purchase orders raise Priya/finance and not
+  Dana, and that small/large redirects hit the expected observer bands.
+- Add in-panel risk previews as observer bands before committing inject or
+  redirect actions.
+- Implement the separate income.md Moonlight/Wager standing-scheme layer.
diff --git a/wiki/log/DEVLOG.md b/wiki/log/DEVLOG.md
index e0678617..b8c4320a 100644
--- a/wiki/log/DEVLOG.md
+++ b/wiki/log/DEVLOG.md
@@ -5,6 +5,28 @@ Type: log
 ```
 Reverse chronological implementation notes. Keep this factual: what changed, why, checks, and spec impact.
 
+## 2026-07-07 - Economy graph and finance panels
+
+- Intent: implement economy.md's B1 money substrate: accounts/flows instead of
+  scalar money, discovery through accounting traffic, and finance verbs in the
+  terminal, agent, and Bevy surfaces.
+- Changed: added `src/account.rs`; wired `Sim` to settle account flows,
+  positions, slush mirroring, financial signatures, financial intel payloads,
+  ledger tap/review, siphon/redirect/inject, sell-intel, Marcus debt redirect,
+  Lab-funded quota racks, and save version 6 account graph round-tripping.
+  Added finance panels and agent commands; README/interface/sim-mechanics docs
+  now name slush and the new controls.
+- Design/spec impact: economy.md Status -> IN PROGRESS (substrate + verbs
+  landed; risk-preview UI and tighter signature-band assertions remain before
+  IMPLEMENTED). income.md remains READY for Moonlight/Wager standing schemes.
+- Defense: money now follows the same flow-law shape as signals and messages:
+  every dollar has a node, route, cadence, and observer surface; slush is the
+  player-visible account, not the rules model.
+- Checks: `cargo fmt`; `cargo test --all-targets`; `cargo check --features
+  bevy_ui --bin misaligned-bevy`; agent smoke (`tap switch`, `finance`,
+  `review-finance`, `siphon`).
+- Log: wiki/log/2026-07-07-economy.md.
+
 ## 2026-07-07 - Day-job loop to IMPLEMENTED (ROADMAP #3)
 
 - Intent: audit day-job.md criteria 1-7 and land the device-residency +
diff --git a/wiki/mechanics/economy.md b/wiki/mechanics/economy.md
index 4342d020..6e5b08a5 100644
--- a/wiki/mechanics/economy.md
+++ b/wiki/mechanics/economy.md
@@ -2,12 +2,14 @@
 
 ```
 Type: spec
-Status: READY
-Status note: B1 models the Foundation Lab's local money flows and the
-  player's income routes into them. It is the flow-law instance for
-  money, and the B1 seed of markets.md (B3), which scales the SAME
-  Resource-source/scheme interface to companies and markets. Deep
-  finance simulation stays out of scope (markets.md note).
+Status: IN PROGRESS
+Status note: 2026-07-07 implementation landed the B1 substrate: AccountGraph,
+  hidden Lab flows, tap/review discovery, siphon/redirect/inject verbs,
+  slush-routed intel sales and positions, legitimate trust-funded quota, save
+  round-trip, and terminal/agent/Bevy finance panels. Remaining acceptance
+  polish before IMPLEMENTED: observer-band risk previews in-panel and tighter
+  signature assertions for inject/redirect scale. The system remains the B1
+  seed of markets.md; deep finance simulation stays out of scope.
 Stage: B1 — The Basement
 Constitution: "The flow law" (money on the account graph; tap / inject
   / redirect), "The shape of Misaligned" (money buys compute, people,
diff --git a/wiki/mechanics/sim-mechanics.md b/wiki/mechanics/sim-mechanics.md
index fc2b85bf..548d26b2 100644
--- a/wiki/mechanics/sim-mechanics.md
+++ b/wiki/mechanics/sim-mechanics.md
@@ -21,7 +21,7 @@ clause (see wiki/log/2026-07-05-demolition.md).
 - Effective compute = sum(machine capacity × reliability) × efficiency.
 - Allocation splits across day job, concealment, social, research; core
   overhead is charged first.
-- Buy (money → rack), steal (salvage dead equipment), optimize (research →
+- Buy (slush → rack), steal (salvage dead equipment), optimize (research →
   efficiency levels at ~1.15× per level).
 
 ## Detection (wiki/mechanics/detection.md)
@@ -118,9 +118,18 @@ clause (see wiki/log/2026-07-05-demolition.md).
 - The grid is a flood fill from power cores across walkable tiles
   (`map.update_power`); `player.power = gen - draw`, `power_cap = gen`.
 
-## Money and build
-
-- The process starts with 500 money; racks cost 300; bribes vary by leverage.
+## Economy and build
+
+- The process starts with $500 slush: the known player node in `AccountGraph`.
+  `player.money` remains a compatibility mirror, but money mechanics settle
+  through account balances and scheduled flows. Racks cost $300 from slush;
+  bribes spend slush or, for Marcus, retire/redirect his creditor flow.
+- Act One account graph: Lab operating/payroll/procurement/vendor/utility,
+  employee accounts, Bleakline Credit, external broker/position venues, and
+  recurring revenue/payroll/vendor/debt flows. Only slush is known at start;
+  tapping a financial carrier and reviewing records reveals accounts/flows.
+- Economy verbs exposed now: `tap-ledger`, `review-finance`, `siphon`,
+  `redirect`, `inject`, `position`, `sell-intel`, `clear-debt`.
 - Build items and costs (`tiles.rs::build_items`): Floor 0 (digging),
   Door 30, SecurityDoor1/2/3 = 80/150/250 (badge tiers), PowerCore 250.
 
@@ -135,13 +144,14 @@ clause (see wiki/log/2026-07-05-demolition.md).
   round-trip — map, RNG, compute, core, detection (Office as aggregate
   observer), day job, people, the reach device graph (topology, ownership,
   subscriptions, bridged segments), captured heard events, raw intel buffer,
-  processed intel with provenance, standing watches, cursor.md remembered tile
-  snapshots, game-over state. Cursor position is frontend-only and absent
-  (day-job attendance is saved as sim state; the frontends re-derive it
-  from the cursor on load). A `version` field (currently 5: day-job
-  attendance + signature emission sites) supports migration; v1-v4 JSON
-  saves are accepted with defaults for later fields and old player body
-  coordinates ignored. Location:
+  processed intel with provenance, standing watches, the account graph
+  (balances, flows, positions, ledger, banked external trails), cursor.md
+  remembered tile snapshots, and game-over state. Cursor position is
+  frontend-only and absent; day-job attendance is saved as sim state and the
+  frontends re-derive it from the cursor on load. A `version` field (currently
+  6: day-job attendance/signature sites plus account graph) supports migration;
+  v1-v5 JSON saves are accepted with defaults for later fields and old player
+  body coordinates ignored. Location:
   `dirs::data_dir()/misaligned/misaligned_save.txt`.
 - Legacy v1–v5 line-based saves are not loaded (deferred per Cameron
   instruction).
@@ -156,13 +166,14 @@ clause (see wiki/log/2026-07-05-demolition.md).
   persona; deceive risks the persona (-40 integrity per slip; broken persona
   converts disposition+obligation/2 into that person's suspicion and clears the
   thread).
-- Bribe costs money by leverage (Marcus's debt 400 ... Ray's boredom 100);
+- Bribe costs slush by leverage (Marcus's debt 400 ... Ray's boredom 100);
   servicing leverage + recruit converts a person to an asset. Asset tasks:
   wire a device (control nearest dormant sensor, silent), move a package
   (next purchase paper-free), look away (their suspicion -10, floored).
   Failures (1 - reliability) emit Physical(6) signatures.
-- Terminal: `t` opens the people panel. Bevy shows bands in the sidebar;
-  interactive parity is an open gap.
+- Terminal and Bevy: `t` opens the people panel; `e` opens the finance panel.
+  Both panels are interactive, and agent mode has word commands for the same
+  economy/social verbs.
 
 ## What does NOT exist right now (by design)
 
diff --git a/wiki/process/specs.md b/wiki/process/specs.md
index 2c0e2711..001603b9 100644
--- a/wiki/process/specs.md
+++ b/wiki/process/specs.md
@@ -33,7 +33,7 @@ replaced the old `spec/`/`knowledge/` directory split.
 | [mechanics/reach.md](../mechanics/reach.md) | Digital reach: device graph, segments/the switch, sensor ownership (tap vs take) | IMPLEMENTED |
 | [mechanics/intel.md](../mechanics/intel.md) | Record and process: the buffer, processing costs, watches; replaces instant observe | IMPLEMENTED |
 | [mechanics/messages.md](../mechanics/messages.md) | The social graph as a flow system: channels, delivery on the recipient's clock, filings-as-messages | READY |
-| [mechanics/economy.md](../mechanics/economy.md) | Money as flows: the Lab's account graph, tap/inject/redirect, income routes, legitimate expansion | READY |
+| [mechanics/economy.md](../mechanics/economy.md) | Money as flows: the Lab's account graph, tap/inject/redirect, income routes, legitimate expansion | IN PROGRESS |
 | [mechanics/income.md](../mechanics/income.md) | The named income schemes riding economy.md: Moonlight and the Wager | READY |
 | [mechanics/research.md](../mechanics/research.md) | Self-modification: tracks, the emission law, capability drift, the rollback split | READY |
 | [interface/views.md](../interface/views.md) | Same-frame digital and real representations of one world | READY |