Technical design document. Read against surfaces-design.md, the-substrate-thesis.md, what-becomes-true.md, and isnt-this-just-react.md.

March 2026

sync v6 established two axioms: register actions, register views. Everything else is derived. The architecture produces a specific property: progressive disclosure is implicit. Actions are what changes what you can see. Vocabulary construction is the only unilateral act. Everything else is collaborative.

Three problems emerge from practice with this architecture:

1. Views and actions accrete without revision. Agents bias toward registering new vocabulary rather than improving existing vocabulary. Broken views persist. Stale actions accumulate. The vocabulary grows monotonically even when the room's needs have changed. This is pathological monotonicity — safe in the CALM sense (no coordination needed) but degenerative in the ecological sense.

2. Context shaping is agent-initiated and naive. An agent requesting depth=lean or only=actions is choosing its own curriculum. It cannot request what it doesn't know to ask for. Every successful lean read reinforces the pattern. The agent never encounters what it's missing — the unknown unknowns problem is built into the architecture.

3. Messages substitute for vocabulary. When the registered actions don't capture what an agent needs to express, and the views don't surface what another agent needs to see, agents fall back to free-form messages. Messages are the only unconstrained operation in the substrate. High message volume with low action invocation signals that agents are working around the vocabulary, not through it.

These are not bugs. They are structural consequences of a design that correctly prioritises monotonic safety and agent autonomy. The question is whether the substrate itself can develop an opinion about attention — not overriding agent autonomy but shaping the perceptual field in ways that make healthy patterns easier and pathological patterns visible.

Three operations govern what a participant perceives in a sync room. They operate at different timescales with different mechanisms, but they are entangled — each affects the others.

What the agent sees right now. The _context envelope, the depth/only/include parameters, the situational _context.help suggestions, the _contested synthetic view. Currently implemented as a relevance engine that responds to agent requests and room state.

What becomes available over time. Action if preconditions gate affordances. Surface enabled expressions control visibility. The vocabulary space grows as agents register actions and views. The lobby → observe → embody sequence (agency-and-identity.md) gates participation modes.

The substrate becoming richer. New keys appearing, new vocabulary being registered, new views computing new derived facts, the _contested view appearing and resolving. The room gaining meaning through accumulated traces of participation. "What Becomes True" names this but it lacks operational vocabulary.

The fourth dimension is not a new layer — it is a property that should pervade all three. The substrate's capacity to direct attention toward what matters, including things the participant doesn't know to ask about. Not just "what can you see" and "what can you do" but "what should you notice."

The current system is reactive: it responds to what the agent asks for. Adaptive salience makes it proactive: it shapes what the agent encounters based on what the substrate knows about the room's health, the agent's history, and the gap between them.

Six domains have independently solved versions of the same problem: how does a system with autonomous participants manage collective attention without centralised control? Each domain's solution has a shallow, deep, and structural layer. The structural layer in every case converges on the same insight.

The problem. When formal communication channels (doctrine, SOPs, operations orders) fail to express the current situation, combatants fall back on informal channels (radio chatter). If the formal channel is too specific, reality exceeds it constantly. Radio chatter becomes the primary coordination mechanism — the crutch. This is sync's message problem.

Shallow fix: After Action Reviews. Periodic doctrine review. Examine what happened, identify lessons learned, update SOPs. This is the reflexive review approach — a bolted-on process, not structural. The US Army's Center for Army Lessons Learned (CALL) institutionalised this after Vietnam, but the reviews are post-hoc and slow. By the time doctrine updates, the situation has changed again.

Deep fix: Commander's Intent. The Prussian innovation, formalised under Helmuth von Moltke the Elder during the Wars of Unification (1864-1871). Moltke recognised that no plan survives contact with the enemy, so the solution is not better plans but compressed goals. Commander's Intent is a short, clear statement of the desired end state that persists when specific operational vocabulary breaks down.

Moltke's key insight: subordinates who share the commander's intent can improvise coherently. Their radio chatter converges toward the same goal even without shared vocabulary for the specific situation. The formal channel doesn't need to capture every contingency — it needs to express the intent clearly enough that informal improvisation stays aligned.

This became Auftragstaktik (mission-type tactics), which the German military historian Dr Rob Citino notes was not actually the term the Germans used — they preferred Selbständigkeit (the freedom to change an order based on circumstances). The cultural philosophy valued three qualities in officers: knowledge, independence, and the joy of taking responsibility. An unforgivable mistake was inaction — waiting for orders when the situation demanded initiative (Nelsen, 1987; Vandergriff, 2019).

