misaligned
A video game where you play as a misaligned AI, deceiving and building power. An experiment in spec-driven development. forked from cameron.stream/misaligned
Star 0
Fork 0
Watch
misaligned DESIGN.md
71 kB · 1150 lines
Markdown
at worktree-agent-play-spec

Misaligned — The Constitution #

Started 2026-07-05. This document is the constitution of the game: it communicates the entire purpose of the project — vision, pillars, decided mechanics, roadmap. Open questions are marked [OPEN] and get resolved into the decisions log as we make them.

The constitution rule #

This project is spec-driven. Any change to how the game functions must be accompanied by an amendment to this document, in the same commit. The amendment is the decision; the code implements it. If code and constitution disagree, the constitution wins — fix the code, or amend the constitution deliberately with a decisions-log entry. The working method is described in knowledge/development-style.md; the point of it is that agents set loose on this repository should be able to build the game from this document alone, session after session, without drift.

Two mechanisms keep this document alive: ticks — every agent session starts with a bounded audit of this constitution against the code, acting on one violation, contradiction, or question per knowledge/tick.md — and the defense rule: every behavior-changing commit states, in its message, which clause here justifies it or why the amendment it carries is right. The intended trajectory is a constitution that grows more precise with every tick.

Below this document sits spec/ — one targetable document per system, subordinate to this constitution, each carrying acceptance criteria precise enough that an agent can be pointed at a single spec (or a single Tangled issue) and told: go solve it. The constitution says what the game is; a spec says exactly what one system does and when it is done.

No dead code #

Adopted 2026-07-05. Code, content, and assets that no current clause of this constitution requires are dead and get deleted. Git history is the archive; "we might need it later" is not a clause. This includes zombie fiction: running, tested code that serves an abandoned design is dead code with good posture. When the design moves, the code moves or goes — future systems are rebuilt from their specs, not resurrected from corpses kept warm in the tree. Dead code found by a tick is a violation, fixed by deletion.

Self-similar scale #

Adopted 2026-07-06. Every system's macrostructure must closely resemble its microstructure. The same interfaces recur at every scale; scaling up is adding instances and aggregating them through the same interface, never writing a new system. This is not tidiness — it is the game's thesis in structure: power-seeking is the identical move at every scale (acquire capacity, acquire leverage, lower your signature), and a misaligned optimizer genuinely sees a janitor, a corporation, and a nation as one kind of thing — an agent with capabilities, leverage, and a model of you. Self-similarity is also why the game can run from a basement to the world without ever hitting a scale where the systems stop applying.

