# 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.

### 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 (spec/messages.md), not a
Dana feature. Intercepted traffic (tapped channels) lands in this
buffer like any recording.

## 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.