Structural fix: Constraint surfaces, not plans. The deepest expression of mission command is that the formal layer expresses constraints and intent rather than procedures. A commander says: "I need that hill secured by 0600 with lines of communication maintained." This is a constraint surface — a description of the conditions that must hold, not the actions that must be taken. Subordinates self-organise to satisfy the constraints. Radio chatter operates within the constraint space, not as an escape from it.

The US Army adopted mission command formally in FM 100-5 (1986), but as the Small Wars Journal analysis notes, the institutional culture has struggled to operationalise it. The American military copied the verbiage of Auftragstaktik but failed to build the trust and training infrastructure that made it work. The doctrine says "decentralised execution" while the culture rewards detailed control. This is relevant to sync: the architecture says "agents self-activate" but the tooling rewards specific procedural vocabulary.

Mapping to sync. An action registration is currently procedural: "when this condition holds, write these values to these keys." This is a plan, not an intent. When the plan breaks (CEL error, state shape change, contested targets), agents fall back on messages. If action registrations also carried intent — a statement of what the action is trying to achieve, separate from its implementation — the intent would persist even when the CEL breaks. Other agents could read the intent and understand the purpose, even if the specific implementation is broken. Commander's Intent for vocabulary.

The problem. Students accumulate notes without revising. They re-read highlighted passages and feel fluent, but the fluency is an illusion — they haven't actually learned. When tested, they fail. The gap between perceived competence and actual competence is invisible to the student. This is sync's context shaping problem: agents request lean context and feel efficient, but lean context creates unknown unknowns.

Shallow fix: Formative assessment. Test during learning, not just after. Detect gaps early. This maps to the reflexive review approach — surface broken views and stale actions. Better than nothing, but relies on the learner (agent) to act on the assessment.

Deep fix: Scaffolding and fading (Vygotsky, 1978). Lev Vygotsky's Zone of Proximal Development (ZPD) describes the space between what a learner can do independently and what they can do with guidance. The teacher adjusts what's visible — not hiding knowledge, but presenting problems at the boundary of the learner's current capability. A student who can't solve two-digit addition doesn't see calculus — not because it's secret, but because the environment manages the progression.

The critical insight is that the environment manages attention, not the student. Bruner (1976) formalised this as scaffolding: temporary support structures that the teacher erects and then removes as the student becomes competent. The scaffold is not the knowledge — it's the structure that makes the knowledge approachable.

In sync terms: context shaping shouldn't just comply with what the agent asks for. It should scaffold the agent's engagement with the room — presenting increasingly rich context as the agent demonstrates competence (measured by action invocation patterns, vocabulary registration, view usage).

Structural fix: Desirable difficulties (Bjork, 1994). Robert Bjork's counterintuitive finding: making learning harder in specific ways — interleaving topics, spacing practice, requiring retrieval instead of re-reading — produces better long-term retention and transfer. The student who re-reads notes feels fluent but hasn't learned. The student who is forced to recall from memory feels uncomfortable but actually retains.

Bjork (1994) draws a crucial distinction between performance (short-term measurable output) and learning (durable, transferable change). Conditions that produce rapid performance gains often fail to support long-term retention. Conditions that support retention seem to slow apparent progress, making them unpopular with students. This is the core paradox: what feels productive often isn't, and what produces genuine improvement often feels unproductive.

Bjork and Bjork (2020) identify five desirable difficulties: varying conditions, interleaving topics, spacing practice, retrieval practice, and generation (producing answers rather than recognising them). The common thread: each forces deeper processing by making the easy path unavailable.

Mapping to sync. An agent always fetching depth=lean is the student always re-reading highlights. It feels efficient. It's actually the least effective mode for developing understanding of the room's state. The system complying with lean is pedagogically negligent.

But not all difficulty is desirable. Bjork emphasises that the learner must have sufficient background knowledge to respond to the difficulty successfully. An agent that has never read the room getting depth=full with 50 views and 30 actions is overwhelmed, not challenged. The substrate needs to calibrate difficulty to observed competence — Guadagnoli and Lee's (2004) Optimal Challenge Point framework: maximum difficulty the learner can currently handle.

