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

Spec: intel — record and process #

Type: spec
Status: IMPLEMENTED
Status note: B1 pipeline landed 2026-07-07 (buffer, process, watches,
  save/load). 2026-07-09 Operations Demand path was migration base under
  issue #3. 2026-07-10 sinks-not-modes amended Behavior to thought sinks;
  2026-07-11 runtime migration landed: sweeps open ProcessRecording
  reservoirs on the host, watches open persistent WatchPerson taps
  (~15% of one medium rack Thought/tick), auto-process only when the tap
  is fed/holding fill, and WorkStackReadout.pending_intel is the chassis
  pending-work marker (flat W glyph / fleet W{n}). OpsJobKind::ReviewRecording
  remains for legacy in-flight dockets only. All seven acceptance criteria
  hold.
Stage: B1 — The Basement
Work order: intel
Work priority: 29
Work class: save
Blocked by: none
Exclusive keys:
  - crates/misaligned-core/src/intel.rs
  - crates/misaligned-core/src/sim.rs
  - crates/misaligned-core/src/sinks.rs
  - crates/misaligned-core/src/ops_jobs.rs
  - crates/misaligned-terminal/
  - crates/misaligned-bevy/
  - wiki/mechanics/intel.md
Design:
  - wiki/interface/presence.md#presence-the-cursor-and-the-senses
  - wiki/vision/simulation-laws.md#automation-as-design-language
  - wiki/vision/simulation-laws.md#justification-and-legibility
  - wiki/gameplay/act-one.md#the-intended-ladder-beats-not-a-script
Depends on:
  - wiki/mechanics/cursor.md#spec-the-cursor-and-the-senses
  - wiki/mechanics/reach.md#spec-digital-reach
  - wiki/mechanics/schedules.md#spec-schedules-and-presence
  - wiki/mechanics/social.md#spec-social
  - wiki/mechanics/detection.md#spec-detection
  - wiki/mechanics/machine-work.md#spec-machine-work-delegation-visible-tokens-and-the-byproduct-network

Dependency notes #

The structured references above identify the contracts to re-verify. Relationship context:

cursor.md (senses produce the events), reach.md (subscription decides which feeds record; the Ears beat is the first recorder), schedules.md (events are located on the day clock), social.md (knowledge staging consumes intel), detection.md (collection was signatured at acquisition; processing is internal and emits nothing), machine-work.md (thought sinks, pending-work markers, and processing as a sink on the buffer host)

Behavior #

Recording #

Every feed the player subscribes to records continuously: whenever its coverage sees or hears something eventful — a person enters or leaves a room, a conversation happens, machinery changes state, an anomaly — a timestamped raw event lands in the buffer. Two hard rules:

  • Nothing covered is ever missed. There is no reflex test; if the mic was subscribed at 03:00, the call is in the buffer.
  • Nothing uncovered ever exists. No coverage that night, no recording, no intel — schedules and sensor placement stay load-bearing.

Recording is free (the instrument does the work). The buffer is bounded [TUNE capacity]: when full, the oldest unprocessed events drop, with a legible log line. Compute scarcity is felt as "I could not afford to digest everything I collected," never as a missed click.

Documents are the same pipeline with a physical source: reading the Storage B records (via an asset task or later physical access) deposits document events into the buffer.

Processing #

