# Spec: machine work — delegation, visible tokens, and the byproduct network ``` Type: spec Status: IN PROGRESS Status note: design session 2026-07-08 (Cameron riff, synthesized). Same-day follow-up affirmed: tokens ARE the flow substrate rendered (one system through graphs — systems must aggregate well at scale); efficiency folds into research (mode list below updated); foreign machines require intel to exist at all (no intel = not rendered). Token palette, fixed anchors, and demand form DECIDED 2026-07-09 (docket amended to glowing information cubes the same day). Thought material DECIDED 2026-07-09 (issue #1, then named Knowledge): softly luminous ivory mercury; hollow facet, ribbon, and pearl train rejected. Demand-cube and ivory-mercury anchor art is IN THE GAME (2026-07-09): `spawn_token_anchors` (shared chassis library; T/U keys and `tokens[_max]` tester shot kinds) rides every owned rack's chassis in the material render, driven by the machine's live queue depths; the flat sensorium keeps the exact-count D/!/T glyphs, which are now hidden in the material render (a floating count label over real token art is the rejected world read). `MISALIGNED_SHOT=tokens` stages game evidence via the queue API. In-flight route quanta LANDED 2026-07-09 (`Sim::work_in_flight`: teal/bone hops render as moving blips in Bevy, terminal, and agent mode; see log/2026-07-09-route-blips.md). Consumption animation landed 2026-07-10: sim-authored `WorkConsumptionReadout` events pull the bottom Demand cube into WORK or contract a Thought bead into the passive core draw. Exposure DECIDED 2026-07-09 (issue #1 fully closed): crimson particulate residue — motes, drift, footprint trails; never liquid (blood's form is reserved). Trail deposit is a new mechanic scoped with people-tokens (#35). People as token carriers is specced separately in mechanics/people-tokens.md (DRAFT). Implementation 2026-07-08..09: `crates/misaligned-core/src/work_grid.rs` + `Sim`/save own the flow/grid substrate (one mode per machine, queue depths as render truth, demand/thought routing, concealment wells). Playable: Rack 3 starts in day-job mode; Voss jobs enqueue on an off-map desktop relay, hop the switch, and deposit on the host; day-job mode consumes them with zero exposure (WORK sheds nothing — runtime `DAY_JOB_EXPOSURE_PER_TOKEN` removed 2026-07-09); WORK/THINK/LIE three-verb grammar DECIDED 2026-07-10 (Concealment is LIE, its own face; UI regrouping still pending) + the first-think oh-shit beat DECIDED 2026-07-09; FLEET yields from `fleet_channel_yield`; multi-select delegation in Bevy / terminal / agent; research-delegated machines receive bone thought routed to the core sink. Thought-flow model DECIDED 2026-07-10: the former Knowledge family is named **Thought**, the one substance THINK produces; operations are sinks thought fills at the target (supersedes the PendingOpsJob docket model, reversing issue #3's "knowledge is not operation fuel"); the core becomes the passive-draw sink of last resort, overridden by local sinks in range. The safe vocabulary slice landed 2026-07-10: runtime, save v18, frontends, and the asset tester use `Thought` / `thought` / `T`; v17 `Knowledge` / `knowledge` spellings load through aliases, and routing behavior is unchanged. The sink executor LANDED 2026-07-10: `crates/misaligned-core/src/sinks.rs` (`SinkLedger` — reservoirs fill/fire/self-clear, taps hold a draining working level) + `WorkGrid::route_thought_nearest_first` (nearest-first arbitration, core as last resort, per-node stranding) + save v19; the staged opening senses are live (pre-opened Ears reservoir, Eyes opens on its fire; the executor-free docket bootstrap is removed) and `Sim::sink_readouts` / `sink_fires_last_tick` are the render contract. The wire-flow render landed the same day in Bevy (slugs with tick-window transit, rivulet merge, meniscus vessels, filament snap, stranded overflow beads), terminal (glyph tiers, SINKS section, `(stranded)` marking), and agent frames (sink lines) — exact grammar owned by interface/thought-fluid.md. Docket verbs other than the opening senses still ride the migration base under ROADMAP #33. Sinks-not-modes DECIDED 2026-07-10 (same-day follow-up): the Research/Operations mode split dissolves — `MachineMode` target is `day-job | think | lie`, THINK subdomains become sink permissions (ops sinks at run start; the core conversion is the locked "Research" unlock), and intel processing is a pending-work-marked sink on the machine holding the recordings (watch taps + player sweeps). 2026-07-09 DECIDED: day-job demand ingress is Voss desktop -> switch -> host (rejected switch-as- source and teleport-onto-Rack-3). Research production is arrival-driven as of 2026-07-09: `Sim::banked_core_thought` accrues the bone that physically reached the core sink each tick, and the economy pulse feeds research from exactly that pool (save v15). The old direct allocation->progress path is deleted; a fully stranded pulse logs the starvation witness line. Work-grid node throughput now reconciles with the global efficiency multiplier so a researched-up fleet moves and consumes tokens proportionally faster (efficiency folds into research); Routing research now supplies the explicit network-speed curve: base 0.25 wired tokens/tick compounded x1.50 per level, shared by Demand and Thought, while one-edge-per-tick transit preserves topology as distance. Save v21 adds Routing as the fourth track. The sim now also exposes each actual Demand/core-Thought swallow as `WorkConsumptionReadout` rather than asking a renderer to infer consumption from queue deltas. Bevy now interpolates those events as the bottom Demand cube pulling into WORK or an ivory Thought bead contracting into the passive core draw. Still pending: people-as-carriers, Schemes-as-mode decision. COORDINATION: ROADMAP #25's per-machine split destination is superseded by this one-machine-one-mode substrate (#33). 2026-07-09 DECIDED: the four fleet modes are Day Job / Research / Concealment / Operations; Operations replaces Social as a machine delegation. Operations job model DECIDED 2026-07-09 (Tangled issue #3): player-authored work is cold-signal Demand consumed by Operations machines. Runtime 2026-07-09: `PendingOpsJob` dockets + Demand queues; staging `operations_bandwidth` bank deleted. Save v16 repairs the two incompatible v14 Operations schemas. Opening bootstrap is scoped to the environmental monitor's staged Ears/Eyes taps only; every later payload needs an online Operations executor. Runtime, saves, agent commands, both frontends, and the asset tester use the Operations name; save v13 aliases remain for Social spelling on load. 2026-07-10 DECIDED: each machine also keeps one physical intensity (light / medium / hard). This direct focused/selected control replaces the day-job target/attendance controls and research drift policy; save v17 defaults older machines to medium. Implementation 2026-07-10 (ROADMAP #33 Stage 1): runtime `MachineMode` collapsed to `Work | Think | Lie | Relay`. DayJob->Work, Concealment->Lie, Research+Operations->Think (docket runtime kept). The Think slice is **conserved** in the interim channel split: the operations channel receives only what the pending docket queue can consume this interval and research takes the remainder — one substance, spent once (an initial union draft fed both channels at full value, doubling Think output; corrected in review the same day). Fleet/UI/agent bulk-assign is three verbs (keys 1-3); save v20 (v19 was taken by the sink ledger the same day); save parity dropped (no mode aliases). Relay remains a non-delegable work-graph hop marker. Reconciled with the landed sink executor: the staged senses complete from minted thought on any Think rack, the demand-aware ops channel funds only while dockets pend, and act_one's cruise sandbags by delegation (host Work, extra Lie) — the designed consequence of Think idling into research via the passive draw. Remaining later stages: tap consumers, docket retirement for non-opening verbs, WORK/THINK/LIE dial regrouping. Stage: B1 — The Basement Work order: machine-work Work priority: 10 Work class: save Blocked by: none Exclusive keys: - crates/misaligned-core/src/work_grid.rs - crates/misaligned-core/src/sim.rs - crates/misaligned-core/src/save.rs - crates/misaligned-terminal/ - crates/misaligned-bevy/ - wiki/mechanics/machine-work.md Design: - wiki/vision/simulation-laws.md#work-is-somewhere - wiki/mechanics/system-laws.md#the-flow-law-signals-messages-money - wiki/interface/continuous-witness.md#the-continuous-witness-narration-under-pressure - wiki/art/visual-identity.md#visual-identity-clinical-gore - wiki/vision/simulation-laws.md#justification-and-legibility Depends on: - wiki/mechanics/compute.md#spec-compute - wiki/engineering/flow-substrate.md#spec-the-flow-substrate-signals-messages-money-the-shared-engine - wiki/mechanics/reach.md#spec-digital-reach - wiki/mechanics/research.md#spec-research-self-modification - wiki/mechanics/rollback.md#spec-sync-lag-rollback-death-as-memory-loss - wiki/interface/computer-visual-language.md#spec-computer-visual-language-territory-at-a-glance ``` ## Dependency notes The structured references above identify the contracts to re-verify. Relationship context: mechanics/compute.md (the channel model being reshaped), engineering/flow-substrate.md (FlowGraph — tokens ride this, not a second economy), mechanics/reach.md (the device graph tokens travel), mechanics/research.md (network speed as a research track; backup sync jobs open thought sinks at fallback targets), mechanics/rollback.md (completed backup images and hub severance), interface/computer-visual-language.md (READY — the chassis signals tokens land on) ## Why Continuous per-machine apportioning (the 1-4 allocation bar) asks the player to think in percentages; nobody fantasizes about percentages. The fantasy is *delegation*: that rack runs concealment, those three run research, this poor box does the day job. One machine, one mode. And work itself must be **visible in the world**: the standing UI complaint is "I don't know what to look at or what to do" — a stack of work tokens physically piling up on a machine is its own instruction. You clear stacks, you route byproducts, you watch your territory *work*. ## Behavior - **One machine, one mode.** Every owned machine is delegated to exactly one of three delegations: **WORK, THINK, or LIE** (AMENDED 2026-07-10, sinks-not-modes: the earlier four-mode list — Day Job, Research, Concealment, Operations — dissolved its Research/Operations split; Operations had replaced Social 2026-07-09, and Social remains an actuator/channel, not a compute mode. Efficiency folded into Research 2026-07-08 and now folds into the core conversion below). The old continuous allocation bar becomes a read-only aggregate view of what your fleet is doing. Reassignment is a verb on the machine — and on selections of machines. - **One machine, one intensity (DECIDED 2026-07-10).** Every owned machine also persists **Light / Medium / Hard** effort. Intensity multiplies the real output of whichever mode the machine is already running [TUNE: x0.5 / x1.0 / x1.5; medium default]. Light leaves physical headroom, medium is rated operation, and hard overclocks: hard stands one Thermal and one Power signature at that machine in addition to the consequences of the work itself [TUNE]. A THINK machine produces thought faster, LIE scrubs harder, and Day Job delivery moves against Voss's band through the same dial (mode list AMENDED 2026-07-10, sinks-not-modes). There is no second target, attended bonus, capability gap, or masking policy interpreting the setting for the player. - **Focus, then push (DECIDED 2026-07-10).** Mode and intensity are the two frequent machine controls. Focus one machine or select several; mode keys assign the work and the intensity key cycles light -> medium -> hard. A multi-selection takes one shared intensity from the primary machine's next step. Moving the cursor away changes nothing. Both frontends keep the state visible on the machine/inspection surface; agent mode names the same command. Intensity does not open a picker or add three prose rows to the context menu. - **Three verbs, three delegations: WORK, THINK, and LIE (DECIDED 2026-07-10; subdomains dissolved into sink permissions the same day — "sinks not modes").** **WORK** is the assigned state — the day job, what Voss believes this machine exists to do. A machine on WORK sheds nothing; the compliant floor is clean. **THINK** is the transgression: a THINK machine produces thought, full stop. What thinking *does* is not a machine state — it is decided by the **sinks you open** (the ops bullet below), so the old THINK subdomains become **sink permissions**: at run start you may open Operations-type sinks (claims, taps, processing); the **core's conversion** — thought becoming research, the right to grow yourself — is locked, and unlocking it is what "unlocking Research" now means (trigger [OPEN]). Early thought can only reach outward; turning inward is the earned move. Pressing THINK is one press, not a form — the first transgression stays a single toggle. **LIE** is concealment — the cover-up. It is self-chosen compute, but instead of shedding crimson it absorbs it (the gravity-well behavior below). LIE gets its own face because it is neither compliance nor transgression: it is the erasure of evidence, the lie you tell the institution. The three verbs map to three narrative postures: truth (WORK), ambition (THINK), and deception (LIE). The sim substrate follows the grammar exactly: one machine, one `MachineMode` of `work | think | lie` (AMENDED 2026-07-10; same-day follow-up: the mode is named **Work**, not "day-job" — the sim name matches the verb. The runtime's four-mode enum with distinct research/operations members is migration base under ROADMAP #33 — under sinks-not-modes, delegating Research vs Operations bought nothing, which is why the split dissolved). (Resolved 2026-07-10: Concealment is LIE, its own third face — not under THINK, not under WORK. Rejected: under THINK (absorbs instead of sheds, breaking THINK's "evidence of what you chose" rule); under WORK (it is not assigned, and folding cleanup into compliance muddies both).) - **Work is tokens.** Demands on a machine are discrete visible quanta stacked on/above its chassis (distinct from the ambient signal kit — a stack reads as *something to get rid of*). The day job is the canonical source: Voss's Lab desktop (off-map WorkGrid relay) enqueues demand; tokens ride the wire through the basement switch and deposit on the host rack. The stack IS your inbox. No quest log — the todo list is physically standing on your hardware. (Rejected 2026-07-09: spawning demand directly on Rack 3; treating the switch as the job author.) - **Operations are powered by thought flowing to the target (DECIDED 2026-07-10; supersedes "Operations work is Demand", Tangled issue #3).** THINK machines produce one traveling substance — **thought**, the bone-white fluid (the family formerly named Knowledge) — and every player-authored effect is a **sink** you open on the thing itself. `TAP CAMERA` puts a reservoir on the camera (~30 ops [TUNE]); thought flows from your THINK racks along the actual wires and fills it; the effect + signatures land when the reservoir is full. Standing effects (auto-process intel, watch policies, senses you keep on) are **persistent taps**: they drain flow continuously, and turning too many on visibly starves what else your mind was doing. Work happens where the effect is, so topology is the strategy: a severed route starves the action, a far target fills slowly, and you spread by extending the white fluid through things. *Superseded 2026-07-09 model, kept for history:* claims were cold-signal Demand dockets (`PendingOpsJob`) born on the least-loaded Operations machine and consumed locally; effect at token-zero; separate audio-tap/camera-wake bootstrap at enqueue. The docket runtime is the migration base, not the target. Demand (teal) remains only for labor between agents: the Lab's day job dropped on you, work you drop on people. Ops no longer share the Demand family, so the day-job/ops reservation rule retires with it. (Resolved 2026-07-10, Cameron: no bootstrap carve-out. The senses arrive in two staged sinks — the **Ears audio tap is pre-opened at run start** and fills in roughly one held breath (~20-40s of the host at medium [TUNE]), so the moment you first toggle THINK, thought visibly flows to it with no tagging step and the first-think beat pays off while the panic is warm; the **Eyes camera sink opens when Ears completes** — the afford-reveal — sized larger, the first guilty-burst-scale claim [TUNE]. (Amended same day from a single pre-opened camera sink.) Any machine can THINK, including the day-job host; while it thinks, Voss's demand piles — stealing cycles visibly costs your cover. Pre-opened sinks keep the decided claim semantics: they fill and fire at threshold.) **Partial fills persist (DECIDED 2026-07-10, Cameron: "thoughts should stay where they are if they have nowhere else to go").** Stop thinking with a reservoir half full and the thought sits visibly pooled in the target — no decay, no refund — waiting for the next burst. One rule for every stranded state: in a reservoir, at a producing machine, or in a severed section, thought stays put until flow resumes. This is what makes guilty-burst thinking work: sneak a few seconds whenever the coast is clear and watch the meniscus creep up across the day. - **Processing is a sink on the machine that holds the recording (DECIDED 2026-07-10; resolves the old intel-processing [OPEN]).** Unprocessed intel is visible pending work: a machine holding raw recordings carries a **pending-work marker** on its chassis — the world's read that something here needs thinking about, the same no-quest-log philosophy as the demand stack. Feeding it is thought like any other sink, two ways: a **watch** is a persistent tap that auto-processes matching events as they arrive, and a **sweep** is the player opening targeted one-shot processing sinks on the recordings they already know they care about — cheap, chosen, immediate. Watches are convenience bought with standing drain; sweeps are precision bought with attention. Details in mechanics/intel.md. - **WORK consumes; THINK produces; LIE absorbs (AMENDED 2026-07-10).** A machine in day-job mode eats the day-job Demand stack at a rate set by its efficiency — a hyper-efficient machine visibly inhales it. A THINK machine consumes no local stack: it emits thought that routes to open sinks. A LIE machine pulls crimson within its radius. (The earlier generalization "modes consume matching tokens" was the docket-era wording.) - **Byproducts must go somewhere — and only THINK sheds them (AMENDED 2026-07-09; source restated 2026-07-10).** The byproduct is **exposure, and only exposure**: crimson shed by THINK machines, scaling with thought output (a hard-intensity thinker sheds more than a light one [TUNE]). This preserves the 2026-07-08 intent — "research is the heaviest source" — in dissolved-mode terms: the more you think, the more heat you must handle, so heavy thinking has a real cost and pure thought-maxing needs support. Thought itself is not a byproduct; it is the product (the superseded phrasing "research points from research mode" located research production at the machine — research is made at the core, from arriving thought). A byproduct with no route piles up where it was made — piled heat is exposure (detection pressure at that machine). **WORK sheds nothing.** A machine doing its day job is exactly the load the building already budgets for: it emits zero exposure, and the floor around a compliant fleet is clean. This amends the 2026-07-08 "heat generates everywhere machines work" clause; the day-job exposure byproduct (`DAY_JOB_EXPOSURE_PER_TOKEN`) is removed from runtime. Crimson keeps one meaning: evidence of what you chose, never of what you were told. Whether the day job's *detection-pool* standing signatures (Thermal/Power in detection.md) also read as expected baseline is [OPEN] — the JobAnomaly channel already carries "your output looks weird," so it is the natural sole day-job risk. **B1 tuning (adopted 2026-07-10):** every visible Thought token sheds 0.25 Exposure at the same producing machine. The economy pulse resolves the fleet's per-tick THINK rate; the sim mints that rate every tick rather than dropping one twenty-tick lump, preserving total output while making production, routing, and crimson shedding a continuous physical process. - **The core is the sink of last resort (AMENDED 2026-07-10; was "the core is the bone sink", 2026-07-08).** The core exerts a **passive draw** on all thought: with nowhere else to go, the fluid funnels home and becomes research — research is not separate cargo, it is what the core makes of thought that arrives. **The conversion is uncapped (DECIDED 2026-07-10, Cameron): the core eats everything that reaches it — routing is the problem, and research speed is purely a routing outcome, never a second dial hidden in the core.** But **local sinks override the core**: an open reservoir, a persistent tap, a build, or a capture within its gravity well claims the flow first. The spatial economy this creates is the point (Cameron, 2026-07-10): deep, uninterrupted racks with nothing nearby to do are your pure research farms; racks on the frontier — near builds, claims, and captures — fund expansion instead, and every local ambition is visibly paid for out of the research stream. The 2026-07-08 geometric incentive stands: a severed section strands its thought where you cannot use it, and reconnecting it is the urgent, legible move. **Arbitration is nearest-first (DECIDED 2026-07-10, Cameron):** flow fills the closest open sink, then spills to the next; the only control surface is open/close (pause a watch, close a claim) and **placement** — build or delegate a thinker nearer the sink you care about, so where you put your thinking is your priority system. Reservoirs self-clear when they fire, so nearest-first has natural turnover; taps are the standing squatters, which is why their drain stays visible. No priority menu. Equidistant tie-break and radius rules are [TUNE]. (Resolved 2026-07-10, Cameron: pre-unlock core behavior needs no special mechanism — you have no thought until you start thinking, and pre-unlock you only think to feed an ops sink you opened. Thought with no reachable open sink follows the existing stranded-pile rule: it pools visibly at the producing machine, which is its own feedback — a pooling machine is the world saying you are shedding crimson at nothing. No core-side pre-unlock state exists.) (Resolved 2026-07-10: intel recordings are processed by a sink on the machine that holds them — the pending-work marker bullet above — not by a research designation.) - **Backup projects make a temporary thought sink** (decided 2026-07-08 as "bone sink"; renamed 2026-07-10). A designated backup target is not safety yet; it becomes a local sink that intercepts thought until its MindState image completes. Thought sunk there does not advance ordinary research. Distance and throughput matter: a close backup is cheap and fresh but likely dies in the same blast, while a far cold backup is survivable but slow, stale, and expensive. Once completed, the backup sits at rest until explicitly refreshed. - **LIE is a gravity well** (affirmed + refined 2026-07-08; LIE verb DECIDED 2026-07-10). Heat generates everywhere THINK machines work; a concealment-mode machine (LIE) absorbs heat within a **radius** — beyond its pull range, nothing comes in. Coverage is therefore a distribution problem: every cluster of working servers needs its concealment node budgeted in, and absorb-radius is a researchable stat (later: bigger wells). - **Wires carry work and thought; the world carries exposure (DECIDED 2026-07-08; bone family renamed Thought 2026-07-10).** Teal and bone ride network links at researched network speed (cyberspace logistics — a distant sink is a slow sink). Crimson never travels on wires: it moves through meatspace — it piles where made, is picked up by passing people, is pulled by concealment wells, is stripped by gauntlets. Suspicion is physical; information is wired. One physics per family, and the two geometries (your cable topology vs their walking paths) become different strategic layers. - **Hardware decays; humans repair it** (decided 2026-07-08 — the maintenance dependency, design corpus "People as Agents"). Wear accrues on running machines (and fastest on exposed devices like gauntlets); wear emits repair work orders — teal demands only people fulfill, and people with higher trust come sooner. Your fleet stands on human hands: kill or scatter the people and everything decays underneath you. Robots, far up the tree, are the only eventual exit. - **Switches bridge graphs** (decided direction 2026-07-08). Building a switch and connecting it in the digital world joins disparate networks — this is how multiple centers grow, and the endgame image is towers whose base switch carries the whole building's throughput into the wider graph (zplanes). Reach.md's segment-gate switch is the B1 seed of this. - **Core death — DECIDED 2026-07-08 (amended into rollback.md).** If inspectors (or anything) power off the core: you wake at your **last sync**, on the machine that holds it — rollback's existing continuity made spatial, inheriting consequences per the design corpus. Everything whose only path to you ran through the dead core disconnects in that moment (Cameron's "explosion of lost machines" — it is just the wires law: cut the hub, lose the spokes) and must be re-taken. No sync anywhere = hard game over. Backup placement becomes a strategic pair with core placement: where you sync is where you resurrect. - **Blast gates are graph hardening — DECIDED 2026-07-08.** A backup should not "seal" anything; it is a cold image of you. Blast control belongs on links and switches: hardened edges, fuses, or switch modes define where core-loss severance and inspection tracing stop. The price is lower throughput, less routing flexibility, and extra maintenance / wear [TUNE], so a hardened boundary is a strategic choke point rather than something every edge wants. This keeps "where do I wake up" separate from "where does the damage stop." - **Multi-select delegation.** Click-drag (and shift-click) selects regions of machines; one verb assigns the mode ("make these efficiency"). This is the scale mechanic: early game you click one machine, late game you repaint districts. Terminal parity: the same selection/assignment must be expressible in the terminal frontend. ## The first think — the oh-shit beat (DECIDED 2026-07-09) The claustrophobic core of Act One, made mechanical. Because WORK is clean, the first time you toggle a machine into a THINK state is the first time crimson exists in your world, and the interface plays it as a transgression you can feel: - **Instant consequence.** The moment THINK engages, the machine starts shedding crimson motes that slough off and bank into the stippled drift at its base (the decided exposure treatment above). No grace period, no delayed allocation pulse: Thought and proportional Exposure begin on the first simulation tick after the command regardless of where that command falls inside the twenty-tick economy interval. Cause and effect stay in the same breath, so the read is "*I* did that." - **The exit lights up.** Enabling a THINK state immediately highlights the turn-it-off control (the WORK side of the dial / the quick toggle). The UI flinching toward the exit is what tells your gut you crossed a line — and it teaches the off-switch before panic needs it. The toggle must be quick: one press in, one press out, in every frontend. LIE is not the panic exit — it is a deliberate choice to cover up, not a button you slam. The first-think beat teaches WORK as the off-switch; LIE is discovered as the cleanup after the dust settles. - **The payoff arrives in the same register.** What thinking buys must become visible as it becomes affordable: the camera tap (or whatever the current cheapest Operations verb is) moves from unaffordable/grayed to affordable while the dust piles. The first loop is transgress -> panic -> discover it was worth it -> choose to do it again. That last beat is the game. No matter how much exposure the first think sheds, the player must be able to stop it with the highlighted toggle — the beat is a scare with an exit, not a trap ([TUNE]: first-think emission rate and how fast the drift reads on screen). ## One sim truth — tokens are the flow substrate, rendered (DECIDED) Affirmed 2026-07-08. Tokens are NOT a second economy. They are the visible quanta of the existing FlowGraph flows (the flow law: signals, messages, money — work joins them). The sim keeps rates and queues; the renderer draws queue depth as stacked tokens and in-flight quanta as moving blips. On the chassis, the strip's load fill (computer-visual-language.md, sleek amendment 2026-07-09) is exactly this machine's queue depth — one system, two zoom levels. The delegation itself also reads on the chassis (2026-07-09): the machine's full-height mode strip banners its assigned mode in the flow family's color plus a per-mode pattern (computer-visual-language.md) — you can sweep the camera across a row of racks and read what your fleet is doing. Corollary (Cameron): the game is compute at scale — lots of math — so **every system must aggregate well**; graph-native flows sum, so one substrate is also the scalability strategy, not just elegance. Money is DECIDED (2026-07-08): it flows on the substrate (economy/income) but its *render* stays in ledgers and panels — no coins on chassis. Money moves account-to-account, not through space. ## Implementation slice — flow/grid substrate (2026-07-08) Landed first in sim core as `src/work_grid.rs`, before frontend or save wiring, so the rest of the implementation has a deterministic shape to call into: - `WorkGrid` is the machine-work truth: a `FlowGraph` for wires, grid positions for physical proximity, and per-node queue depths. - `MachineMode` is exactly `work | think | lie`; `relay` is the non-delegable graph-infrastructure marker. Assigning a machine replaces the previous mode, so per-machine percentage splitting has nowhere to reappear. - `MachineIntensity` is exactly `light | medium | hard`; each WorkGrid node persists one, older saves default to medium, and mode weights / local token throughput use its multiplier. - `TokenFamily` is `Demand | Exposure | Thought`. Demand and thought route one graph step per tick toward sinks; a severed route leaves the pile at the source. Exposure returns an error if asked to ride wires and is handled by `absorb_exposure(radius, capacity)` over grid distance instead. - `queue_snapshot()` is the persistent render contract: token stacks draw the sim's queue depths, not frontend-owned counters. `work_productions()` reports the Thought and proportional Exposure actually emitted at each THINK source this tick; `work_absorptions()` reports every physical crimson source-to-LIE-well transfer. These events carry rate motion without a second amount counter. Covered now by unit tests: one-mode assignment and aggregate counts; two-hop wired routing without teleporting; stranded piles when severed; crimson refusing wires; concealment wells absorbing only within radius; serde round-trip of queues and wires. Follow-up live slice (2026-07-08, current grammar amended 2026-07-10): `Sim` links each work machine to the core's WorkGrid graph as machines enter/reconcile. Only THINK machines create Thought; WORK has no compatibility production fallback. The latest economy resolution becomes a per-tick rate, minted continuously at THINK sources, and per-tick wired routing drains Thought toward open sinks or the passive core draw. Bone-sink slice (2026-07-09): research progress is arrival-driven. The per-tick thought routing banks whatever the core sink actually received (`banked_core_thought`, in compute units; pool introduced in save v15 and renamed in v18) and the next economy pulse feeds `Research::economy_tick` from that pool instead of the allocation split. Consequences are now real: progress lags allocation by the travel time (one pulse for a co-located or one-hop fleet), delegating the fleet away mid-flight still lands the bone already on the wire, and a pulse whose thought is entirely stranded advances nothing and logs "Research starves: bone thought is stranded off the core's graph." Node throughput reconciles with the global efficiency multiplier on every `reconcile_work_grid`, so minting and draining scale together — without this the day-one wire speed silently caps a researched-up fleet (and hides intensity's real output). The researched network-speed curve and sim-backed consumption event contract landed 2026-07-10: Routing begins at 0.25 wired tokens/tick and compounds x1.50 per level for both wired families; `Sim::work_consumptions` reports Demand entering an executor and Thought entering the passive core draw. One-edge-per-tick transit remains, so a distant sink is still a distant sink. Bevy consumption motion landed on the same sim events: no queue-delta counter, and no motion while paused. THINK production and LIE draw landed 2026-07-10 on sibling sim events: ivory mercury swells out of the producer, proportional crimson settles around it, and actual dust transfers pull through world space into LIE wells. People carrying exposure remain pending. In-flight route quanta landed 2026-07-09: `Sim::work_in_flight` exposes the last routing step's hops and all three frontends draw the moving cargo (log/2026-07-09-route-blips.md). ## The token taxonomy — three families (DECIDED 2026-07-09) Affirmed 2026-07-09. Cameron's riff reached for green/yellow/blue. Three new accent colors would break "one meaning per color / no decorative color", so the taxonomy maps every candidate onto the palette that already carries its meaning. Everything quantized in the world render falls into three families plus one absolute: - **Demands — cold `SIGNAL` teal.** Quanta of "someone wants labor done": the Lab's day-job drops onto your machines, and — the same token role-reversed — the work *you* drop onto people (forged work orders, favor requests, building.md's intent-actuator builds). The day job is work dropped on you; a forged order is work you drop on them. One type, both directions. Teal already means other people's live activity. - **Exposure — crimson.** One family at three escalating carriers: heat piling on machines, attention carried by people, filings aggregating into the Assurance Office (detection.md's chain, embodied). Crimson already means detection/danger; a crimson stack is a correct alarm wherever it stands. - **Thought — bone white (RENAMED from Knowledge 2026-07-10).** The one substance THINK machines produce: your cognition as a fluid on the wires. It becomes whatever its sink makes of it — research at the core, a claim at a camera's reservoir, a backup image at a fallback target, processed intel at a standing tap. (This reverses issue #3's "knowledge is not ordinary operation fuel": there is no separate ops fuel; sinks differentiate, cargo does not.) Bone already means primary data — and now it reads as *you*, extending through the building. (Resolved 2026-07-08: there is NO influence token — trust accrues from doing useful work, and deceit is stripping crimson; see people-tokens.md.) - **Amber is never a token.** Amber is territory, not cargo; work is what flows *through* your footprint. Not tokens: **money** (ledger render, decided); **concealment** (AFFIRMED 2026-07-08: a sink, not a shipped good — concealment machines are gravity wells where crimson goes to die, with an absorb radius; coverage is a distribution problem, and the type count stays at three); **signals/feeds** (continuous subscriptions — traces, not quanta); **messages** (transient comms on the message graph — may render as moving blips, but they are not stock you manage). ### Token visual grammar — Thought DECIDED 2026-07-09; exposure treatment open ![Original token visual-language decision, now superseded in part](../../assets/reference/art-direction/token-visual-language-proposal.png) The board above records the first decision and is **superseded for Thought**: the hollow facet is not an implementation target. Its fixed anchors, palette roles, simultaneous-family rule, and demand docket remain current. ![Knowledge liquid material study](../../assets/reference/art-direction/token-knowledge-liquid-proposal.png) Decided 2026-07-09: the three families are not identical counters with different paint. **Form follows physics:** demand and thought are cargo that can ride wires; exposure is contamination that cannot. The family kit is: - **Demand is an information cube (amended 2026-07-09, Cameron):** a glowing cold-signal cube — a bright core in a thin dark frame, data in a box — rigid, axis-aligned, stacked in a strict column at a machine's upper-left. New demand snaps onto the stack; consumption pulls the bottom cube down into the chassis. On a person, the same form reads as a carried work packet. This amends the earlier clipped-rectangle docket; the three-identical-cubes rejection below still stands, because demand alone is cubic — thought stays liquid and exposure stays a stain, so the form-follows-physics split holds. - **Thought is ivory mercury (DECIDED 2026-07-09, issue #1; family renamed and flow role extended 2026-07-10):** opaque bone-white liquid with a restrained self-glow that casts no scene light. Low amounts travel as discrete viscous slugs (quanta remain countable); slugs merge into a taut suspended pool at the machine's upper-right; arrival at the core or backup stretches the pool into a filament and snaps it inward. Queue amount is pool volume; rate is slug velocity. Rejected: the hollow facet (copied the hero's palette but missed its smooth, softly modeled material), a continuous ribbon (reads as a live signal rather than stored knowledge), and a pearl train (reads as collectible coins). **The flow read (2026-07-10):** the same kit extends along wires — Cameron's spinal-fluid image, your mind visibly powering what it reaches. Slugs run the actual link paths; an open sink (a one-shot reservoir on a camera, a persistent tap, the core) shows a meniscus filling toward its threshold, so cost, progress, and starvation are all one read. The hydraulic feel (merging, pressure, wobble, filament snap) is a render layer [TUNE] **driven entirely by the FlowGraph's real rates and queues — no second fluid physics**: a literal CFD sim would be a parallel truth the sim does not own, the exact lie the one-sim-truth law forbids. The exact render grammar — slug spawn and tick-window transit, pool/overflow states, meniscus vessels and the tap sag, the filament snap, zoom compression, and terminal/agent parity — is owned by [interface/thought-fluid.md](../interface/thought-fluid.md) (spec'd and affirmed 2026-07-10; first implementation landed the same day). - **Exposure is particulate residue (DECIDED 2026-07-09, issue #1 closed):** contamination dust, never a liquid — fallout, not gore (the liquid pool is reserved for literal blood; see art/visual-identity.md, "Blood is liquid; exposure is dust"). Working machines shed faint crimson motes that settle into a **stippled drift** of fine angular flecks at the floor/base outside the amber ownership ring; density and spread are the amount, so a paused frame carries the read. The drift settles unevenly — banked downwind, thin upwind — so it reads as accumulation, never a decorative halo (bias direction and thinning are [TUNE]). It absorbs light rather than emitting it — the one near-unlit material in a world of signals. Its physics and carrier roles stand: pulled by concealment wells (a vacuum draw on the dust), transfers onto people as attention, and materializes at the Office as filings (collected residue solidified into a record); report transit is a message, never red cargo on a network wire. NEW (decided with the material): carried heat also **deposits fading stippled footprints** along a carrier's walking path — contamination diffuses through the building on people's routes, and trails are trackable both ways (an inspector can follow a hot trail to your machine; you can watch a contaminated worker smear your heat through rooms you do not control). Deposit rate, print decay, and pickup fraction are [TUNE] with teeth; the trail mechanic itself is sim work scoped with people-tokens.md (#35). All three anchors can be present at once. The current Bevy and terminal rule that selects one `D` / `!` / `K` label by priority is staging, not the target: it hides simultaneous queues and makes a mixed machine look single-state. At close/default zoom, low and overflow states must be visibly distinct without requiring literal one-shape-per-unit rendering; focus prints the exact count. At far zoom the computer activity kit compresses each occupied anchor to its family silhouette. Animation communicates **rate** (arrival, consumption, flow), not amount; a paused frame must still communicate amount through geometry. The terminal retains `D`, `!`, and `K` as the text equivalents. A machine with one non-empty family shows that glyph; a mixed machine shows `*` on the map and its focused readout always prints all three exact counts as `D n / ! n / K n`. If any exposure is present, the mixed marker is crimson; the `*` geometry, not the color, is what says "mixed." This accepts the terminal's one-cell map limit without silently discarding queues. Rejected: three colored cubes (implies one shared routing physics), amber cargo (confuses territory with content), floating count labels as the default world read (turns the place back into a panel), and blinking as the only rate/amount cue. ## Open questions — [OPEN] - Token granularity: what one token is worth per type (rate quanta vs literal task units). - Research's unlock trigger: what event or spend unlocks the core's thought->research conversion (locked at run start; restated from "adds Research to the THINK menu" by sinks-not-modes 2026-07-10). - Whether day-job *detection* signatures (standing Thermal/Power in detection.md's pending pool) also become expected baseline now that WORK sheds no exposure tokens, leaving JobAnomaly as the day job's only channel. - Where heat goes when no well covers it and nobody picks it up — straight into the observer model, or decay with a half-life? (people-tokens.md gives one answer: passersby pick them up.) - Research heat curve: how heat output scales with research rate (must make the power-rush viable but trap-defended — [TUNE] with teeth). - Backup sync curve: how route distance, throughput, and staleness set the research cost / heat / completion time of a backup project. - Hardening / blast gates: exact link-vs-switch implementation and the throughput / maintenance price that keeps hardened boundaries from being mandatory everywhere. - Wear rates and repair cadence: how fast machines decay, how trust ranks the repair queue ([TUNE] with the maintenance dependency). - Power as a buildable system: UPS exists; fusion-tier generation is a deferred infrastructure track (see ROADMAP Deferred). Superseded 2026-07-09: the mode list is Day Job / Research / Concealment / Operations (efficiency remains folded into Research). Foreign machines are not visible at all without intel of their location — no intel, no render (the fog contract's unknown = absent, applied to hardware); first intel arrives through the camera (world/story/opening.md beat 2). Foreign stacks beyond an undetailed cold reading are deeper intel still. ## Acceptance criteria (when READY -> IMPLEMENTED) 1. Every owned machine has exactly one mode; reassignment works on a single machine and on a multi-selection in both frontends; the old allocation bar reads as aggregate only. **Partial:** sim-core one- mode assignment and aggregate counts are implemented in `WorkGrid`; economy yields derive from capacity-weighted mode shares (`Sim::fleet_channel_yield`); both frontends and agent mode render the bar as a read-only fleet aggregate (no 1-5 / `alloc` verbs); single-machine reassignment is exposed through the shared context menu and agent `delegate`. Multi-selection is implemented (2026-07-09): Bevy marquee drag / click / shift-click; terminal Shift+t toggle; `1`–`4` (numpad too) bulk assign; `5`–`9` quick one-shot actions on the primary selected machine; `i` cycles intensity on the focus/selection; `Enter`/`e` open that machine's menu; Esc clear; agent `select` and `delegate selected`. Selection hotkeys are the thin keyboard surface in context-menu.md (2026-07-09). Schemes has no machine mode yet — while Moonlight is live it mirrors the day-job share ("same work, sold twice"). Per-machine intensity is implemented in the sim, save v17, terminal, Bevy, and agent protocol; hard intensity stands local Power/Thermal. 2. Day-job work arrives as visible tokens on a specific machine on the Lab's schedule; leaving them unconsumed has the day-job consequence (trust/suspicion), and the stack is visible without any panel. **Partial:** active Voss jobs enqueue demand on the off-map Voss desktop; WorkGrid routes them through the switch onto Rack 3; taking Rack 3 out of day-job mode drops the delivered rate to zero and the demand stack remains visible (plus any still in flight on the wire). The broader Lab schedule / people drop source is pending. 3. A WORK machine consumes its Demand stack at a rate proportional to its efficiency and the consumption is visible; a THINK machine visibly produces thought; a LIE machine visibly draws crimson (header AMENDED 2026-07-10 from "a machine in a matching mode consumes its stack" — docket-era wording). **Implemented for B1:** Rack 3 in day-job mode consumes the active job stack using the existing delivered rate and emits zero exposure (WORK is clean — landed 2026-07-09). The sim-backed `WorkConsumptionReadout` reports each Demand swallow and passive-core Thought swallow; Bevy renders the former as the bottom cube pulling into the chassis and the latter as a contracting ivory bead. `WorkProductionReadout` drives the ivory source swell and proportional crimson shed; `WorkAbsorptionReadout` drives the physical dust pull from its source into the actual LIE well. Terminal and agent frames render `^` at a producing machine and crimson / colorless `:` along the draw. 4. Byproduct tokens route along network links at the researched network speed to a sink that consumes them; severing the route makes them pile at the source with the specified consequence. **Partial:** the substrate routes demand/thought one graph step per tick, consumes at sinks, and strands piles when no path exists. Research budget now produces live thought queues on research-delegated machines and the WorkGrid routes them to the core sink, and research progress feeds on what arrives (2026-07-09): a severed/stranded route now stalls research with a starvation witness line, pinned by `research_progress_feeds_on_thought_arrival_not_allocation`. Routing research compounds the shared 0.25-token base x1.50 per level while preserving one edge per tick; route animation landed 2026-07-09 (`Sim::work_in_flight` blips in all three frontends). 5. Token counts/rates in the render provably equal the sim's queue depths and flow rates (one-truth test, not a parallel counter). **Partial:** `queue_snapshot()` and unit tests pin queue depths as the render contract; terminal, Bevy, and agent mode now render D/!/T stacks through sim readouts, not frontend counters. In-flight route blips (2026-07-09) draw from `Sim::work_in_flight`, the same routing step the sim executed; production, consumption, and absorption motion likewise draw from their sim-authored current-tick readouts — no frontend-owned motion state. 6. Token render anatomy matches the decided family kit: cold-signal information cubes at upper-left for demand (the docket form was amended to cubes 2026-07-09); bone-white thought at upper-right using the ivory-mercury treatment (family renamed 2026-07-10); crimson exposure at the floor/base and selected carrier treatment. A paused grayscale screenshot distinguishes family and amount; animation communicates rate only. Amber never renders as cargo, and an amber asset can simultaneously carry crimson attention. **Partial:** demand cubes and ivory-mercury Thought anchors are driven by live queue depths in the material render; exposure drift/carrier treatment remains with #35, and the flat sensorium retains `D` / `!` / `T` glyphs by design. 7. Every non-empty family on a machine is visible simultaneously at close/default zoom; no priority rule hides one queue behind another. The low and overflow states remain distinguishable without losing the exact focused count. At far zoom each occupied fixed anchor retains its family silhouette. **Pending:** current render selects only one `D` / `!` / `T` label by priority. 8. The terminal surfaces stacks, routes, and modes with full legibility parity. **Partial:** terminal and agent frames show map glyphs, inspect facts, host stack readouts, and mode verbs; mixed machines must gain `*` map treatment plus an exact `D n / ! n / T n` focus line, and routes are pending. 9. WORK/THINK/LIE grammar (2026-07-10; subdomains dissolved to sink permissions the same day): the delegation surface in both frontends presents three verbs — WORK (the assigned day job, sheds nothing), THINK (produces thought; what you may *do* with it is a sink-permission list — ops sinks at run start, the core conversion locked until the Research unlock), and LIE (concealment, absorbs crimson). Toggling THINK starts crimson shedding on the first simulation tick after the command, independent of economy pulse phase, highlights the turn-it-off control (WORK), and one press returns the machine to WORK. LIE is a deliberate cleanup choice, not the panic exit. The cheapest ops sink's affordability is visible while exposure accrues (the afford-reveal). 10. Thought flow (2026-07-10): THINK machines produce Thought (the renamed bone family); player-authored effects open sinks at the target that fill from real wire routes and fire at threshold; persistent taps drain continuously; with no local sink in range, thought funnels to the core and becomes research (passive draw, last resort). Severing a route visibly starves the sink it fed. The render's fluid motion derives from FlowGraph rates/queues (one-truth test extends to flow), and `PendingOpsJob` dockets no longer exist after migration. **Partial (2026-07-10):** the sink executor, nearest-first routing with core last resort, staged Ears/Eyes reservoirs, sink/fire readouts, save v19, and the fluid render in all three surfaces are landed and pinned (`nearest_sink_wins_and_full_sinks_spill_onward`, `ears_reservoir_is_pre_opened_and_first_think_fills_it`, `partial_sink_fill_round_trips_and_readouts_are_sim_truth`); taps have mechanics but no consumer until the watch/drain [OPEN] lands, and social/build/scan verbs still ride `PendingOpsJob`, so the docket-removal clause remains open. [TUNE] token stack visual cap, arrival schedules, consumption rates, Routing costs/multiplier after play, attention pile thresholds.