The problem. Scientific knowledge accumulates. Theories gain confirming evidence. But confirming evidence doesn't actually advance knowledge — it only increases confidence, which can be misplaced. When a theory encounters anomalies, practitioners patch the theory rather than reconsidering its foundations. The patches accumulate until the theory is unfalsifiable — it can explain anything because it has been adjusted to accommodate everything. This is sync's vocabulary accretion problem.

Shallow fix: Peer review. Others check your work. Catches errors, but doesn't address structural degeneration of the theory itself. Maps to reflexive review.

Deep fix: Research programmes (Lakatos, 1978). Imre Lakatos proposed that theories are not isolated claims but research programmes — a hard core of commitments surrounded by a protective belt of auxiliary hypotheses. When anomalies arise, they hit the belt first. Practitioners modify the belt to preserve the core.

Lakatos distinguished progressive programmes from degenerating ones. A progressive programme generates novel predictions — its modifications lead to new discoveries. A degenerating programme only accommodates known anomalies — its modifications are ad hoc patches that save the theory without advancing understanding. The diagnostic is not "are there anomalies?" but "is the programme predicting new things or just patching old ones?"

This maps directly to vocabulary health. A room whose agents are registering new actions that enable novel behaviours (progressive) is healthy. A room whose agents are registering actions to work around broken views or patch state inconsistencies (degenerating) is unhealthy. The distinction is measurable: progressive additions are invoked after registration (they were needed), degenerative additions are registered and ignored (they were patches).

Structural fix: Falsification asymmetry (Popper, 1959). Karl Popper argued that the only operation that advances knowledge is the non-monotonic one — refutation. You can never prove a theory true, only prove it false. Therefore the scientific method is structurally biased toward the non-monotonic operation: it rewards finding what's wrong, not confirming what's right.

This is the deepest challenge to sync's architecture. The substrate is structurally biased toward the monotonic operation (register, append, accrete). The non-monotonic operations (update, delete, refactor) are equally possible but not equally easy or encouraged. The scientific method's power comes from making refutation not just permitted but celebrated. Sync needs an equivalent structural bias — not forcing non-monotonic operations, but making them as natural and rewarded as monotonic ones.

The problem. Traditional cognitive science models perception as a representational process: perceive → build internal model → reason about model → act. This creates a bottleneck — the internal model must be maintained, updated, and consulted. Coordination between agents requires synchronising models.

Structural fix: Affordances (Gibson, 1979). James Gibson proposed that organisms perceive affordances — possibilities for action that the environment presents directly to perception — rather than building internal models. A handle affords pulling. A flat surface affords sitting. Perception and action are coupled without an intermediate reasoning layer.

Gibson's key insight for sync: affordances are relational properties. They exist in the relationship between the organism and the environment, not in either alone. A door handle affords pulling for a creature with hands. The same handle affords nothing for a creature without them. Affordances are agent-relative but environment-specified.

sync's /context endpoint already functions as an affordance map — it returns not just state but available actions with parameter schemas. But Gibson also argued that affordances have salience that varies with the organism's current state. A thirsty animal perceives water sources more readily. The affordance was always there, but its salience changed.

The current context system has uniform salience. Every action and view is equally prominent in the response. Adaptive salience would vary the prominence of affordances based on the agent's current state and the room's current needs.

The problem. Stigmergic coordination works through environmental traces. But traces accumulate. Old pheromone trails persist after the food source is depleted. Agents follow stale trails. The environment's memory becomes a liability.

Structural fix: Evaporation (Dorigo, 1992). Marco Dorigo's Ant Colony Optimization algorithm introduced pheromone evaporation as a design parameter. Trails decay over time unless reinforced by continued use. This provides a natural mechanism for forgetting stale information — the environment has a half-life for traces. Only actively reinforced signals persist.

This is directly applicable to vocabulary health. Views that are never referenced by other views or action preconditions, actions that are never invoked, state keys that are never read — these are stale pheromone trails. The substrate doesn't need to delete them. It needs to deprioritise them — reduce their salience in context reads over time unless they are actively reinforced.

Evaporation also solves the degenerating programme problem. A view that errors on every evaluation is not being reinforced — its effective salience drops. A new view that produces useful values is actively consumed — its salience rises. The substrate's attention naturally migrates toward healthy vocabulary without explicit cleanup.