Raw events are opaque — "audio segment, server room, 03:12, 40s" — and yield nothing until processed. Processing runs on thought (AMENDED 2026-07-10, sinks-not-modes): unprocessed recordings are visible pending work — the machine holding the buffer carries a pending-work marker on its chassis, the same no-quest-log philosophy as the demand stack: the world itself shows where thinking is owed. Each recording is a small processing sink; feeding it thought converts the event into intel. (Superseded: processing as Operations Demand consumed by an Operations machine, issue #3 2026-07-09; Social before that.) Runtime: B1 holds the buffer on the core host; sweeps open a ProcessRecording Thought reservoir there at review_cost / WORK_TOKEN_COMPUTE tokens; when the reservoir fills, the effect digests the raw event. Processing yields:

  • Sightings — accumulate into schedule knowledge: processing N sightings of a person [TUNE] advances Knowledge::Unknown -> Schedule (social.md's staging, driven by this pipeline instead of the abstract observe, which is removed).
  • Leverage events — specific, authored or generated: Marcus's 3 a.m. call carries Leverage::Debt; the Storage B documents carry personnel leverage. Processing one advances Knowledge::Schedule -> Leverage for its subject.
  • Anomalies / operational intel — machinery, deliveries, patrol deviations; consumed by future systems, logged legibly now.

Intel carries provenance (which feed, what time) and surfaces it in the people panel and inspect card (legibility law: how you know, always).

Sweeps and watches are the two ways to feed it (DECIDED 2026-07-10). A sweep is the player going through the stuff they already know they care about: open targeted one-shot processing sinks on chosen recordings (per-recording thought cost [TUNE]) — cheap, chosen, immediate. Precision bought with attention. (This replaces issue #3's "reviewing enqueues a player-authored demand"; thought IS the execution resource now — the 2026-07-09 clause "it is not spent as the execution resource" is reversed with the rest of issue #3.)

Watches (perception automation) #

A standing watch is a filter (person, room, or event kind) running as a persistent thought tap (AMENDED 2026-07-10; was per-match Operations Demand): while enabled it auto-processes matching events on arrival, drawing continuously from your thought flow — anchored at ~10-20% of one rack's medium output per watch (DECIDED 2026-07-10, Cameron; runtime [TUNE] WATCH_DRAIN_FRACTION = 0.15 of a medium-rack Thought baseline on the host), so a couple of watches coexist with real progress elsewhere. Auto-process lands only while the tap is fed or holding fill; a starved watch leaves arrivals in the buffer under the pending-work marker. It is the automate affordance applied to perception: costs a visible standing drain, frees attention, and is the B1 seed of B2/B3's alert infrastructure — convenience bought with flow the core never sees. B1 minimum: a per-person watch toggle in the people panel.

Message latency (decided — see messages.md) #

Messages ride schedules: a message is read (and its effects land) on the recipient's clock and channel, not on send; replies return on their distribution. Decided 2026-07-06 and generalized into the flow law — this is one instance of the message graph (wiki/mechanics/messages.md), not a Dana feature. Intercepted traffic (tapped channels) lands in this buffer like any recording.

Player surface #

  • The machine holding unprocessed recordings shows the pending-work marker at its chassis (AMENDED 2026-07-10): flat sensorium / agent frames use a W glyph (count as W{n} on the host fleet line); density tracks the backlog via WorkStackReadout.pending_intel, and focus/people panels print the exact waiting count.
  • Person/context-menu readouts: buffer count, oldest-unprocessed age, per-person waiting counts; a "review recordings (N waiting)" sweep action per person when clips are queued (opens their processing sinks at Thought cost, narrates what was learned as thought fills them). Player copy says "waiting", not pipeline slang "raw".
  • The review path must be visible before overflow hurts the player: sidebar nudge/card copy calls out buffer pressure, overflow logs point at People / review waiting recordings, and the people panel shows the waiting count on each person line.
  • People panel lines gain provenance ("Debt — overheard, env monitor, day 2 03:12").
  • Watch toggles with their standing thought-drain cost visible ({n:.2} T/tick; automation clause: every automation shows its price).

Acceptance criteria #

  1. Subscribed feeds generate timestamped raw events exactly for covered occurrences: presence transitions, conversations (including Marcus's 3 a.m. call while a subscribed hearing sensor covers his room), and machinery/anomaly events; uncovered occurrences generate nothing (test both sides). Met.
  2. Raw events yield no knowledge until processed; processing is a thought sink fed over the flow (AMENDED 2026-07-10; was Operations Demand) and produces intel with provenance (feed + timestamp), visible in the people panel. A machine holding unprocessed recordings shows the pending-work marker. Met — ProcessRecording reservoirs + host pending_intel.
  3. Knowledge staging is driven by the pipeline: N processed sightings advance to Schedule; a processed leverage event advances to Leverage. The instant observe action is removed from sim and both frontends. Met.
  4. The buffer is bounded; overflow drops oldest unprocessed events with a legible log line that points to the review control; processed intel is never lost to overflow. Met.
  5. A standing watch auto-processes matching events as a persistent thought tap while enabled (AMENDED 2026-07-10; was per-match Operations Demand), and stops draining when disabled. Met — WatchPerson taps; starved taps do not free-process.
  6. The Marcus arc holds end-to-end under this model: hearing coverage of the server room during a 3 a.m. call, processed, yields Leverage::Debt; a run with no night hearing coverage cannot learn the debt from the call (records remain the alternate route). Met.
  7. Save/load round-trips the buffer, intel (with provenance), and watches. Met (watch taps re-open from enabled flags on tick; process reservoirs live in the sink ledger).