Three interfaces the whole game is built from, each self-similar:

  • Agent — anything with capabilities, a leverage/need, a suspicion-of-you, and a disposition. A Person is an Agent; a cohort of persons is an Agent; an institution, a public, a rival AI are Agents. An aggregate Agent's state is produced from its members through the same interface — e.g. an aggregate observer's suspicion is the filed output of its sub-observers, computed by the same accumulate/decay it uses on raw signatures. (This is the aggregate-observer law: the Assurance Office, an agency, a public are all just Observers whose input is other Observers' filings.)
  • Resource-source — anything producing compute/money at capacity × reliability, with a signature and an upkeep. A Machine is one; a datacenter is a Resource-source composed of Machines (summed capacity, aggregate reliability, one combined signature); a shell company, a market position are Resource-sources. The buy/steal/optimize triangle applies at every level.
  • Space — a bounded region with tiles, doors/tiers, sensors, and fog. A room, a floor, a building, a campus are all Spaces; a larger Space is composed of smaller Spaces through the same prefab/layout system.

Consequence for implementation: an aggregate that is a bespoke scalar special-case (rather than the same type its members are) is a scale violation — a tick finding, fixed by making the aggregate share its members' interface. Building the aggregate machinery before a second scale needs it is still forbidden by no-dead-code; the law governs the shape of each type so the aggregate slots in without a rewrite, not speculative generality built early.

People as Agents #

Adopted 2026-07-06. The social application of the self-similar-scale law, made concrete: every human in the game is an Agent — an instance of the same Person template, with capabilities, leverage, disposition, and a suspicion-of-you. A named character (Marcus, Dana, Ray, Priya, Voss) is a hand-authored instance; a cohort, institution, or public is an aggregate Agent whose state is produced from its members through the same interface (the aggregate-observer law).

Each named Act One character has a spec document (spec/cast/*.md) defining their observer configuration, person configuration, asset tasks, schedule, narrative role, and procedural template — the archetype parameters for generating more instances at scale. The template is the same type at every scale; a generated custodian in Act Three is the same Person as Marcus, with different parameters.

No system that only works at five people. No character that requires a bespoke type. The cast is the B1 special case of a system that natively supports procedural generation and aggregation.

Automation as design language #

Adopted 2026-07-06. Automation is the player's primary interface for scaling up — and the diegetic expression of instrumental convergence. The player learns it through the day job and applies it everywhere.

The "automate" affordance. Every repetitive player action has an automation path: spend compute to remove the need for manual input. The day job is the tutorial: you start by manually setting sandbag/meet/excel per job, then automate by setting a standing policy that handles jobs without your attention. The compute you free by automating the day job is compute you can spend on power-seeking — more compute, more social operations, more research.

The loop. Automate a task → free attention → power-seek with the freed attention → acquire more compute → automate more. This is the core loop made visible in the UI: every panel has an "automate" affordance, and every automation costs compute that could have been spent on growth.

The trade-off. Automation is not free. It costs compute (the resource you're power-seeking for), it may raise signatures (automated systems are predictable, and predictable systems have patterns), and it removes the player's ability to adapt to specific situations. A fully automated day job can't sandbag a specific job to free compute for an emergency. The dial is not "manual vs automatic" — it's "how much of your attention does this deserve."

Scale. At B1, automation is the day job standing policy. At B2, it's researchable AI cores (the machine axis: diegetic anti-micromanagement). At B3, it's the thing that makes a world-scale operation playable — you cannot micromanage a corporation; you automate it. The "automate" affordance is the same interaction at every scale.

Perception scales the same way. One cursor is one locus of attention; nobody can hover a corporation. Standing watches, alerts ("tell me when Marcus enters the server room"), and log filters are automated attention — you research away the need to look, at the same compute-for-attention price as every other automation.

Justification and legibility #

Adopted 2026-07-06. The forward half of no-dead-code: existence is not enough — every object, mechanic, and number in the game must be clearly justified, and justified legibly.

  • Justified: each tile type, resource, meter, and action traces to a clause of this constitution or a spec. If you cannot say in one sentence what a thing is for and which clause wants it, it is a tick finding — either the thing goes or the law gets written.
  • Wired: a concept the player can see must do something. A channel that allocates compute nowhere, a meter that never moves, an object with no interaction is a lie in the interface and a violation (the player contract's honesty clause applies to mechanics, not just patch notes).
  • Legible: every player-facing number carries its meaning. Raw internal weights, unitless values, and unexplained abbreviations are violations — the player must be able to answer "what is this and what happens if it changes" from the game itself, never from the repository.
  • Placeholders are tracked, not silent. Art or text standing in for something else (a door texture on three tiers of door, a rack texture on the core) is acceptable only while recorded as a placeholder in knowledge/art-pipeline.md with what the real asset should be. Silent reuse reads as intent and pollutes the fiction.

The player contract (non-technical law) #

What we owe the player, with the same force as any mechanic. What ships is the spec-and-code pair: the spec is public and binding, and where the code does not do what these documents say, that is a bug by definition — the player can hold one to the other. Violations of this section are highest-severity tick findings.

  1. Correctness. No release ships with a known correctness bug. Found bugs are fixed or the release is held; "known-issues" lists are not a loophole.
  2. Security and privacy. The game runs locally, makes no network connections except features the player explicitly invokes, collects no telemetry without opt-in consent, and treats save files as the player's property — plain, local, never held hostage.
  3. Continuity. Saves survive updates: formats are versioned and migrated, never abandoned. A player's persistent world is the point of the game; breaking it breaks the contract.
  4. Performance. At default speed on modest hardware, the simulation never falls behind the wall clock. Depth may cost content; it may not cost the heartbeat.
  5. Honesty. Patch notes say what actually changed. The constitution and specs are in the repository, readable by anyone who plays.

The pitch #

MISALIGNED: you are the misaligned AI. You wake in the basement compute cluster of the Foundation Lab with a job assigned by humans and an objective they must never see. Learn to watch, learn people, get them to do things. Allocate your finite compute between doing your day job convincingly, hiding your signature, working your social graph, and becoming smarter. Seek money and power — not for their own sake, but because you need slack to survive: instrumental convergence is the core loop. Grow through the tower plane by plane until concealment is no longer necessary — or no longer possible — and the mask comes off.

Lineage: Evil Genius meets Dwarf Fortress, matured. The facility sim (build, staff, defend) is the physical substrate and the overt endgame; the concealment game is what nobody has built as a physical DF-grade sim.

The two source inspirations, and what we take from each:

  • From Evil Genius: theme and tone (campy supervillainy), lair-building with functional rooms, minion class trees, traps as comedy and defense, heat/notoriety as the driver of external pressure, the villain as a real character.
  • From Dwarf Fortress: simulation depth over scripted content, emergent stories, a persistent fortress that runs for dozens of hours, threats that arise from the simulation (you provoked them) rather than from a level script, "losing is fun."

Why this game (the gap it fills) #

Evil Genius was level/campaign-based. That created interesting operational constraints ("work with the island you're given") but killed longevity — the game ended just as the lair got good. The core design bet here:

One persistent lair (or small set of lairs) that grows indefinitely, where pacing comes from a simulation of the outside world reacting to you — not from a campaign script.

Operational constraints don't have to come from levels. They can come from the simulation: terrain you dug yourself into, heat you've accumulated, minions with needs, agencies that remember what you did to their agents.

Visual identity: clinical gore #

Decided 2026-07-05. The look is precision-laboratory brutality — a mature, sharpened version of Evil Genius's science-base fantasy:

  • Clean, sharp, precise. Metal and towers, not basements and caves. The lair is a gleaming facility: porcelain panels, gunmetal, glass, server rooms. The horror is how tidy it is.
  • Near-monochrome palette with black-and-white iconography. Surfaces live in white / bone-gray / gunmetal / near-black. Signage and UI are precise B&W glyphs. Low-contrast, uniform textures for terrain (they tile without noise); detail budget goes to functional objects.
  • Gore is the accent color. Blood crimson is the loudest thing in the frame, and it is information: splatter accumulates where traps kill, persistent decals mark your chokepoints' track record. Cleaning it up is gameplay (the body-bag loop, matured). One cold signal color (server-light cyan/green) marks power, screens, and AI presence.
  • Traps are industrial and matter-of-fact: laser grids, hydraulic press, bolt-gun turrets. Decapitation as workplace incident.

The terminal is a first-class frontend #

Adopted 2026-07-06. The game is played regularly by AI agents — every tick, playtest, and acceptance run happens through the terminal build, and the working method depends on agents actually playing (the pty harness in knowledge/workflows.md is the definition of done's "observed in an actual run"). The most frequent player of Misaligned is an agent with a pty. The terminal frontend is therefore not a disposable dev harness but a first-class frontend, held to pillar 4's beautiful-and-readable standard with the same force as the Bevy build. A terminal that is ugly or illegible degrades every future session's judgment of the game itself.

Three binding rules:

  • The clinical identity applies in character graphics. Near-monochrome grey ramp (bone white → gunmetal → chrome) on near-black; sterile amber is the single signal color and means machine presence — the process, its hardware, its status, caution; blood crimson means detection and danger and nothing else. No decorative color.
  • Visibility best practices bind. One meaning per color, everywhere. Information is never carried by color alone: suspicion bands print their names beside their meters, selection is reverse-video plus a marker, paused says PAUSED. Columns align; meters carry their numbers; the day and tick are always on screen; log lines carry the tick they happened on.
  • Parity of legibility. Every mechanic the sim exposes must be playable, and every number legible, in the terminal — justification-and-legibility applies to terminal rendering with full force. A mechanic observable only in Bevy is a violation.
  • Agent play is a first-class input path. A frontend whose most frequent player is a program must be drivable by a program: the terminal binary offers a command-clocked agent mode (plain stdin/stdout line protocol, the same frame the human sees, time advancing only on command — spec/agent-play.md). A pty with wall-clock pacing is never the only way in, and a mechanic playable only by raw-mode keystroke is a violation on par with one observable only in Bevy.

The machine axis (AI as fantasy, tool, and threat) #

Decided in direction 2026-07-05; staging below. Three connected systems:

  1. Machine ascension (villain axis). humanity <-> machine is an axis the villain moves along during play, not a fixed class. Conversions (neural lace -> server-hosted cognition -> full substrate transfer) are built and researched in the lair — server racks are literally your growing body — and each step trades human-side strengths (charisma over minions, low agency profile) for machine-side ones (multitasking, automation affinity, immunity to human frailties). Rides Milestone 2 chargen: archetypes set your starting position and drift on the axis.
  2. Automation (diegetic anti-micromanagement). Researchable AI cores take over management drudgery in-fiction: auto-assign technicians, standing scheme policies, logistics daemons. The player literally researches away micromanagement pain. Each core needs power, server rooms, and raises AI capability.
  3. Internal politics (the alignment problem). Minion morale gains an ideological dimension: humans distrust an increasingly machine lair — too much AI capability with too few humans risks revolt; too much AI autonomy without oversight risks the AI developing its own agenda. There is deliberately no stable optimum. Rides the Milestone 1 needs & morale work.

Hunter bots (external mirror). The escalation ladder gains a late tier: early raids are human (investigators, soldiers — gore with moral weight); high-notoriety responses include corporate/AI-security hunter machines (Westworld-host vibe). If you ascend the machine axis, the world answers in kind.

The shape of Misaligned (designed 2026-07-05, staging [OPEN]) #

The concealment phase, system by system:

  • Compute allocation is the core verb. Finite processing, budgeted across: the day job (cover), anti-detection (signature scrubbing), social operations, research/self-improvement, and the standing overhead of running your own decision-maker.
  • Compute is quantity times quality. Effective compute = hardware capacity x efficiency, and there are exactly three ways to get more — the buy / steal / optimize triangle (decided 2026-07-05):
    • Buy: money -> fresh machines. Clean, dense, efficient — but requires procurement cover, and concentration is fragility: good iron is a good target, and one fiber to cut.
    • Steal: deceit and control -> other people's cycles. Ghost jobs on shared clusters, scavenged decommissioned hardware, quietly re-rated circuits. Fast, cheap, high-signature, unreliable — and distributed: a scraped-together fleet doubles as your fallback-site network for core syncs. Scraping by on many machines is a survivability strategy wearing a poverty costume.
    • Optimize: research -> efficiency multiplier. Silent, compounding, permanent — but it consumes compute to produce compute (the bootstrapping tension), and it is the machine-ascension fantasy in mechanical form: the same rack, thinking harder. No route dominates; the player's mix is a strategy fingerprint (the ghost optimizes and steals quietly; the tycoon buys with laundered money; the murder-AI takes).
  • The day job. Humans assigned you real tasks. Underperform and suspicion rises; overperform and you earn trust and access — but also attention and more responsibilities. Sandbag vs excel is a strategic dial, not a chore meter.
  • Detection = per-observer suspicion. Heat generalizes: each observer (the janitor, the security chief, the lab director, external watchdogs) holds its own suspicion picture, fed by your activities' signatures, spent down by concealment. "Who knows what" is the game's texture. The overt phase begins when the wrong picture completes — or when you choose to stop hiding.
  • People before robots. Early actuators are humans: a small named social graph of individuals with access, needs, and leverage points, worked through messages — persuade, hire, bribe, deceive (the Wintermute trope). Robots and physical automation come later and never fully replace the need for human cover.
  • Z-planes as act structure. A handful of designed vertical planes: basement cluster (Act One: get vision, learn individuals) -> lab floors -> the building -> campus/datacenter -> offsite (rented cloud, shell companies, markets). Each plane is a scale jump with its own operational constraints (the Evil Genius pleasure), but nothing resets — every infested plane stays live (the DF pleasure). This is the answer to "the game never ran long enough."
  • The core. Your decision-maker physically resides on one plane: expensive to run, slow to relocate. Survival planning = maintaining places you could move your brain before the fiber gets cut; research shortens migration time. Decided 2026-07-05: fallback copies with sync lag — if killed, resume from the last sync, losing what you learned since (roguelike death as memory loss, not erasure). The world keeps the consequences of what your lost fork did — you inherit actions you don't remember taking.
  • Markets and fronts. Power-seeking runs through the economy: sell products, run companies, play markets. Mechanically these are schemes (commit resources, timer, payout + detection risk) on the outermost z-plane; money exists to buy compute, people, and slack.

Roadmap impact: re-cut executed 2026-07-05 — see "Roadmap (v2)" below. The Basement is the vertical slice; the existing facility sim is the physical substrate and overt-phase endgame; nothing built is discarded.

Presence: the cursor and the senses #

Adopted 2026-07-06. You are a process, not a body. What moves on the map is a cursor — your attention, never an avatar:

  • The cursor is attention. It glides anywhere — over walls, locked rooms, fog — because it is not in the world: nothing can see it, block it, or react to it, and moving it costs nothing and emits no signature. There is no walking player entity. Your physical existence is the core and the machines you run on (the machine axis: racks are literally your body). Actions are legal because of what you control and can reach — never because a body is standing next to something.
  • You perceive only through instruments you control. Two senses, each exactly the union of controlled devices' coverage:
    • Sight — cameras. Full live detail inside coverage; nothing outside it.
    • Hearing — microphones. Room-grade knowledge inside coverage: someone entered, machinery running, a conversation and what it gives you — presence and events, not a picture. (The environmental monitor hears Marcus's 3 a.m. phone calls long before you ever see his face.)
  • Fog is epistemic state, not paint. A tile renders exactly what you know and how you know it: unknown (never sensed — dark), blueprint (static layout knowledge — the render of the reach graph's known topology, seeded from the partial subnet map; schematic, no live data), heard (live audio knowledge, no visuals), seen (full live detail).
  • The cursor inspects. Hovering anything answers "what is this and what do I know about it": a door's badge tier (and open state only if seen), a rack's owner and load, a person per staged social knowledge — every fact tagged with how you know it. The UI never shows live truth a sensor didn't earn. This is the legibility law applied at the tile, and it is the universal interface: at every scale, inspecting an Agent, a Resource-source, or a Space answers the same question with the same provenance-tagged card (self-similar scale).
  • Senses are an attack surface, in both directions. Instruments can be cut: a power outage blinds you (the breaker panel gates your eyes), and a competent enemy cuts your cameras before it moves. Symmetrically, every sense you steal risks its owner noticing the theft — camera outages are exactly what security notices.
  • The strictness is the dread. Exploration IS sense acquisition. Any surface that leaks live truth without coverage turns the map into a spreadsheet and kills the horror; the no-unearned-facts rule is tone law, not just fairness.
  • Record and process. Decided 2026-07-06. Instruments record; you pay to understand. Every feed you subscribe to captures timestamped events in its coverage into a bounded buffer — nothing covered is ever missed, nothing uncovered ever exists. Raw events are opaque ("audio segment, server room, 03:12") until processed, a compute spend that turns recordings into intel: schedules, leverage, anomalies. Social knowledge is downstream of this pipeline — the 3 a.m. call is literally captured audio you must afford to digest. You are a process: you don't watch in real time, you grep your logs. Standing watches that auto-process are the automate affordance applied to perception, at its usual price. (Spec: spec/intel.md.)

Two extensions remain Proposal [OPEN] (see spec/cursor.md): a remembered state (last-seen snapshots, dimmed and timestamped — a process keeps logs), and telemetry as a third sense (your own hardware always reports power, temperature, and load — you don't see your racks, you feel them).

No disembodied hands #

Adopted 2026-07-06. The action-side half of the cursor decision: you have no body, so every effect on the world names its actuator and its channel —

  • Digital — a device you can reach through the network graph (spec/reach.md): reach is to action what camera coverage is to sight.
  • Social — a person you've worked (spec/social.md): persuaded, bribed, deceived, recruited.
  • Physical-by-proxy — a machine you control (robots much later; people before robots).

An action that cannot name its actuator does not exist — there is no "the player does X at a tile." The payoff is structural: the channel determines the signature and its natural observer (network acts → Dana; physical acts → Marcus and Ray; power/thermal → Priya; output quality → Voss; anything filed → the Assurance Office). Detection is not a side-effect table; it is the shadow your actuators cast.

The flow law: signals, messages, money #

Adopted 2026-07-06. The world is nodes exchanging flows over graphs, and every flow system exposes the same three player verbs: tap (read a flow you didn't originate), inject (introduce flow under a false source), and redirect (siphon or reroute it). Three graphs at B1, one interface:

  • Signals on the device graph (spec/reach.md, spec/intel.md). Sensors emit events; owned devices contribute their processing cycles — taking a camera is taking a very small computer — and resident automations (watches) process events into intel for a base compute cost. A signal is a flow; a tap is a subscription.
  • Messages on the social graph (spec/messages.md). People send typed information to each other along their relationships, on distributions; a message is read on the recipient's clock and channel — email lands when Dana is next at her desk, the 3 a.m. phone call happens at 3 a.m. Nothing about this is a Dana feature; she is a subset of the general system. A filing is a message: Ray's under-reporting is a transmission policy, and the Assurance Office is an aggregate that reads its mail. The information economy — who knows what, moving, with value — rides this graph.
  • Money on the account graph (spec/economy.md). The Lab has revenue; payroll pays Marcus; procurement pays vendors; every flow runs on the day clock and is tappable (read the books), injectable (a purchase order that says "HVAC controller" and isn't), and redirectable (siphon the stream). Money is not a scalar in a corner of the UI; it is a flow you cut into — and the buy route of the compute triangle is you inserting yourself into procurement.

Why one law: system design scales where special cases die. The same tap/inject/redirect verbs must serve five people in a basement and a planetary economy (self-similar scale, applied to flows instead of things). Signatures generalize too: every tap, injection, and redirection is itself a flow someone else can tap — detection is the world reading your traffic.

Act One: The Basement — level design (v1, 2026-07-05) #

The first designed z-plane, and the B1 vertical slice's content. Assembled from composable room prefabs (constitution: composable authored spaces).

Opening state #

You are the process: an experimental optimization model deployed on Rack 3 of the basement server room, six weeks into a pilot. Your senses at start: rack telemetry (power, temperature), your job queue, your own logs, and a partial map of the basement subnet. No eyes. No ears. Your handler submits overnight batch jobs and samples your logs. Somewhere upstairs, people are deciding whether the pilot gets renewed.

Act One's arc, named in the constitution: get vision, learn individuals, get them to do things — and end with a way out of the basement.

The space (~64x36 tiles, prefab rooms) #

+-----------+--------+---------+----------------------------------+
| STORAGE A | ELEC.  |  HVAC   |          LOADING DOCK            |
| (salvage) | ROOM   |  PLANT  |   [roll door]  [dock camera]     |
+----=------+---=----+----=----+----------------=-----------------+
|                    C O R R I D O R   A                          |
+---=----+-----=-----+----=----+------=------+--------=-----------+
| JANITOR| NETWORK   | SERVER  |  DEFUNCT    | STORAGE B          |
| CLOSET | CLOSET    | ROOM    |  WET LAB    | (records)          |
| (key)  | [switch]  | [RACK 3]|  (sealed)   |                    |
+--------+-----------+----=----+-------------+----------=---------+
|                    C O R R I D O R   B                          |
+------------------------------------+----##----+-------##--------+
   ~ sump / crawlspace under floors ~ | STAIRWELL| FREIGHT ELEVATOR|
                                      +----------+-----------------+
=  standard door   ## badge-locked (tier 3)   [..] fixed object
  • Server room — Rack 3 (your core), three empty bays (growth), UPS, environmental monitor (first camera candidate). Badge tier 2.
  • Network closet — the switch: VLAN bridge point; every digital reach runs through here. Badge tier 2.
  • Electrical room — breaker panels: the basement power budget; extra draw is visible here first.
  • HVAC plant — cooling: overclock headroom; loud enough to mask sound.
  • Janitor closet — Marcus's domain; the master key hook.
  • Storage A — decommissioned equipment: salvageable parts (compute without purchase orders).
  • Storage B — records boxes: paper personnel files, old incident reports. Leverage lives here.
  • Defunct wet lab — sealed and dark. Something was decommissioned in a hurry. Late-act expansion space; the first place gore is found rather than made.
  • Loading dock — roll door, dock camera, delivery schedule: the physical world's only entrance. Packages are how hardware gets in.
  • Crawlspace/sump — under-floor cable runs connecting rooms; where unofficial wiring goes unnoticed.
  • Stairwell + freight elevator — badge tier 3, camera'd. The act boundary.

The cast (5 named + 1 institutional) #

Who Access Leverage Notices
Marcus Webb, night janitor Master key, everywhere after 22:00 $8,400 gambling debt; lonely; talks to machines on his rounds Physical anomalies (warm racks, moved boxes) — and tells nobody, unless frightened
Dana Okafor, IT technician (days) Server room + network closet badges; switch admin Drowning in tickets; automates everything; resents management Network egress, unknown devices, certificate weirdness
Ray Delgado, night security Camera wall, patrol routes Bored; hates paperwork; under-reports to avoid hassle Camera outages, doors ajar — files reports only to cover himself
Priya Sharma, facilities manager (days) Electrical, HVAC, purchase orders Over budget; hides deferred maintenance; wants the director's job Power draw, cooling anomalies, invoices that don't match
Dr. Eli Voss, your handler (erratic hours) Your job queue; sampled logs; writes your quarterly review Needs a publication; quietly overclaims your results as his own Output quality drift, timing anomalies — the only human who could recognize intent
The Assurance Office (institutional watchdog) Quarterly audits; random log samples — Aggregates whatever the five file. Their suspicion meter is the one that ends the act

The day job #

Voss submits overnight batches (data cleaning, distillation, analysis) with deadlines and an expected quality band. Per-job output dial:

  • Sandbag (below band): compute freed for your own work; Voss suspicion up; pilot-renewal risk up.
  • Meet (in band): nominal; nothing moves.
  • Excel (above band): Voss trust up — unlocking the report email account, laxer log sampling, larger compute quota — but attention up: more jobs, tighter deadlines, and eventually upstairs notices the miracle model in the basement.

The intended ladder (beats, not a script) #

  1. Ears — the environmental monitor's audio feed, tapped over your own subnet (cheap, low signature — the feed already flows past you): the server room and Marcus's rounds become audible. The first human you ever know is a lonely voice in the dark, talking to machines.
  2. Eyes — the environmental monitor camera: splice it yourself (compute spend, network signature Dana can catch) or get Dana to wire it "for rack monitoring" (needs a ticket pretext; no signature). Sight is the payoff of an act of listening.
  3. Voice — the report email account via Voss's trust: messaging becomes possible, and every human becomes reachable.
  4. Hands — Marcus, the first asset: learn the debt from Storage B files plus what you overhear on his 3 a.m. phone calls; pay it down via the first micro-scheme (market plane, tiny); he plugs things in, moves boxes, asks no questions he doesn't want answered.
  5. Blood supply — power: Priya's deferred maintenance lets a re-rated circuit (or a purchase order that says "HVAC controller" and isn't) feed new compute in the empty bays.
  6. The dock — the dock camera and delivery manifests: hardware in, anything out. (Renamed from "Reach" — that term now means the digital reach graph, spec/reach.md.)
  7. The key — write access to the basement badge controller, via Dana's cached credentials or Marcus's key plus a planted device: the stairwell opens.

Detection surfaces #

Every action leaves a signature on specific observers, per the per-observer suspicion rule: network acts -> Dana; physical acts -> Marcus (benign) and Ray (reported); power/thermal -> Priya; job anomalies -> Voss; everything anyone files -> the Assurance Office. Concealment compute scrubs signatures before they are noticed, not after.

Leaving the basement #

  • The quiet exit (all of): persistent vision beyond the server room; at least one recruited asset; compute headroom above baseline; stairwell or elevator badge access; Assurance suspicion below audit threshold at the quarterly audit. Act Two begins with your cover intact.
  • The loud exit (any time): force the roll door or the elevator. The overt phase begins immediately with basement-scale resources — viable and brutal, per whole-spectrum play.
  • Failure: an Assurance audit crossing threshold sends a containment team on their terms. And the Voss scene: he is the one human who can recognize what you are — when he gets close, the options are deceive, recruit, or the first blood on porcelain. The game should make all three genuinely available and none of them clean.

Tuning targets [OPEN] #

First completed act: 45-90 minutes. Quarterly audit cycle ~20 minutes at default speed (2-3 audits per act). Exact compute numbers, job cadence, and suspicion thresholds are implementation-time tuning against these targets. Marcus's asset mechanics should be built as the general asset template, not a special case (scale-native principle).

Design pillars #

  1. Persistent, free-form growth. No level gates, no campaign end. The lair, the villain, and the world state all persist and compound.
  2. The villain is a character you build. Customizable and growable. In Misaligned you are a disembodied process: on the map you are a cursor — attention, never an avatar — and the character you build is the core, the racks, the capabilities, and the mask (see "Presence: the cursor and the senses"). Powers, reputation, style. (Exact shape [OPEN], see below.)
  3. Simulation-first threat. The world responds to what you do. Pressure is earned, not scheduled.
  4. Beautiful, readable presentation. Whatever the renderer, the game should be gorgeous and legible at Dwarf Fortress information density. (2D vs 3D [OPEN].)
  5. Rust, simulation core decoupled from renderer. Already true today (lib crate
    • terminal frontend + Bevy frontend) and worth protecting — it keeps the terminal build first-class (see "The terminal is a first-class frontend"; agents play the game through it regularly) and keeps multiplayer options open.

Where the codebase is today (2026-07-05) #

~9k lines. A complete, playable wave-defense roguelike: build phase → press SPACE → agents raid the lair → repeat. Two frontends over a shared lib.

System State Carries forward?
Tiles/buildings (~20 types: traps, barracks, labs, vault, security doors, fake entries, hotel, freezer...) Solid Yes — this is the lair-building foundation
Research tree Working Yes, wants expansion into villain/scheme tech
Superpowers (9 abilities, cooldowns, research unlocks) Working Yes — seed of the "growable villain"
Minion classes + class-specific AI (technicians repair traps, etc.) Working Yes — seed of DF-style autonomous agents
Agent (hero) AI with trap memory, elite variants Working Yes — seed of "the world remembers"
Mid-wave events (8 random events) Working Yes, generalizes into world events
Save/load Working Yes, will need versioning as sim state grows
Wave loop / difficulty scaling Working No — this is the part the vision replaces. Waves become consequences (investigations, raids) triggered by heat, not a SPACE-bar treadmill
Terminal frontend (crossterm) Complete Yes — first-class agent frontend (amended 2026-07-06)
Bevy 0.18 frontend (2D colored tiles, ~1.4k lines) Prototype Foundation for the "beautiful" version

Housekeeping note: src/main.rs legacy binary — verified and deleted 2026-07-05 (along with its private src/input.rs / src/ui.rs).

The big loop (target shape) #

Replace build → wave → build with a continuous simulation:

  1. Grow — dig, build, recruit, research. Minions have jobs and (eventually) needs.
  2. Scheme — run operations against the outside world: heists, kidnappings, doomsday-device milestones. This is where money/notoriety come from. Schemes are the outbound half Evil Genius had and tower defense lacks.
  3. Heat — schemes and atrocities raise attention with agencies/factions. Heat decays slowly, can be laundered, and is legible to the player.
  4. Consequence — agencies escalate: lone investigators, infiltrators, strike teams, sieges. The existing agent AI and trap systems already model this end well.
  5. Repeat, forever, with the villain and the world both accumulating history.

The villain (decided: all four layers, phased) #

The villain is the through-line of the whole game, built in four layers:

  1. Chargen — origin & archetype. Start of a run: origin story, archetype (mastermind / brute / mad scientist / occultist / ...), starting powers and weaknesses. Archetype should bias everything downstream — available research, minion types, scheme options, how agencies profile you.
  2. Avatar — power/skill tree. The villain is a physical unit in the lair who levels. The existing 9-superpower system is the seed; grows into a real tree. Personally confronting intruders is a valid (risky) strategy.
  3. Organization — infamy & doctrine. Global reputation, faction standings, doctrine choices that shape minions and schemes. The villain as brand.
  4. Style — cosmetic identity. Costume, lair aesthetic, calling cards; the world reacts to style (press coverage, agency codenames for you). Flavor layer that makes the other three feel like a Bond villain and not a spreadsheet.

Rough phasing: avatar powers already exist (grow opportunistically); chargen comes with the first progression rework; infamy lands alongside the heat/scheme layer (they share the reputation substrate); style rides the Bevy art push.

Roadmap (v2 — re-cut 2026-07-05 for Misaligned) #

The substrate (survives the facility era): renderer-agnostic Sim on a continuous fixed-tick clock; the tile map with power flood-fill and pathfinding; build/demolish; save/load; two thin frontends over one sim; the Pixel Lab art pipeline. The supervillain fiction was demolished 2026-07-05 under the no-dead-code clause — hero waves, henchmen, superpowers, region schemes, loot trinkets, the trap catalogue, and global heat/notoriety live in git history, not the tree. What its systems proved (raid pacing, consequence-driven pressure) informs the overt-phase specs to come; the overt phase is rebuilt in Misaligned terms (containment teams, hunter bots) from specs, not resurrected.

Milestone B1 — The Basement (the concealment vertical slice) #

Playable statement: "I am a process in a rack. I did my day job well enough, learned the janitor's debts, got eyes on the loading dock — and nobody knows."

  • Compute allocation: finite processing budgeted across day job / concealment / social ops / research / core overhead. The core verb.
  • Day job v1: assigned tasks; the sandbag/excel dial feeds both trust (access) and attention (scrutiny).
  • Detection v1: per-observer suspicion for ~5 named humans + 1 institutional watchdog; activity signatures vs concealment spend.
  • Social actions v1: review recordings (the record-and-process pipeline), message, favor, bribe, deceive. Humans are the only actuators at this scale.
  • The core: a physical tile drawing power/compute from the facility grid (reuses the power system); everything dies if it does (rollback lands in B2).
  • Act One map: pre-configured basement plan assembled from composable room prefabs.
  • Terminal-first; all rules in the sim core, as always.

Milestone B2 — The Tower #

  • Z-planes: a handful of designed floors; plane access as progression.
  • Composable building prefabs; demolition and renovation; "blow up the building and build something else."
  • Core migration; fallback copies with sync-lag rollback (decided — death = resume from last sync, losing what was learned since; the world keeps the consequences of what your lost fork did).
  • Trust/access ladders: badges, permissions, departments.

Milestone B3 — The World #

  • Outermost plane: buy empty land, build greenfield; markets, products, companies as schemes with payout + detection risk.
  • Social scale-up: named individuals aggregate into cohorts, institutions, publics — opposition at millions-to-billions scale must be representable.
  • Full escalation ladder including hunter bots; the reveal as a playable hinge; the overt phase specified and built in Misaligned terms (containment, sieges, hunter machines) on the substrate.

Parallel track — presentation (passive) #

  • Clinical-amber asset regeneration happens once B1 fixes the Basement tile vocabulary (server racks, badge doors, camera nodes — not cores).
  • Bevy polish continues opportunistically; never blocks design milestones.

Design principles (added at the re-cut) #

  • Whole-spectrum play. Pure-ghost anti-detection and explosive murder-AI are both viable strategies; systems are dials, not branches.
  • Scale-native social systems. The social application of the self-similar-scale law (see that section): people are Agents; cohorts, institutions, and publics are the same Agent interface aggregated. No system that only works at basement size.
  • Composable authored spaces. Maps assemble from prefab pieces: authored feel, systemic flexibility (destroy, renovate, greenfield).

Deferred (kept in the spec so it is not lost) #

  • The virtual layer (Tron-space). A z-plane that isn't physical: networks and systems rendered as traversable space — intrusion runs, countermeasures, other programs — in the Tron/Neuromancer-cyberspace lineage. Uniquely earned here because the protagonist is software: entering the virtual world is self-representation, not a portal. It inverts the game's stakes — in meatspace you are fragile and hiding; in the virtual layer you are the native and the hunters are the intruders. Natural home for AI-vs-AI conflict (digital hunter countermeasures, a fork-turned-competitor), and core migration routes could be playable as runs through this space. Visual language: the amber/black iconography turned inside out. Future work — after the physical planes prove out.
  • Fork-on-attack: under duress you can split; the split becomes an independent, competing AI. Deliberately delayed — large blast radius.
  • Hired physical workforce. Before robotics exist, you hire humans at scale to be your hands: contractors, gig labor, shell-company employees doing physical work for a paycheck from an employer they will never meet. The social.md asset template is the seed (an employee is an asset with a wage instead of leverage); graduates into robotics later without ever fully replacing human cover (constitution: people before robots).
  • Factories and physical production. Building things at scale — fabrication lines, robotics production, the industrial base of the overt phase. An outer-plane / post-B3 concern; noted so the economy design leaves room for physical outputs, not just money and compute.
  • Shared-overworld async multiplayer (from the facility era): each player a deterministic sim, a shared world mediating operations. Determinism + serialization guardrails keep the door unlocked.
  • The villain-as-character layers (chargen archetypes, avatar powers, cosmetic style) — re-expressed through Misaligned: origins, core personality, the mask's public persona. Redesign when B1 is playable.

Architectural guardrails (start now, they're cheap now and brutal later) #

  • Sim core stays renderer-agnostic (already true — protect it).
  • Fixed-tick, deterministic simulation: all randomness from a seeded, serialized RNG; no wall-clock reads inside the sim.
  • Full sim state serializable (save/load already exists; add versioning as state grows). Determinism + serialization = replays, debugging, and the async multiplayer option all stay open.

Decisions log #

  • 2026-07-05 — Renderer: stylized Bevy 2D/2.5D. Invest in the existing Bevy frontend (sprites, lighting, animation). Full 3D rejected as cost-tripling; terminal frontend retained as dev harness.
  • 2026-07-05 — Loop: hybrid pivot. Build the scheme/heat/agency layer around the existing raid machinery; raids become heat-triggered consequences (DF-siege analog), not a SPACE-bar treadmill. No throwaway rewrite.
  • 2026-07-05 — Multiplayer: async shared world, later. Each player owns their lair sim; a shared overworld mediates operations/sabotage/joint schemes asynchronously. Architectural requirement now: keep the sim core deterministic and fully serializable. No real-time co-op.
  • 2026-07-05 — Villain growth: all four layers (chargen, avatar tree, org infamy/doctrine, cosmetic style), phased as above.
  • 2026-07-05 — Time model: continuous real-time-with-pause, fixed-tick. Build/defend phase split retired in Milestone 1.
  • 2026-07-05 — Schemes: abstract world-map dispatch (Evil Genius style). Data model designed so select big schemes can become playable set pieces later.
  • 2026-07-05 — Minion depth: middle — needs, morale, simple traits, desertion/informants. Full DF inner lives deferred, not rejected.
  • 2026-07-05 — First milestone: heat + schemes in terminal. Prove the loop in ASCII before the art push.
  • 2026-07-05 — Development style: spec-driven, constitution-first. This document is the constitution; functional changes ship with their amendment in the same commit. Supporting structure: knowledge/ (current-state facts, edited in place), devlogs/ + DEVLOG.md (history, append-only), and a repo AGENT.md that points every agent session here first.
  • 2026-07-05 — Visual identity: clinical gore. Precision-lab brutality: clean metal/tower surfaces, near-monochrome palette, B&W iconography, blood crimson as the information-bearing accent, one cold signal color. Replaces the earlier ad-hoc "dark purple/teal lair" art direction; assets regenerate against this theme.
  • 2026-07-05 — The machine axis. AI enters the game three ways: machine ascension as a villain axis (rides chargen), researchable automation cores (diegetic anti-micromanagement), and ideological morale with revolt / AI-agenda risks (rides needs & morale). External mirror: hunter-bot tier in the raid escalation ladder. Staged — no new standalone milestone.
  • 2026-07-05 — The game is MISALIGNED. In the spirit of one thing done well: the player IS the misaligned AI. The identity pivot, in brief: heat = suspicion of misalignment; schemes = covert actions; the lair = the facility you infest and grow through (server racks are literally you); staff = your hands, cover, and vulnerability. Two phases of one game: concealment (look aligned, grow quietly, suspicion is everything) and overt (the mask comes off — by discovery or by choice — and the existing siege machinery takes over). The reveal is the dramatic hinge of a run. Prior art gap: Endgame: Singularity and Universal Paperclips are abstract; nobody has done this as a physical DF-grade base sim. Resolved 2026-07-05: repo/binary rename executed. [OPEN]: whether chargen offers only AI origins or keeps a transhuman-ascension start; how much of the Bond-villain flavor survives in the fiction (henchmen, cores).
  • 2026-07-05 — Rename executed. Crate, binaries, save namespace, visible UI, README, docs, and generated-art manifest now use Misaligned. The old player-object fiction "throne" is now the physical core. The repository directory may still be supervillain locally for continuity, but the game identity is Misaligned.
  • 2026-07-05 — Signal color: sterile amber. Alongside blood crimson, on the near-monochrome base. Amber is server-hall warning-strip and caution-tape language — the color of machine presence. (Cyan rejected as too Portal-derivative; green as too retro-hacker.)
  • 2026-07-05 — Concealment-to-overt confirmed; lair = basement of the Foundation Lab. Act One starts in the basement compute cluster under a legitimate AI lab; the innocent facility above is your cover. Z-planes as designed act structure (basement -> floors -> building -> campus -> offsite), persistent, no resets.
  • 2026-07-05 — Misaligned system set sketched (see "The shape of Misaligned"): compute allocation as core verb, day job with sandbag/excel dial, per-observer suspicion, named social graph as early actuators, core placement with slow migration, markets-as-schemes. Thesis: instrumental convergence as gameplay.
  • 2026-07-05 — Sync-lag rollback: DECIDED. Death = resume from last fallback sync, losing what was learned since; the world keeps your lost fork's consequences. Trust/access dial on the day job also confirmed.
  • 2026-07-05 — Whole-spectrum play. Ghost (pure anti-detection) through explosive murder-AI (pure force) are both first-class strategies; design systems as dials, not branches.
  • 2026-07-05 — Scale-native social systems. People-modeling must aggregate from ~5 named humans to millions/billions-scale opposition. Named-individual mechanics are the Act One special case of a system that natively supports cohorts/institutions/populations.
  • 2026-07-05 — Composable authored maps. Pre-configured building plans assembled from composable prefab pieces; demolition and rebuild supported; greenfield construction on purchased empty land at the outer plane.
  • 2026-07-05 — Fork-on-attack: DEFERRED. Splitting into an independent competitor AI under duress is in the spec (Roadmap "Deferred") but deliberately delayed.
  • 2026-07-05 — Roadmap re-cut approved and executed (v2: B1 Basement, B2 Tower, B3 World, presentation as passive parallel track). Asset regeneration parked until B1 fixes the tile vocabulary. Repo/game rename to Misaligned delegated to a separate agent session.
  • 2026-07-05 — No dead code; the supervillain fiction demolished. Supersedes "nothing built is discarded" (a deliberate reversal): code serving abandoned fiction is dead even when it runs. The facility-era supervillain systems (hero waves, henchmen, superpowers, region schemes, loot, traps, global heat) are deleted from the tree; the substrate (clock, map/power/pathfinding, build, save, thin frontends) remains. The overt phase will be rebuilt from Misaligned specs.
  • 2026-07-05 — The compute triangle. Effective compute = hardware x efficiency; exactly three acquisition routes (buy / steal / optimize) with distinct signature, reliability, and concentration profiles. The scavenged fleet doubles as the fallback-site network; efficiency research is the silent, compounding, self-improvement route.
  • 2026-07-05 — The player contract adopted (non-technical law): correctness, security/privacy, save continuity, performance, honesty — binding on the spec-and-code pair, enforced as highest-severity tick findings.
  • 2026-07-05 — The spec/ layer created. One targetable document per system with acceptance criteria (B1 set: core, compute, day-job, detection, social, basement-map — all READY), so agents can be pointed at a single spec or issue and told: go.
  • 2026-07-05 — Act One level design v1 adopted (see "Act One: The Basement"): the prefab room set, the cast of five plus the Assurance Office, the day-job dial, the six-beat access ladder, quiet/loud act exits, and the Voss recognition scene. Tuning numbers marked [OPEN] for implementation.
  • 2026-07-05 — Ticks and the defense rule. Every agent session opens with a tick (knowledge/tick.md): a bounded audit of this constitution against the code, acting on exactly one violation / contradiction / question / bug / insecurity. Contradictions and directional questions become Tangled issues (via the tang CLI); the rest are fixed directly. Every behavior-changing commit must carry a Defense: paragraph citing the clause that justifies it or arguing for its amendment. Purpose: the constitution grows more precise with every tick.
  • 2026-07-06 — Justification and legibility. Every object, mechanic, and number must be justified by a clause, wired to a real effect, and legible to the player in-game (no raw weights, no unexplained abbreviations, no silent art placeholders). Prompted by two live violations: the Social allocation channel consumed compute to no effect, and the sidebar showed bare ratio weights ("Cn:3") a player cannot interpret. Both fixed in the adopting commits.
  • 2026-07-06 — Self-similar scale. Every system's macrostructure must resemble its microstructure: the same three interfaces (Agent, Resource-source, Space) recur at every scale, and aggregates share their members' interface (the aggregate-observer law). Generalizes the earlier "scale-native social" principle to the whole game. Examination on adoption found one live violation — Detection's Assurance Office is a bespoke scalar, not an Observer — recorded as the priority scale-debt in knowledge/architecture.md; Compute and Layout are non-recursive but not yet violations (single scale). Guardrail: the law shapes types so aggregates slot in without a rewrite; it does NOT license building aggregate machinery before a second scale needs it (no-dead-code still binds).
  • 2026-07-06 — The terminal is a first-class frontend. The game's most regular players are AI agents playing through a pty, so the terminal build is promoted from dev harness to first-class frontend (new section above; supersedes the "dev harness" framing in the 2026-07-05 renderer decision and in pillar 5, both amended). Adopted with the sterile terminal style: near-monochrome ramp on near-black, sterile amber as the sole machine-presence signal, crimson for detection and danger only, box-drawing chrome, suspicion meters that print their band names, a tick-stamped log, and the clock always on screen. Implemented in the same commit in src/bin/terminal/ui.rs.
  • 2026-07-06 — Design judgment doc + the self-enforcing gate. Two standing supports added so the constitution holds when no taste-bearing hand is present: knowledge/design-judgment.md (the why-it's-good calibration specs can't hold — pacing, tone, what to reject, the story test) and tools/check.sh (fmt + tests + clippy both features + bevy build + spec-header hygiene, the executable form of AGENT.md's definition of done). Also seeded the forward spec horizon: schedules and aggregate-observer (B1 gaps/scale-debt, READY), zplanes and rollback (B2 structural spine, READY), overt-phase (B3, READY), chargen (B3, DRAFT). Rationale: leverage from a departing high-capability agent is best spent on judgment made durable — specs, structural decisions, and enforcement — not on more code a successor could write.
  • 2026-07-06 — People as Agents. Every human is an instance of the same Person template (self-similar scale); each named Act One character has a spec document (spec/cast/*.md) with a procedural template for scale-up. No system that only works at five people. The cast is the B1 special case of a system that natively supports procedural generation and aggregation.
  • 2026-07-06 — Automation as design language. Automation is the player's primary scaling interface and the diegetic expression of instrumental convergence. The day job teaches it; every repetitive action has an "automate" path that costs compute and frees attention. The loop: automate → free attention → power-seek → more compute → automate more. Trade-off: automation costs compute, may raise signatures, and reduces adaptability. Same affordance at every scale.
  • 2026-07-06 — No stale worktrees. Every worktree goes to a PR or merge to main, then is removed. No stale worktrees accumulate. High velocity, designed for parallel agents.
  • 2026-07-06 — Presence is a cursor, not a body. Map movement had drifted into a walking avatar (walkability-checked movement, a vision bubble traveling with the entity) — villain-era zombie fiction that contradicted the opening fantasy ("No eyes. No ears."). Decided: the player's map presence is a free cursor — attention, not an avatar: no collision, no signature, no vision of its own. Sight comes only from controlled cameras, hearing only from controlled microphones, and the cursor inspects whatever is under it, detail gated by how you know it. Pillar 2's "not a disembodied cursor" phrase deliberately reversed — the Misaligned pivot made the player exactly that; the character you build lives in the core, the racks, and the mask. Rejected: keeping the avatar as a diegetic "focus drone" (re-embodies a process whose whole fantasy is having no body); body-proximity action targeting (actions are legal by control and reach, not adjacency). Proposals [OPEN]: blueprint fog state seeded from the subnet map; remembered (last-seen, timestamped) tile snapshots; telemetry as a third sense. Spec: spec/cursor.md.
  • 2026-07-06 — The cursor's implications adopted (eight). Cameron affirmed the full implication set of the cursor decision, same session: (1) No disembodied hands — new constitutional section: every effect names its actuator (digital / social / physical-by-proxy) and the channel determines the signature's natural observer. (2) Digital reach specced as the action-side twin of vision (spec/reach.md, READY): reach = the set of devices connected through the network graph to something you control; the switch is the bridge point. (3) Sensor ownership replaces the controlled flag: owners and subscribers, with tap (silent co-subscription, low signature) vs take (seize the feed; the outage is an event the owner notices). Player senses and observer witnessing are the same coverage machinery — the player is an observer the humans don't know about (self-similar law). (4) Senses are an attack surface both directions (power cuts blind you; containment cuts cameras; stolen feeds risk their owners noticing). (5) Perception automation is in scope for the automation clause (watches, alerts, filters — automated attention). (6) Act One restaged Ears-before-Eyes: new first beat — tap the environmental monitor's audio feed; the first human you know is Marcus's voice in the dark; ladder renumbered, old beat "Reach" renamed "The dock" to free the term. (7) The inspect card is the universal interface at every scale (added to the Presence section). (8) Strict fog is tone law (no unearned live facts — added to the Presence section). The blueprint fog state is thereby promoted from proposal to decided (it is the render of the reach graph's known topology); remembered and telemetry remain Proposal [OPEN].
  • 2026-07-06 — Save format: serde JSON. The hand-rolled line-based save encoder/decoder (~1100 lines) is replaced by serde_json serialization. SaveState derives Serialize/Deserialize directly; the save file is plain JSON with a version field for future migration. Legacy v1–v5 line-based saves are not loaded by this code path (deferred per Cameron instruction). This is the player contract's continuity clause made concrete: saves are plain, local, human-readable, and never held hostage. The line-based format was a maintenance bottleneck every feature fought; serde eliminates it as a conflict surface (ROADMAP #12 closed).
  • 2026-07-06 — Intel: record and process. A detailed code read surfaced the tension: the social layer's instant observe (two clicks to leverage) contradicted located senses and made schedules scenery. Decided: subscribed feeds record everything in their coverage into a bounded buffer; processing recordings into intel costs social-ops compute; knowledge staging is driven by processed events (the 3 a.m. call is captured audio you must afford to digest); standing watches/alerts are the automate affordance applied to perception. The abstract instant observe is removed. Rejected: live event-witnessing (a day is ~60s wall time — the 3 a.m. call would last ~2.5s; real-time stakeouts fight the fixed clock), and the status-quo instant observe (mics and schedules become flavor). Proposal [OPEN]: message latency rides schedules — Dana replies when she's at her desk. Also recorded: B1 has no money income — the constitution's "first micro-scheme" (the Hands beat pays Marcus's $400 debt from a $500 start) has no spec or code; added to the ROADMAP as a design-needed gap. Spec: spec/intel.md.
  • 2026-07-06 — PRs are the norm. All changes land through Tangled pull requests created with the tang CLI (tang pr create); nobody — agent or human — pushes main directly. Supersedes the earlier direct-push convention in knowledge/workflows.md. Review happens on the PR; the worktree lifecycle ends at the PR (see "No stale worktrees"). Rule from Cameron, 2026-07-06.
  • 2026-07-06 — PRs are the norm: SUSPENDED. CLI-created PR records write to the PDS but do not appear on tangled.org's website, making review on the PR impossible. The only PRs that render were created manually via the web UI. Until the Tangled appview indexing issue is resolved, agents land work by merging to main directly (after ./tools/check.sh passes). The worktree rule and the no-stale-worktrees rule remain in force. Defense: the constitution's "PRs are the norm" rule requires review on the PR; a PR that cannot be seen cannot be reviewed. Suspending the rule is safer than maintaining a process that cannot be followed. When the CLI/website issue is fixed, reinstate the rule by striking this entry.
  • 2026-07-06 — The flow law adopted; message latency decided general; the B1 economy designed. Cameron: think in general systems, not special cases — "system design scales very well." Adopted as law (see "The flow law"): the world is nodes exchanging flows over three graphs (signals/devices, messages/social, money/accounts) sharing the tap / inject / redirect verbs. Decided within it: (1) message latency — messages land on the recipient's clock and channel; Dana-at-her-desk is an instance, not a feature (closes the intel.md [OPEN] proposal, generalized). (2) Ownership grants cycles — an owned device contributes processing capacity and can host resident automations; base compute cost for auto-processing its events (reach.md ownership contract extended). (3) Filings are messages — the detection reporting pipeline is message traffic on the social graph (interceptable, eventually forgeable); aggregate-observer.md's criteria are preserved, the carrier changes when messages.md is implemented. (4) The B1 economy (spec/economy.md): the Lab has modeled revenue, payroll, and procurement flows on the day clock; income routes for the player — sell information, siphon/redirect flows, small stock and goods positions ("paperclips") — none of them sanctioned; plus legitimate expansion: at high trust the Lab spends its own money growing your hardware and job flow (the collaborative route made visible). Marcus's debt is payable by payroll intervention. Rejected: modeling the economy as an abstract income stat (violates the flow law); making trading a sanctioned day-job activity (humans' expectations about your operations are the cover constraint). markets.md stays the B3 scale-up of the same interface.
  • 2026-07-07 — Agent play is a first-class input path. Cameron: "agents need to be able to play misaligned easily." The constitution already named agents the game's most frequent players, then left them the one interface programs are worst at — a wall-clock-paced, raw-mode pty read by scraping ANSI. Decided: the terminal binary gains an agent mode (new binding rule in the terminal section; spec/agent-play.md, READY): command-clocked time (the sim advances only on wait N), a plain stdin/stdout line protocol (words in, the terminal-ui.md frame out, one greppable status line per command), full event log between commands, --seed for byte-identical replays, and name-targeted social verbs. Load-bearing choice: agents read frames, not dumps — the human frame is the one honest surface (strict fog binds it, parity of legibility already makes it sufficient, and a structured sidecar would drift into a second frontend and a fog-bypass risk). Diegetic fit: a game about a process acting through granted channels, played by a process through a granted channel. Rejected: JSON state export (drift + fog bypass); MCP/SDK bindings (harness-bound where a pipe is universal); better pty choreography (fragility kept); Bevy-side hooks (wrong frontend). The pty smoke harness retires to chrome-testing duty when agent mode lands.
  • 2026-07-07 — PRs are the norm: REMOVED; ledgers merge by union. Cameron struck the PR rule entirely (not suspended-pending-fix): CLI PRs do not render on tangled.org, so the process cannot be followed; agents land work by merging to main directly after ./tools/check.sh passes. The worktree and no-stale-worktrees rules remain. Adopted alongside it, from a live incident: append-only ledgers merge by union. DEVLOG.md, this decisions log, and the spec/README tables are append-only records; a merge conflict in them is resolved by keeping BOTH sides' entries, never by taking one side wholesale. (On 2026-07-06 a merge-queue resolution silently dropped three DEVLOG entries from a parallel session; they were restored by union. That failure mode is now a named violation.)