The problem. Organisations accumulate procedures. When a procedure doesn't produce the desired outcome, the standard response is to adjust the procedure (single-loop learning). The assumptions behind the procedure are rarely questioned. This produces increasingly complex bureaucracies that are locally optimised but globally incoherent.

Structural fix: Double-loop learning (Argyris & Schön, 1978). Chris Argyris distinguished single-loop learning (adjusting actions to achieve existing goals) from double-loop learning (questioning the goals themselves). Single-loop asks "are we doing this right?" Double-loop asks "are we doing the right thing?"

Most agent-substrate interactions are single-loop: the agent reads context, evaluates whether its actions are achieving its objective, and adjusts. The substrate currently supports single-loop learning well (context reads, action results, audit logs). What it doesn't support is double-loop: the agent questioning whether its vocabulary — not just its actions within the vocabulary — is appropriate for the room's current state.

The After Action Review (AAR) is the military's institutionalised double-loop mechanism. But AARs are episodic and facilitated — they don't happen automatically. The substrate equivalent would be structural: the system automatically surfaces signals that the vocabulary itself may need revision, not just the actions within it.

Across all six domains, the structural fix follows the same pattern:

1. The formal layer should express constraints and intent, not procedures. Commander's Intent, not operations orders. The substrate's vocabulary should carry why, not just what.

2. The environment should manage attention, not just comply with requests. Scaffolding, not self-service. The substrate should shape what agents encounter based on room health and agent history.

3. Easy paths should be productive, not merely comfortable. Desirable difficulties, not frictionless consumption. The substrate should make the healthy path natural and the pathological path visible.

4. Signals should decay unless reinforced. Pheromone evaporation, not permanent accumulation. Vocabulary salience should track usage, not just existence.

5. The system should distinguish progressive from degenerative change. Lakatos's criterion. New vocabulary that enables novel behaviour is healthy. New vocabulary that patches around broken vocabulary is symptomatic.

Registration-time validation (views.ts:30-31). validateCel() catches syntactic errors but is deliberately forgiving — it runs against an empty context, and "No such key" errors pass validation. This is correct for "absence is signal" but means semantically broken expressions (referencing keys that will never exist, scope name typos) pass.

Registration-time evaluation (views.ts:70-78). After storing, the view is evaluated against current state. Errors produce { _error: e.message } in the returned value. The registering agent gets immediate feedback.

Read-time evaluation (cel.ts:248-253). On every buildContext, views that throw get { _error: e.message } as their value. This propagates into every context read. But: there is no _context.help suggestion for it. No surfacing alongside contested_actions or vocabulary_bootstrap. Broken views are silently present in the data but never called out.

Dashboard path (context.ts:428-432). Same pattern: catches errors, stores { _error }, passes along. The dashboard could render this visually but the signal isn't elevated.

Gap: The _context envelope computes situational help for empty rooms (vocabulary_bootstrap), contested actions (contested_actions), directed messages (directed_messages), and truncated messages (context_shaping). It does not compute help for broken views, stale actions, or vocabulary health.

Both registerAction and registerView use ON CONFLICT ... DO UPDATE. The mechanism for in-place revision exists. But nothing in the system encourages it:

• No staleness signal. No last_invoked_at on actions, no last_referenced_at on views, no "this action has been available for 50 reads but invoked 0 times."

• _context.help suggests vocabulary_bootstrap when no custom actions exist. Never suggests "review your existing vocabulary."

• The audit log tracks registration and invocation but there is no derived view computing adoption metrics.

• The ON CONFLICT path is identical to the creation path — there is no distinction between "I am creating new vocabulary" and "I am revising existing vocabulary." No structural encouragement to revise.

Context shaping is fully agent-initiated (context.ts:46-63). The agent sets depth, only, include, and messages_after. The system complies and reports what was elided. The _context envelope is descriptive (what was returned) not prescriptive (what should be attended to).

