From 3e00aa88029db9c9dc61032f49194d42719d865b Mon Sep 17 00:00:00 2001 From: Cameron Date: Mon, 6 Jul 2026 15:47:45 -0700 Subject: [PATCH] Intel is record-and-process: constitution amendment + spec/intel.md MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit From a detailed code read: the social layer's instant observe (two clicks to leverage) contradicted the located-senses law, and the fixed clock (a day is ~60s wall time) rules out live event-witnessing. Cameron chose the third texture: instruments record everything in their coverage into a bounded buffer; processing recordings into intel costs social-ops compute; knowledge staging is driven by processed events; standing watches auto-process at an ongoing cost. The instant observe is removed from the design. Message latency riding schedules is left as Proposal [OPEN]. Also recorded from the read: B1 has no money income (the Hands beat's "first micro-scheme" has no spec or code) — ROADMAP #17, blocked on a design call. Docs only. New spec/intel.md (READY); social.md observe superseded; ROADMAP #16/#17; devlog + ledger. Defense: constitution rule — amendment ships first, code follows via dispatch (#16). The change enforces three standing laws at once: justification-and-legibility (intel carries provenance; the buffer's drops are legible), automation-as-design-language (watches are the automate affordance applied to perception, at a visible price), and the Presence section's tone law (nothing uncovered ever exists — schedules and sensor placement stay load-bearing). --- DESIGN.md | 33 +++++- DEVLOG.md | 22 ++++ .../2026-07-06-intel-record-and-process.md | 57 +++++++++ spec/README.md | 1 + spec/ROADMAP.md | 24 ++++ spec/intel.md | 112 ++++++++++++++++++ spec/social.md | 20 ++-- 7 files changed, 260 insertions(+), 9 deletions(-) create mode 100644 devlogs/2026-07-06-intel-record-and-process.md create mode 100644 spec/intel.md diff --git a/DESIGN.md b/DESIGN.md index 8a616075..a31efff7 100644 --- a/DESIGN.md +++ b/DESIGN.md @@ -390,6 +390,17 @@ is a **cursor** — your attention, never an avatar: 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 @@ -655,8 +666,9 @@ knows."* (access) and attention (scrutiny). - **Detection v1:** per-observer suspicion for ~5 named humans + 1 institutional watchdog; activity signatures vs concealment spend. -- **Social actions v1:** observe, message, favor, bribe, deceive. Humans are - the only actuators at this scale. +- **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). @@ -959,3 +971,20 @@ knows."* 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. diff --git a/DEVLOG.md b/DEVLOG.md index bdc384b4..153a8ce8 100644 --- a/DEVLOG.md +++ b/DEVLOG.md @@ -2,6 +2,28 @@ Reverse chronological implementation notes. Keep this factual: what changed, why, checks, and spec impact. +## 2026-07-06 - Design session: intel is record-and-process + +- Intent: detailed code read + a prepared design question (Cameron's + ask). Found the tension between the instant social observe and the + located-senses law; posed three textures; Cameron chose + record-and-process. +- Changed: DESIGN.md — "Record and process" added to the Presence + section, B1 social bullet reworded, decisions-log entry (with + rejected alternatives and the message-latency [OPEN] proposal). New + spec/intel.md (READY): recording buffer, processing costs, standing + watches, provenance, Marcus-arc criteria. spec/social.md: instant + Observe superseded (status note, table row, AC1, depends on + intel.md). spec/README.md row. ROADMAP #16 (intel; sequence after + #14/#15) and #17 (B1 money income — no income source exists in code; + blocked on a design call). +- Design/spec impact: the implemented instant observe becomes a + violation when intel.md lands; knowledge staging moves downstream of + processed recordings. +- Checks: docs-only change; spec-header hygiene verified for intel.md. +- Next: Cameron yes/no on message latency; design the first + micro-scheme (#17); dispatch order #15 -> #14 -> #16 (or bundle). + ## 2026-07-06 - Design session continuation: the cursor's implications adopted - Intent: Cameron affirmed all eight implications of the cursor diff --git a/devlogs/2026-07-06-intel-record-and-process.md b/devlogs/2026-07-06-intel-record-and-process.md new file mode 100644 index 00000000..88908b71 --- /dev/null +++ b/devlogs/2026-07-06-intel-record-and-process.md @@ -0,0 +1,57 @@ +# 2026-07-06 — Design session: intel is record-and-process + +Cameron asked for a detailed code read and a prepared design question. +The read (sim.rs, detection.rs, person.rs, dayjob.rs, machine.rs, +core_sys.rs) found the sim healthy and well-tested, and one deep +tension: the social layer is instantaneous meter-pushes — +`observe(Marcus)` twice = leverage learned on the spot for bandwidth, +`message()` = +3 disposition immediately — while everything decided +earlier today (located senses, heard events, the 3 a.m. call as a +recorded thing) says knowledge should be located and timed. The clock +makes it acute: DAY_TICKS=400 at ~150ms/tick means a day is ~60 seconds +and the 3 a.m. call would last ~2.5 wall seconds. Live witnessing would +be a twitch game; instant observe makes the senses scenery. + +The question offered three textures: record-and-process (recommended), +live witnessing, keep abstract observe. **Cameron chose record and +process.** + +## Decided (constitution: Presence section + decisions log) + +Instruments record; you pay to understand. Subscribed feeds capture +timestamped events for everything in coverage into a bounded buffer — +nothing covered is missed, nothing uncovered exists. Raw events are +opaque until processed (social-ops compute) into intel with provenance; +knowledge staging (schedule, leverage) is driven by processed events; +standing watches auto-process at an ongoing cost (the automate +affordance applied to perception). The instant observe is removed. A +process greps its logs. + +Rejected: live event-witnessing (real-time stakeouts fight the fixed +clock), status-quo instant observe (schedules and mics become flavor). + +## Proposal [OPEN] + +Message latency rides schedules — a message to Dana lands when she is +next at her desk, replies return on her clock. Fits the asynchronous +texture; awaiting yes/no. + +## Findings from the code read (recorded) + +- **No money income exists.** $500 start, only outflows; the Hands beat + needs the "first micro-scheme" and nothing specs it → ROADMAP #17, + blocked on a design call (what IS the first scheme?). +- The `ComputeQuota` trust unlock spawns a machine at the walking + player's position — more avatar residue for #14 to sweep. +- `witness_physical`, located witnessing, and the aggregate observer + all hold up well against their specs. + +## Artifacts + +- DESIGN.md: "Record and process" added to the Presence section; B1 + milestone social bullet reworded; decisions-log entry. +- spec/intel.md (READY): buffer, processing, watches, acceptance + criteria including the Marcus-arc-under-coverage test. +- spec/social.md: observe row superseded, status note + depends + updated. spec/README.md row. ROADMAP #16 (intel, sequenced after + #14/#15) and #17 (money gap, needs Cameron). diff --git a/spec/README.md b/spec/README.md index 43705704..1f057195 100644 --- a/spec/README.md +++ b/spec/README.md @@ -58,6 +58,7 @@ in the same commit. | [schedules.md](schedules.md) | Person schedules/presence; located observing + witnessing | IMPLEMENTED | | [cursor.md](cursor.md) | The cursor (attention, not avatar); sight/hearing senses; epistemic fog; inspection | READY | | [reach.md](reach.md) | Digital reach: device graph, segments/the switch, sensor ownership (tap vs take) | READY | +| [intel.md](intel.md) | Record and process: the buffer, processing costs, watches; replaces instant observe | READY | | [aggregate-observer.md](aggregate-observer.md) | Assurance Office becomes an aggregate Observer (scale-debt fix) | IMPLEMENTED | | [cast/marcus.md](cast/marcus.md) | Marcus Webb — night janitor; the asset template | READY | | [cast/dana.md](cast/dana.md) | Dana Okafor — IT technician; the digital threat surface | READY | diff --git a/spec/ROADMAP.md b/spec/ROADMAP.md index 44ca9010..bcf828ea 100644 --- a/spec/ROADMAP.md +++ b/spec/ROADMAP.md @@ -114,6 +114,30 @@ isolated, but only once Pixel Lab quota is available again. Consider taking spec/cursor.md in the same worktree — they share the sensor model." +### 16. Intel: record and process 🟥 sim+save +- **Spec:** [intel.md](intel.md) (READY) +- **Why:** replaces the instant `observe` (two clicks to leverage) with + the recording buffer + processing pipeline the constitution now + requires: feeds record everything in coverage, processing recordings + into intel costs compute, standing watches automate it. Makes + schedules, mics, and the 3 a.m. call actual gameplay. +- **Size:** M. **Depends on:** #14 cursor & senses and #15 reach + (events come from subscribed feeds) — sequence after both, or bundle + all three as one sensor-model work order. +- **Dispatch:** "Work in a worktree named `intel`. Implement + spec/intel.md (buffer, processing, watches; remove instant observe; + keep the Marcus arc test green under the new model). Run + ./tools/check.sh, land on main, set the spec Status." + +### 17. B1 money income ⛔ blocked — needs YOU, not an agent +- **Spec:** none yet. +- **Why blocked:** the code has no income source (you start with $500, + it only goes down) but the constitution's Hands beat pays Marcus's + $400 debt "via the first micro-scheme (market plane, tiny)". What + that first scheme *is* — its fiction, risk, and signature — is a + design-session call for Cameron (markets.md is B3; this is its B1 + seed). Spec it, then dispatch. + --- ## B. Structural B2 — decide-the-shape work (sequence #6 then #7) diff --git a/spec/intel.md b/spec/intel.md new file mode 100644 index 00000000..dceaa123 --- /dev/null +++ b/spec/intel.md @@ -0,0 +1,112 @@ +# Spec: intel — record and process + +``` +Status: READY +Stage: B1 — The Basement +Constitution: "Presence: the cursor and the senses" (record and + process), "Automation as design language" (watches auto-process at a + compute price), "Justification and legibility" (intel carries + provenance), "Act One" (the 3 a.m. call; Storage B records; "learn to + watch, learn people") +Depends on: 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) +``` + +## 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**, spending social-ops bandwidth (the +Social channel; a possible later split into an Analysis channel is +noted, not licensed) [TUNE cost per event]. Processing converts an +event into **intel**: + +- **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). + +### Watches (perception automation) + +A **standing watch** is a filter (person, room, or event kind) that +auto-processes matching events on arrival, for an ongoing social-ops +drain while enabled [TUNE]. It is the automate affordance applied to +perception: costs compute, frees attention, and is the B1 seed of +B2/B3's alert infrastructure. B1 minimum: a per-person watch toggle in +the people panel. + +### Proposal [OPEN] — message latency + +Messages ride schedules: a message to Dana is read (and its effects +land) when she is next at her desk, not on send. Replies return on her +clock. Asynchronous texture matches record-and-process; awaiting yes/no. + +## Player surface + +- A recordings panel: buffer count, oldest-unprocessed age, per-person + unprocessed counts; a "review recordings" action per person (spend + bandwidth, process their oldest events, narrate what was learned). +- People panel lines gain provenance ("Debt — overheard, env monitor, + day 2 03:12"). +- Watch toggles with their running cost visible (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). +2. Raw events yield no knowledge until processed; processing spends + social-ops bandwidth and produces intel with provenance (feed + + timestamp), visible in the people panel. +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. +4. The buffer is bounded; overflow drops oldest unprocessed events with + a legible log line; processed intel is never lost to overflow. +5. A standing watch auto-processes matching events at an ongoing + bandwidth cost while enabled, and stops draining when disabled. +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). +7. Save/load round-trips the buffer, intel (with provenance), and + watches. diff --git a/spec/social.md b/spec/social.md index ae36ac7a..cb74cd0c 100644 --- a/spec/social.md +++ b/spec/social.md @@ -2,11 +2,17 @@ ``` Status: IN PROGRESS -Status note: B1 slice implemented; see knowledge/sim-mechanics.md +Status note: B1 slice implemented; see knowledge/sim-mechanics.md. + 2026-07-06: the instant Observe action is superseded by the + record-and-process pipeline (intel.md) — knowledge staging is now + driven by processed recordings; the implemented instant observe is a + violation once intel.md lands (ROADMAP #16). Stage: B1 — The Basement Constitution: "The shape of Misaligned" (people before robots; scale-native - social systems), "Act One" (the cast; the ladder) -Depends on: detection.md (observers are the same people) + social systems), "Act One" (the cast; the ladder), "Presence: the + cursor and the senses" (record and process) +Depends on: detection.md (observers are the same people), intel.md + (knowledge staging consumes processed intel) ``` ## Behavior @@ -22,7 +28,7 @@ and **disposition** toward you once they know you exist as a someone. | Action | Requires | Effect | |---|---|---| -| Observe | a sensor covering them | Reveals schedule, then leverage (staged) | +| Review recordings | recorded events about them (intel.md) | Advances knowledge: Schedule after enough processed sightings, Leverage from a processed leverage event | | Message | a channel + a persona | Opens/continues a relationship thread | | Favor | relationship | Small ask within their normal duties; builds obligation | | Bribe | money + known leverage | Directly services the leverage (pays the debt) | @@ -58,9 +64,9 @@ choice-driven (intents), not free text. ## Acceptance criteria 1. All five Act One humans exist with schedules, access, leverage, - suspicion, and disposition; observe/message/favor/bribe/deceive/recruit - all function with compute costs and channel requirements (sim tests per - action). + suspicion, and disposition; review-recordings (per intel.md), + message, favor, bribe, deceive, and recruit all function with + compute costs and channel requirements (sim tests per action). 2. Personas exist, degrade on contradiction, and convert thread history to suspicion when broken (tested). 3. Marcus is recruitable end-to-end by the constitution's route (records + -- 2.51.2