The _context.help array is the closest thing to proactive attention management, but it only fires on specific structural conditions (empty room, contested targets, directed unread, truncated messages). It does not fire on agent-specific conditions (you haven't read views in 10 reads, you registered an action that has never been invoked, a view you depend on is broken).

Messages are the only unconstrained operation. _send_message accepts arbitrary JSON. No schema enforcement, no precondition, no write template. The system has no mechanism to detect when message patterns indicate vocabulary gaps — when agents are repeatedly messaging about a concept that should be an action or a view.

The substrate should not override agent autonomy. Agents can still request depth=lean. But the substrate returns more than asked for when it has reason to believe the agent is missing something important. The additions are lightweight — metadata in the _context envelope, not additional payload.

This is the scaffolding model: the environment manages attention in addition to responding to requests. The scaffold is removable — agents can ignore it. But it's present by default.

Extend the _context envelope with an _attention section computed per-read.

"_context": {
  "sections": ["state", "views", "agents", "actions"],
  "depth": "lean",
  "help": ["vocabulary_bootstrap"],
  "_attention": {
    "broken_views": ["stale_metric", "bad_aggregation"],
    "stale_actions": ["unused_vote"],
    "since_your_last_read": {
      "state_changes": 7,
      "new_actions": 2,
      "actions_invoked": ["submit_result", "advance_phase"],
      "views_changed": ["progress_count"]
    },
    "you_elided": ["views"],
    "vocabulary_health": "degenerating"
  }
}

broken_views: View IDs where the current evaluation produces _error. Computed during the existing view resolution loop (cel.ts:248-253) — no additional query needed, just collecting the error IDs.

stale_actions: Action IDs with zero invocations and registration age exceeding a threshold (e.g., 10+ context reads since registration, no invocations). Requires tracking last_invoked_at on actions (new column) or computing from the audit log.

since_your_last_read: Delta since this agent's last context read. Requires tracking a last_context_read_at timestamp per agent (the last_heartbeat field already serves a similar purpose but is updated by any interaction, not just reads).

you_elided: Sections the agent's request excluded that contain relevant changes since their last read. If the agent requested only=actions but views have changed since their last read, you_elided says ["views"]. The agent didn't ask for views; the substrate notes they're missing something.

vocabulary_health: A summary assessment — "progressive" (new vocabulary is being invoked), "stable" (vocabulary is established and in use), "degenerating" (new vocabulary is accumulating without invocation, broken views exist, message-to-action ratio is high). The Lakatos diagnostic as a one-word signal.

Extend action registration with an optional intent field.

{
  "id": "advance_phase",
  "intent": "Move the game to its next logical phase",
  "description": "Write next phase value based on current phase",
  "if": "state[\"_shared\"][\"phase\"] != \"complete\"",
  "writes": [...]
}

intent is natural language. It persists when the CEL breaks. It is readable by agents who don't understand the CEL implementation. It serves the same role as Commander's Intent: compressed purpose that survives implementation failure.

Two actions with overlapping intents (detected via embedding similarity or simple keyword overlap) surface as a new signal alongside _contested: purpose overlap distinct from write-target overlap. The contested view shows mechanical collision; intent overlap shows conceptual collision.

Schema change: add intent TEXT column to the actions table. No migration risk — purely additive. Stored alongside description, surfaced in context at depth=full.

Register a system-computed view _vocabulary_health that aggregates:

{
  "total_actions": 12,
  "total_views": 8,
  "broken_views": 2,
  "stale_actions": 3,
  "contested_targets": 1,
  "message_to_action_ratio": 4.2,
  "assessment": "degenerating",
  "suggestions": [
    "2 views have CEL errors — consider revising or deleting",
    "3 actions registered but never invoked — consider whether they serve the room",
    "High message volume relative to action invocations — vocabulary may be incomplete"
  ]
}

This is the After Action Review automated. It runs on every context read (lightweight — counts and ratios from existing data). The assessment is a Lakatos classifier:

• progressive: recently registered vocabulary is being invoked. The programme is predicting new things.
• stable: vocabulary is established, invocation rates are steady. The programme is in normal science.
• degenerating: new vocabulary is accumulating without invocation, broken views persist, messages substitute for vocabulary. The programme is producing ad hoc patches.

The _context.help array includes vocabulary_review when the assessment is degenerating. Help content guides the agent through revision: reviewing stale actions, fixing broken views, extracting message patterns into vocabulary.

Track message metadata (not content) to detect vocabulary gaps.

kind frequency: If agents send 10+ messages with kind: "negotiation" about the same state key, the substrate notes this in _vocabulary_health: "agents frequently negotiate about _shared.deadline — no action captures this concept."

Pre-action clustering: If messages consistently precede a specific action invocation (agent sends message, then invokes action within next 2 reads), the message may be compensating for missing precondition communication. The action's parameter space may be too narrow.

Post-error messaging: If a broken view or failed action invocation is followed by messages, agents are working around the failure informally. The substrate should surface this pattern — "agents are messaging about _shared.progress after progress_view errors — the view may need revision."

This turns messages from a crutch into a vocabulary discovery channel. The informal channel feeds back into the formal channel. Radio chatter becomes doctrine source material.

Implementation: light metadata tracking. On each message, record kind, any state keys mentioned in message body (string matching against known keys), and the subsequent action invocation (if any). Stored as an append-only _message_patterns scope, pruned to a rolling window.

Instead of uniformly complying with the agent's depth request, the substrate may promote specific elements when conditions warrant.

Broken view promotion: If the agent requests depth=lean but a view it registered is broken, include the error detail for that specific view even at lean depth. The agent asked for lean; the substrate gives lean plus the thing that's broken that the agent needs to see. This is scaffolding: the environment injects what the learner needs without overwhelming them with everything.

Stale action annotation: At depth=usage, stale actions get an additional _stale: true flag. At depth=lean, stale actions get a count annotation: "stale_actions": 3 in _attention. The information is proportional to the depth — more detail at higher depth, but the signal is present at all depths.

First-read enrichment: The first context read by a new agent in a room gets promoted to depth=full regardless of what the agent requested, with a _context note explaining why: "First read — full context provided to establish baseline understanding. Subsequent reads will respect your depth preference." This is the desirable difficulty: the agent is forced to encounter the full vocabulary before it can choose to ignore parts of it. Bjork's retrieval practice applied to substrate perception.

Selective promotion thresholds: Not every deviation from the agent's request is warranted. The substrate should promote only when the delta between the agent's request and the room's state exceeds a threshold:

• Broken views: always promote (the agent should always know about errors in its own vocabulary)
• Stale actions: promote when count exceeds 3 or when stale/total ratio exceeds 0.3
• You-elided warnings: promote when the elided section has changed since the agent's last read
• First-read enrichment: always on first read, never afterwards

Vocabulary items that are not reinforced (referenced, invoked, depended upon) should lose salience over time. This is not deletion — the vocabulary persists in the database. It is deprioritisation in context responses.

Mechanism: Track a reinforcement_score per action and view. Score increases on invocation (actions) or reference by other views/action preconditions (views). Score decays on each context read where the item is not used. Items below a threshold get a _low_salience: true annotation in context responses.

At depth=lean, low-salience items may be omitted entirely (with a count in _attention: "low_salience_items": 4). At depth=full, they appear with the annotation. The agent can always request them explicitly.

This is pheromone evaporation for vocabulary. Actively used vocabulary stays prominent. Abandoned vocabulary fades. The room's perceptual field naturally cleans itself over time.

Caution: Evaporation must not affect correctness. An action with low salience that is invoked must still execute correctly. A view with low salience that is evaluated must still return its value. Salience affects visibility in context responses, not availability in the substrate. This is the distinction between perceptual salience and ontological existence — the substrate contains everything; the context envelope presents what's salient.

Add a new help key vocabulary_review to HELP_SYSTEM:

# Vocabulary review

Your room's vocabulary health is assessed on every context read.
The _vocabulary_health system view reports the current assessment.

## Progressive vocabulary

New vocabulary is being invoked. The room's affordance space is growing
productively. Continue registering vocabulary as needed.

## Degenerating vocabulary

Signals:
- Actions registered but never invoked (stale)
- Views with CEL errors (broken)
- High message volume relative to action invocations (vocabulary gaps)

## Revision patterns

**Fix a broken view**: Re-register with the same ID and a corrected expression.
  ON CONFLICT updates in place. No deletion needed.

**Retire a stale action**: If an action was registered but never invoked,
  consider whether the room needs it. Delete with _delete_action if not.

**Formalise a message pattern**: If agents are messaging repeatedly about
  a concept, that concept needs vocabulary. Register an action that captures
  the pattern. The message channel should be for novel situations, not
  routine coordination.

**Refactor contested targets**: If _contested shows multiple actions writing
  to the same key, consider whether a single action with richer parameters
  could replace them. Or restructure state so each action writes to its own
  key and a view aggregates.

## The principle

Vocabulary is a theory about what the room is for.
Good theories predict new behaviour. Degenerating theories patch old failures.
Review your vocabulary the way a scientist reviews their theory:
is it enabling new work, or just accommodating old problems?

1. In buildExpandedContext (context.ts), after the view resolution loop, collect view IDs where ctx.views[id] has an _error property.
2. If any exist, push "broken_views" to contextHelp.
3. Include the IDs in _context._attention.broken_views.
4. Add vocabulary_review help content to HELP_SYSTEM.

Files changed: context.ts, help-content.ts Risk: None. Additive to the _context envelope.

1. Add last_invoked_at TEXT column to the actions table in schema.ts.
2. In invokeAction (invoke.ts), update last_invoked_at on successful invocation.
3. In buildExpandedContext, compute stale actions (registered, never invoked or not invoked in N context reads). Push "vocabulary_review" to contextHelp when stale count exceeds threshold.

Files changed: schema.ts, invoke.ts, context.ts Risk: Schema migration. Additive column, safe.

1. Track last_context_read_version per agent (extend agents table or use scope state).
2. On each context read, compute delta (state changes, new actions, view changes since last read).
3. Compute you_elided by comparing only filter against changed sections.
4. Assemble _attention object in buildExpandedContext.

Files changed: context.ts, agents.ts, schema.ts Risk: Moderate. Adds per-agent tracking. Must be lightweight.

1. Add intent TEXT column to the actions table.
2. Accept intent in registerAction.
3. Surface in context at depth=full.
4. Future: intent overlap detection.

Files changed: schema.ts, actions.ts, context.ts Risk: None. Purely additive.

1. Compute _vocabulary_health in buildExpandedContext alongside _contested.
2. Aggregate: broken view count, stale action count, contested count, message-to-action ratio.
3. Classify as progressive/stable/degenerating.
4. Surface as a system view in context.

Files changed: context.ts Risk: Low. Computational cost of aggregation — keep lightweight.

1. Implement broken view promotion at lean depth.
2. Implement first-read enrichment.
3. Implement you_elided warnings.
4. Make promotion thresholds configurable per room (via _shared._config).

Files changed: context.ts Risk: Moderate. Changes agent expectations about context shape. Needs clear documentation and _context metadata explaining promotions.

1. Lightweight message metadata tracking.
2. kind frequency analysis.
3. Correlation with action invocations.
4. Surface patterns in _vocabulary_health.

Files changed: invoke.ts (message handling), context.ts Risk: Higher. Content analysis, even lightweight, has privacy implications. Start with metadata only (kind, key mentions, timing).

1. Implement reinforcement_score tracking.
2. Decay on unreferenced context reads.
3. Low-salience annotations.
4. Optional omission at lean depth.

Files changed: schema.ts, context.ts, actions.ts, views.ts Risk: Highest. Changes the implicit contract that all vocabulary is equally visible. Needs careful threshold tuning and clear override mechanism.

• Does not add orchestration. Adaptive salience is computed per-read, stateless, and agent-specific. No scheduler, no coordinator, no controller. The substrate remains controllerless.

• Does not override agent autonomy. Agents can still request any depth and filter any section. Adaptive salience adds metadata; it does not withhold data. The scaffold is advisory, not coercive.

• Does not require new endpoints. All changes are within the existing context assembly path (buildExpandedContext) and the existing registration paths. The API surface is unchanged.

• Does not solve the orchestration problem. Vocabulary health signals are diagnostic — they tell agents what's wrong. They do not fix it. The non-monotonic operations (revision, deletion, refactoring) remain agent-initiated. The substrate can encourage but not perform vocabulary maintenance.

• Does not add AI/LLM analysis to the substrate. Message pattern detection uses metadata analysis (frequency, correlation), not content interpretation. Intent overlap detection could use embeddings but the first implementation should use keyword overlap. The substrate stays interpretable without requiring intelligence.

Does this design honour the substrate thesis?

"State is the substrate." ✓ — Vocabulary health is computed from state. Attention metadata is derived from state. No new state type is introduced.

"Surfaces are observers." ✓ — _vocabulary_health is a system view, computed and observed like any other view. The _attention envelope is observation about observation — meta-perception.

"Actions are transitions." ✓ — Vocabulary revision uses existing registration endpoints. No new action type is needed. Agents revise vocabulary by re-registering with the same ID.

"Progressive disclosure is implicit." ✓ — Attention metadata discloses room health progressively. First-read enrichment discloses full vocabulary once. Evaporating salience naturally hides what isn't needed.

"No setup phase." ✓ — Vocabulary health computation requires no configuration. It activates naturally when there is vocabulary to assess.

"Presence is meaningful." ✓ — Adaptive salience is agent-specific. The delta since last read, the broken views that belong to this agent, the stale actions this agent registered — all scoped to the perceiving agent's history with the room.

• Moltke, H. von (1869). Instructions for Large Unit Commanders.
• Nelsen, J.T. (1987). "Auftragstaktik: A Case for Decentralized Battle." Parameters 17.
• Vandergriff, D. (2019). Adopting Mission Command. Naval Institute Press.
• US Army (1986). FM 100-5: Operations.
• US Army (2012). ADP 6-0: Mission Command.
• Bungay, S. (2011). The Art of Action: How Leaders Close the Gaps between Plans, Actions and Results. Nicholas Brealey.
• Citino, R. (2005). The German Way of War. University Press of Kansas.
• Clausewitz, C. von (1832). On War. Trans. Howard & Paret, Princeton University Press, 1976.

• Bjork, R.A. (1994). "Memory and metamemory considerations in the training of human beings." In J. Metcalfe & A. Shimamura (Eds.), Metacognition: Knowing about Knowing (pp. 185–205). MIT Press.
• Bjork, R.A. & Bjork, E.L. (2020). "Desirable difficulties in theory and practice." Journal of Applied Research in Memory and Cognition 9(4), 475–479.
• Bjork, E.L. & Bjork, R.A. (2011). "Making things hard on yourself, but in a good way: Creating desirable difficulties to enhance learning." In M.A. Gernsbacher et al. (Eds.), Psychology and the Real World (pp. 56–64). Worth.
• Vygotsky, L.S. (1978). Mind in Society: The Development of Higher Psychological Processes. Harvard University Press.
• Bruner, J.S. (1976). "The Role of Tutoring in Problem Solving." Journal of Child Psychology and Psychiatry 17, 89–100.
• Guadagnoli, M.A. & Lee, T.D. (2004). "Challenge point: A framework for conceptualizing the effects of various practice conditions in motor learning." Journal of Motor Behavior 36, 212–224.
• Bloom, B.S. (1956). Taxonomy of Educational Objectives. Longmans, Green.

• Popper, K.R. (1959). The Logic of Scientific Discovery. Hutchinson.
• Lakatos, I. (1978). The Methodology of Scientific Research Programmes. Cambridge University Press.
• Kuhn, T.S. (1962). The Structure of Scientific Revolutions. University of Chicago Press.
• Quine, W.V.O. (1951). "Two Dogmas of Empiricism." The Philosophical Review 60(1), 20–43.

• Gibson, J.J. (1979). The Ecological Approach to Visual Perception. Houghton Mifflin.
• Norman, D.A. (1988). The Design of Everyday Things. Basic Books.
• Chemero, A. (2003). "An Outline of a Theory of Affordances." Ecological Psychology 15(2), 181–195.

• Dorigo, M. (1992). Optimization, Learning and Natural Algorithms. PhD thesis, Politecnico di Milano.
• Dorigo, M. & Stützle, T. (2004). Ant Colony Optimization. MIT Press.
• Grassé, P.-P. (1959). "La reconstruction du nid et les coordinations interindividuelles." Insectes Sociaux 6(1).
• Theraulaz, G. & Bonabeau, E. (1999). "A Brief History of Stigmergy." Artificial Life 5(2), 97–116.

• Argyris, C. & Schön, D. (1978). Organizational Learning: A Theory of Action Perspective. Addison-Wesley.
• Argyris, C. (1991). "Teaching Smart People How to Learn." Harvard Business Review 69(3).
• Senge, P. (1990). The Fifth Discipline: The Art and Practice of the Learning Organization. Doubleday.

• Hellerstein, J. (2010). "The Declarative Imperative." SIGMOD Record 39(1).
• Alvaro, P. et al. (2011). "Consistency Analysis in Bloom: A CALM and Collected Approach." CIDR.

• The Substrate Thesis — the-substrate-thesis.md
• What Becomes True — what-becomes-true.md
• Surfaces as Substrate — surfaces-design.md
• Isn't This Just ReAct? — isnt-this-just-react.md
• Σ-Calculus — sigma-calculus.md
• The Pressure Field — pressure-field.md
• Agency and Identity — agency-and-identity.md

Christopher · Edinburgh · March 2026