@mindot/will 0.9.0 → 0.10.0

package/src/cognition/faculties/goal.manager.ts

@@ -693,7 +693,12 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
                             .find( g => {
                               return g.tags.includes( mapping.tags[0]! )
                                       && g.tags.includes( mapping.tags[1]! )
-                                      && g.status === 'active'
+                                      // `pending` counts as existing. It did not, and a
+                                      // goal demoted for capacity therefore stopped
+                                      // blocking its own respawn — the drive minted a
+                                      // fresh copy every time its threshold was crossed.
+                                      // Measured: 92 identical copies of one goal.
+                                      && ( g.status === 'active' || g.status === 'pending')
                             })
 
       // Never spawn a goal that is *already satisfied* — it would complete on its
@@ -720,7 +725,9 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
         // Dedup by the referent (keid: tag) when present, else by description.
         const keidTag = tags.find( t => t.startsWith('keid:') )
         const existing = Array.from( this._goals.values() ).find( g =>
-          g.status === 'active' && ( keidTag ? g.tags.includes( keidTag ) : g.description === desc ) )
+          // Same rule as the drive path: a waiting goal still exists.
+          ( g.status === 'active' || g.status === 'pending')
+          && ( keidTag ? g.tags.includes( keidTag ) : g.description === desc ) )
 
         // Don't spawn a goal that's already satisfied (born-done guard — see _activateFromDrives).
         if( !existing && !this._isConditionMet( cCond, state ) )
@@ -805,6 +812,32 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
     return 0
   }
 
+  /**
+   * Reconcile the active set to capacity — in BOTH directions.
+   *
+   * Demotion alone made `pending` a one-way door, and a mind fell through it.
+   * Nothing in this file promoted a goal back (the only other write of `'active'`
+   * is `pending_verification`'s, a different status), so a goal demoted for
+   * capacity was demoted for good. Worse, `pending` is excluded from every other
+   * mechanism that could have retired it: it is not in `getActiveGoals()`, not
+   * progress-updated, not reachable by the patience/grit sweep (which skips any
+   * status but `'active'`) — yet it IS re-persisted every tick and rehydrated on
+   * every restore. Inert and immortal at once.
+   *
+   * Measured on a live COO: 96 goal entities, of which **83 pending, 0 active**,
+   * and 92 of the 96 the same drive-spawned goal. `activeGoalCount` sat at 0, so
+   * `goalless_crisis` fired every 20 ticks forever while she carried 83 goals —
+   * and the `goal` term, the joint-largest weight in the affordance competition,
+   * contributed nothing to any choice she made.
+   *
+   * Promotion also restores GC reachability, which is the quieter half of the
+   * fix: an over-patient stale goal can only be abandoned while it is active.
+   *
+   * `activatedAt` is deliberately NOT refreshed on promotion. Refreshing it would
+   * let a goal cycle demote→promote and reset its own patience each time, making
+   * it unretirable — the immortality this fix exists to end, reintroduced by the
+   * back door. A goal's age is when it was taken up, not when it last got a slot.
+   */
   private _resolveConflicts(): void {
     const active = this.getActiveGoals()
 
@@ -813,6 +846,21 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
       const lowest = active.pop()
       if( lowest ) lowest.status = 'pending'
     }
+
+    // ...and take the best waiting goals back up when there is room. Only ever
+    // reached when UNDER capacity, so this cannot undo the demotion above:
+    // the loop leaves the set at exactly capacity, and this one starts below it.
+    if( active.length >= this._maxActiveGoals ) return
+
+    const waiting = Array.from( this._goals.values() )
+                         .filter( g => g.status === 'pending')
+                         .sort( ( a, b ) => b.priority - a.priority )
+
+    for( const goal of waiting ){
+      if( active.length >= this._maxActiveGoals ) break
+      goal.status = 'active'
+      active.push( goal )
+    }
   }
 
   // ── Internal: progress ───────────────────────────────────

package/src/cognition/faculties/known.entity.tracker.ts

@@ -108,7 +108,16 @@ const SENTIENT_DOMAINS = new Set<string>([ 'audition' ])
 // specific "get to know them" pull; it subsides once resolution reaches RESOLVED.
 const CURIOUS_FAMILIARITY = 0.5
 const CURIOUS_RESOLUTION   = 0.4
-const CURIOUS_RESOLVED     = 0.6
+/**
+ * Resolved enough to stop wondering — the point the curiosity goal completes at.
+ *
+ * Exported because the AffordanceSynthesizer offers `inspect` against referents
+ * BELOW it. Two readers, one constant, deliberately: if the act that satisfies
+ * curiosity and the goal that measures it disagreed about when something is
+ * known, a mind could keep being offered a look at what it had already placed —
+ * or stop being offered one while the goal it holds is still open.
+ */
+export const CURIOUS_RESOLVED = 0.6
 
 // Forgetting (Phase 4). (Reliability rate is now a Channel-A developable field — analytical.)
 const FORGET_FLOOR     = 0.02    // below this familiarity, an unidentified blip is forgotten
@@ -154,6 +163,8 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
     keid: string; domain: string; name?: string
     /** The room this encounter happened in, and whether it was a private one. */
     thread?: string; direct?: boolean
+    /** What that room is called, where the channel offered a label. */
+    threadName?: string
   }> = []
   // Buffered from known.entity.learned (the conscious / reasoning write-path, Phase 2.2).
   private _pendingConscious: Array<{
@@ -247,12 +258,15 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
     // `direct` is the one bit the Discord edge computed (`isDM`) and threw away
     // before the mind could see it — the single fact that decides whether a room
     // is the right place for a given utterance.
-    const raw  = p?.raw as { speakerName?: unknown; threadId?: unknown; direct?: unknown } | undefined
+    const raw  = p?.raw as { speakerName?: unknown; threadId?: unknown; direct?: unknown; threadName?: unknown } | undefined
     const name = typeof raw?.speakerName === 'string' ? raw.speakerName : undefined
     const thread = typeof raw?.threadId === 'string' ? raw.threadId : undefined
     const direct = typeof raw?.direct === 'boolean' ? raw.direct : undefined
+    // What the room is CALLED. A place has had a dossier since 0.9.0 and no way
+    // to be named, so every room the mind knew rendered as "something".
+    const threadName = typeof raw?.threadName === 'string' ? raw.threadName : undefined
 
-    this._pendingEncounters.push({ keid, domain: p!.domain, name, thread, direct })
+    this._pendingEncounters.push({ keid, domain: p!.domain, name, thread, direct, threadName })
   }
 
   snapshot(): Record<string, unknown> {
@@ -319,6 +333,11 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
           place.encounterCount += 1
           place.familiarity     = Math.min( 1, place.familiarity + this._growthRate * ( 1 - place.familiarity ) )
           place.lastSeenTick    = tick
+          // A room learns its name the same way a person does — from what the
+          // channel offers, and only while it has none. Re-taken every encounter
+          // it would churn the cached prompt on a rename; more to the point, a
+          // name the mind already holds is the mind's, not the platform's.
+          if( enc.threadName && !place.name ) place.name = enc.threadName
           place.resolutionConfidence = this._resolution( place )
         }
       }

package/src/cognition/faculties/planning.engine/engine.ts

@@ -20,7 +20,7 @@
  * competition: each tick it projects its ready frontier step(s) as `plan.prior`
  * entities the AffordanceSynthesizer turns into competing affordances (top-down
  * prior, never a bypass — see PLANNING_AS_PRIOR_TODO.md). The ordinary selector
- * enacts the winner; the executor emits `action.outcome{planId,stepId}` (provenance
+ * enacts the winner; the executor emits `action.outcome{planId,stepId}` (the plan link
  * carried through the affordance→intent chain), which this engine consumes to
  * advance the frontier. Resolves the prerequisite DAG to choose the ready frontier.
  *
@@ -207,7 +207,7 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
           planId?: string; stepId?: string
         }
 
-        // Conscious-enaction credit: outcomes carry plan provenance only when
+        // Conscious-enaction credit: outcomes carry a plan link only when
         // the plan's OWN frontier prior won the competition. But the plan is a
         // prior over WHAT to do — if the self does the very thing an active
         // step calls for by any route (executive action via ideomotor, habit),
@@ -222,7 +222,7 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
             if( plan.status !== 'executing') continue
             const step = plan.steps.find( s => s.status === 'active' && s.action === p.actionType )
             if( !step ) continue
-            logger.info(`[planning] conscious-enaction credit: ${plan.id}/${step.id}=${step.action} (no provenance on outcome)`)
+            logger.info(`[planning] conscious-enaction credit: ${plan.id}/${step.id}=${step.action} (no plan link on outcome)`)
             this._onStepOutcome( plan.id, step.id, {
               success: p.success,
               description: p.description ?? ( p.success ? 'Completed' : 'Failed'),
@@ -656,7 +656,7 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
     // pause/escalate, or a terminal goal — it stops projecting its frontier. But an
     // `agency.intent` the competition had ALREADY committed from a frontier prior can
     // still resolve a few ticks later (sync this tick, or an awaiting one timing out).
-    // That outcome carries this plan's provenance, so it lands here. We must NOT act on
+    // That outcome carries this plan's link, so it lands here. We must NOT act on
     // it: completion is the executive's call, not the late arrival of a step it has
     // already moved past — and re-running supervision below could re-spawn the facet
     // we just tore down. The enaction itself still happened (and still taught the

package/src/cognition/faculties/planning.engine/plan.frontier.ts

@@ -37,7 +37,7 @@ export function computeReadySet( plan: Plan ): PlanStep[] {
  * entities — the top-down bias the AffordanceSynthesizer reads. Rebuilt each tick
  * (cleared then re-emitted, like the affordance field), so a frontier that
  * advances or a plan that ends stops biasing automatically. The prior carries the
- * planId/stepId provenance that flows affordance → intent → action.outcome, and a
+ * planId/stepId plan link that flows affordance → intent → action.outcome, and a
  * `planBias` strength from the goal's importance ⊕ the plan's confidence. It never
  * forces an action — if a more pressing affordance wins, the plan re-projects next
  * tick (no orphaning).

package/src/cognition/faculties/semantic.engine/integrator.ts

@@ -634,7 +634,7 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
 
     // Seed or preserve history.
     // If the belief arrives with an existing history (e.g. from a PMM load or
-    // snapshot restore), preserve it and append the load event so provenance
+    // snapshot restore), preserve it and append the load event so the lineage
     // is traceable without losing the full trajectory.
     // For brand-new beliefs (no prior history) seed a single creation entry.
     if( newBelief.history && newBelief.history.length > 0 ){

package/src/cognition/faculties/working.memory.ts

@@ -280,7 +280,12 @@ export class WorkingMemory implements SimulationEngine, CognitiveEngine {
       this._items.push({
         id: `wm-percept-${entity.id}`,
         type: 'percept',
-        content: { summary, entityId: entity.id },
+        // The data too, not only the label. A percept entity is swept after 2
+        // ticks; WM is where it is remembered, and remembering a sentence about
+        // the evidence instead of the evidence is how a mind ends up unable to
+        // answer a question it already had the answer to.
+        content: { summary, entityId: entity.id,
+                   ...( entity.metadata?.data !== undefined ? { data: entity.metadata.data } : {} ) },
         activation: 0.75,
         attendedAt: [],
         createdAt: tick,

package/src/cognition/instruction.handler.ts

@@ -18,7 +18,7 @@ export interface Instruction {
   deadline?: number
   /** Constraints on how to execute */
   constraints?: string[]
-  /** Context/provenance — why this instruction was given */
+  /** Context — why this instruction was given */
   context: string
   /** Whether the Will can refuse */
   isOverridable: boolean

package/src/cognition/memory/vector.embedder.ts

@@ -67,8 +67,6 @@ export class OpenAICompatibleEmbedder implements EmbeddingProvider {
      * and return "no recall" while a mind with six live facets was asking.
      */
     maxConcurrency?: number
-    /** @deprecated use maxConcurrency — kept as its fallback for back-compat. */
-    batchSize?: number
     /** Per-request timeout in ms before the connection is aborted. Default 30s. */
     timeoutMs?: number
     /**
@@ -82,7 +80,7 @@ export class OpenAICompatibleEmbedder implements EmbeddingProvider {
     this.dimensions = config.dimensions
     this._apiUrl = config.apiUrl
     this._apiKey = config.apiKey ?? null
-    this._maxConcurrency = Math.max( 1, config.maxConcurrency ?? config.batchSize ?? 4 )
+    this._maxConcurrency = Math.max( 1, config.maxConcurrency ?? 4 )
     this._gate = new LLMSemaphore( this._maxConcurrency )
     this._timeoutMs = config.timeoutMs ?? 30_000
     this._tokenTracker = config.tokenTracker ?? null

package/src/cognition/percept.entity.ts

@@ -0,0 +1,122 @@
+// ─────────────────────────────────────────────────────────────
+// src/cognition/percept.entity.ts  —  one shape for "something reached me"
+// ─────────────────────────────────────────────────────────────
+//
+// A `percept` entity is the staging area every downstream consumer of afference
+// reads. Five places write one and none of them agreed on what one is:
+//
+//   exteroception       tick ✓  provenance ✓   the complete one
+//   outbox.controller   tick ✗  provenance ✓
+//   escalation.buffer   tick ✓  provenance ✗   (x2)
+//   stem/index.ts       tick ✗  provenance ✗   the wake percept
+//
+// Both omissions are silent and both cost something real:
+//
+//   • NO `tick` — `exteroception._collectStalePerceptIds` is the ONLY sweeper of
+//     this type, and it collects only entities whose `metadata.tick` is a
+//     number. Everything else is immortal. `msg-delivered-<id>` therefore leaks
+//     one entity per message the mind ever successfully sends, and the wake
+//     percept tells the executive "I was offline for 3 hours" for the rest of
+//     the mind's life.
+//   • NO `provenance` — `action.selector`'s rupture gate counts only percepts
+//     tagged `'exafferent'`, so an untagged percept can never rupture a
+//     commitment, exactly as the mind's own echo cannot. A mind waking after
+//     hours offline cannot be ruptured by noticing that.
+//
+// Neither is a bug in the writers. They are a bug in there being no shape to
+// write: every one of them hand-rolled a metadata literal, and a literal cannot
+// forget a field it was never asked for. This is the shape. It makes `tick` and
+// `provenance` REQUIRED, so the sweeper's precondition and the rupture gate's
+// precondition are both structural rather than remembered.
+//
+// SIGNAL_BOUNDARY P0. Own the contract before widening it — the sense door is
+// about to become a sixth writer, and it must not invent a sixth variant.
+
+import type { SignalProvenance } from '#senses/provenance'
+
+export const PERCEPT_TYPE = 'percept'
+
+/**
+ * How long a `percept` survives before `Exteroception` sweeps it. Not a
+ * durability window — a *staging* window. Persistence happens downstream
+ * (WorkingMemory → EpisodicConsolidator → vector); a percept's job is to be
+ * seen once by the faculties that run each tick, then get out of the way.
+ */
+export const PERCEPT_STALE_AFTER_TICKS = 2
+
+/**
+ * How much of a percept's `summary` survives.
+ *
+ * 100 because that is what `exteroception._summarizeEntity` has always used —
+ * adopted rather than chosen, so naming it changes no behaviour. It is now one
+ * constant instead of a literal per writer, which is the point: the sizing
+ * question is real and open (SIGNAL_BOUNDARY §4 asks it of 120/300/700 too, and
+ * notes that none of those was ever a budget decision), and answering it should
+ * be a one-line change in one place rather than an archaeology exercise.
+ */
+export const PERCEPT_SUMMARY_CAP = 100
+
+/** What every percept must say, whatever wrote it. */
+export interface PerceptFacts {
+  /** Deterministic and unique. Never `wallClock()` — this lives in state (R2). */
+  id:         string
+  /** The tick it arrived on. REQUIRED: without it the entity is never swept. */
+  tick:       number
+  /** 0–1. The rupture gate reads this. */
+  salience:   number
+  /** Coarse kind, for grouping — 'message-delivery', 'system', 'undertaking'… */
+  category:   string
+  /** The one field the executive prompt renders. If it is not here, it is unread. */
+  summary:    string
+  /** REQUIRED: untagged means unrupturable. See `SignalProvenance`. */
+  provenance: SignalProvenance
+  /** The intent this is the consequence of, when `provenance` is `'reafferent'`. */
+  sourceIntentId?: string
+  /** The world entity this is about, where there is one. */
+  entityId?:      string
+  /** What happened to it — 'delivered', 'removed', 'changed'… */
+  changeType?:    string
+  /** What it FELT like, and how much that says about it (registry #5). */
+  valence?:       number
+  valenceSource?: string
+  /**
+   * What a host sent, whole. Carried into state so it survives to working
+   * memory, recall and the prompt — `summary` is a label the engine wrote, and
+   * a mind reasoning only from labels is reasoning from somebody else's
+   * conclusions.
+   */
+  data?:          unknown
+}
+
+/** The write-side entity shape `stateManager.setEntity` accepts. */
+export interface PerceptEntity {
+  id:       string
+  type:     typeof PERCEPT_TYPE
+  metadata: Record<string, unknown>
+}
+
+/**
+ * Build a `percept` entity. `extra` carries a writer's own fields (`messageId`,
+ * `facetId`, `offlineMs`…) and cannot overwrite the core: a writer that could
+ * clobber its own `tick` or `provenance` is back where it started.
+ */
+export function perceptEntity( facts: PerceptFacts, extra: Record<string, unknown> = {} ): PerceptEntity {
+  return {
+    id:   facts.id,
+    type: PERCEPT_TYPE,
+    metadata: {
+      ...extra,
+      tick:       facts.tick,
+      salience:   facts.salience,
+      category:   facts.category,
+      summary:    facts.summary,
+      provenance: facts.provenance,
+      ...( facts.sourceIntentId !== undefined ? { sourceIntentId: facts.sourceIntentId } : {} ),
+      ...( facts.entityId       !== undefined ? { entityId:       facts.entityId       } : {} ),
+      ...( facts.changeType     !== undefined ? { changeType:     facts.changeType     } : {} ),
+      ...( facts.valence        !== undefined ? { valence:        facts.valence        } : {} ),
+      ...( facts.valenceSource  !== undefined ? { valenceSource:  facts.valenceSource  } : {} ),
+      ...( facts.data           !== undefined ? { data:           facts.data           } : {} ),
+    },
+  }
+}

package/src/cognition/sense.boundary.ts

@@ -0,0 +1,176 @@
+// ─────────────────────────────────────────────────────────────
+// src/cognition/sense.boundary.ts  —  where I end and the world begins
+// ─────────────────────────────────────────────────────────────
+//
+// A body needs no rule saying "do not see your own premotor cortex." You do not
+// see it because the retina sits ON the boundary and motor planning is inside
+// it. Efference reaches you as a different signal, in a different modality,
+// already marked as yours — which this engine knows: that is what EXAFFERENCE
+// P1/P2 built.
+//
+// Will has no such boundary. Cognition and world share one `state.entities` map,
+// so the mind's own bookkeeping sits in the same place as the things it is
+// bookkeeping ABOUT, and Exteroception — the outward sense — walks the lot.
+//
+// THE COST, MEASURED. A mind booted offline for 300 quiet ticks — no host, no
+// channel, nothing outside it at all — produced 36,721 percepts, every one about
+// itself:
+//
+//     17802  removed            its own affordances being torn down each tick
+//     16950  affordance         its own affordances being rebuilt each tick
+//       546  calibration.state
+//       496  agency.intent
+//       287  agency.outcome
+//       286  agency.skill
+//       135  action.unresolved
+//       120  engine.config      its own configuration
+//        96  attention.demand
+//         3  will.identity      its own identity entity
+//
+// `maxPerceptsPerTick` is 50. The affordance field alone churns ~116 entities a
+// tick, so the sensory cap was consumed by self-noise before the world said
+// anything — and nothing downstream filters by category, so working memory, the
+// novelty detector, the attention allocator and episodic consolidation all ate
+// it. The visible symptom was elsewhere: a fresh Will proceduralized `inspect`
+// to habit 0.64 within fifteen ticks and spent five of its first eight decisions
+// examining its own affordance entities, because a percept-bound act offered
+// against phantom percepts is a real act aimed at nothing.
+//
+// WHY IT DRIFTED. The boundary was a denylist living inside the sense
+// (`internalTypes`), correct for the faculties it shipped beside in v0.1.0 and
+// silently wrong for every entity type invented after. `git log -L` on that
+// block shows two edits in five weeks — EXAFFERENCE P2 and P4 — each adding the
+// one agency type in front of its author at that moment. A hand-kept list is
+// correct for whatever you were last thinking about.
+//
+// THE ASYMMETRY THAT MAKES THIS TRACTABLE. The mind's own types are a CLOSED
+// set: it knows its own anatomy. The world's types are OPEN and unknowable —
+// that is the whole point of a container anything can rent. So enumerate the
+// self, and let everything else be world by default. Openness is preserved
+// exactly where it must be: a host introduces any entity type, any shape, and
+// the mind perceives it, with no act narrowed and no schema gated.
+//
+// Two sources, unioned:
+//   • MIND_OWN_ENTITY_TYPES — the anatomy this package ships.
+//   • each registered engine's `writes` — so a tenant that brings its OWN
+//     cognitive engine declares its own machinery beside the code that writes
+//     it, and gets this right without editing the container.
+//
+// The guard that keeps it true is behavioural, not a source scanner:
+// `sense.boundary.test.ts` boots a mind into an empty world and asserts it
+// perceives nothing. A new engine writing a new undeclared type fails it.
+// ─────────────────────────────────────────────────────────────
+
+import { CONSEQUENCE_TYPE, ENACTED_TYPE } from '#agency/consequence'
+import { AVAILABILITY_ENTITY_TYPE } from '#agency/schemas/repertoire'
+import { REVOCATION_TYPE }  from '#agency/revocation'
+import { SETTLEMENT_TYPE }  from '#agency/settlement'
+import { ACTION_RECORD_TYPE } from '#faculties/executive.engine/action.record'
+
+/**
+ * Entity types that ARE the mind — written by its own engines about its own
+ * operation. Not perceptible: a mind does not encounter its own machinery as an
+ * event in the world.
+ *
+ * Grouped by the faculty that writes them so a reader can check the list
+ * against the anatomy. Everything absent here is world.
+ */
+export const MIND_OWN_ENTITY_TYPES: ReadonlySet<string> = new Set([
+  // ── perception ────────────────────────────────────────────────
+  // Percepts about percepts are the original feedback loop this guarded.
+  'percept', 'percept.social',
+
+  // ── attention, interoception, control ─────────────────────────
+  'interoception', 'attention.focus', 'attention.demand',
+  'task.focus', 'decision.record', 'self_observation',
+  // What became of what it did. Undeclared, a mind perceives its own history as
+  // events in the world — which is how #127 was caught, recursively.
+  ACTION_RECORD_TYPE,
+
+  // ── memory ────────────────────────────────────────────────────
+  'working_memory.item', 'episodic_memory', 'spaced_repetition_record',
+  'belief', 'belief.integrate',
+
+  // ── deliberative structure ────────────────────────────────────
+  'goal', 'plan', 'plan.prior',
+
+  // ── narrative + metacognition ─────────────────────────────────
+  'narrative_chapter', 'introspection', 'self_narrative', 'cognitive_bias',
+  'calibration.state', 'executive.summary', 'executive.cache',
+
+  // ── affect + social models ────────────────────────────────────
+  // A dossier is the mind's record OF someone, not the someone. The person
+  // arrives through audition and social perception; the dossier is what the
+  // mind then holds about them, and re-perceiving it double-counts.
+  'affect.blends', 'empathic_state', 'attachment.bond',
+  'theory_of_mind', 'reputation',
+  'known-entity', 'known-entity-alias',
+
+  // ── conversation records ──────────────────────────────────────
+  // SocialPerception is the sense that owns these (it reads
+  // `conversation.received` and emits `percept.social` from it, then sweeps it).
+  // Exteroception perceiving them too was the same turn counted twice.
+  'conversation.received', 'conversation.sent',
+
+  // ── agency ────────────────────────────────────────────────────
+  // The whole pipeline: the field it synthesizes, what it committed to, what
+  // came back, what it learned, and what it merely imagined.
+  'affordance', 'agency.intent', 'agency.outcome', 'agency.skill',
+  'agency.schema', 'ideomotor.intent',
+  // What it HAS DONE — the enaction footprint satiation reads to know it has
+  // already tried this. Undeclared, it was the loudest thing in the mind's
+  // perceptual field: measured on a live Will, `New agency.enacted: agency-
+  // enacted-discord_lookup_…` sat at salience 0.5, ABOVE every real percept,
+  // and each enaction produced two of them — one when the record appeared, one
+  // when the retention sweep removed it. A mind watching its own footprints
+  // being laid down and swept away, and calling that the world.
+  ENACTED_TYPE,
+  // What it may currently do, and why not. The availability ledger is empty
+  // until a refusal lands (POLICY_REAFFERENCE P2), which is exactly why nothing
+  // caught it: a mind that has never been told no writes none of these, so the
+  // quiet path and every test that stays on it are blind to the omission. Give
+  // a Will a PolicyArbiter that refuses, and it starts perceiving its own
+  // permissions changing as events in the world.
+  AVAILABILITY_ENTITY_TYPE,
+  'action.unresolved', 'action.unaddressed',
+  CONSEQUENCE_TYPE,   // forward-model records  (EXAFFERENCE P1/P2)
+  REVOCATION_TYPE,    // commitment tombstones  (EXAFFERENCE P4)
+  SETTLEMENT_TYPE,    // verdicts System 2 reached — having thought about it
+
+  // ── substrate ─────────────────────────────────────────────────
+  // Its configuration and its identity are constitutive of it, not events in
+  // its world. It had been perceiving both.
+  'engine.config', 'will.identity', 'effector.created',
+  'dream.activity',
+])
+
+/** An engine that declares the entity types it writes about the mind itself. */
+export interface DeclaresWrites {
+  /**
+   * Entity types this engine writes as part of the mind's own operation.
+   *
+   * Declare here anything the mind should NOT re-encounter through its outward
+   * senses. Omit it for engines that write about the WORLD — a host engine
+   * maintaining rooms, documents, or sensor readings wants those perceived, and
+   * silence is the right default for them.
+   */
+  readonly writes?: readonly string[]
+}
+
+/**
+ * The full endogenous set for a given assembly: the shipped anatomy plus
+ * whatever the registered engines declare.
+ *
+ * Cheap enough to call per tick, but Exteroception memoizes on the engine list
+ * so a 50-engine union isn't rebuilt in the perceptual hot path.
+ */
+export function endogenousTypes( engines: readonly DeclaresWrites[] ): ReadonlySet<string> {
+  let extra: Set<string> | null = null
+  for( const e of engines )
+    for( const t of e.writes ?? [] )
+      if( !MIND_OWN_ENTITY_TYPES.has( t ) )
+        ( extra ??= new Set() ).add( t )
+
+  if( !extra ) return MIND_OWN_ENTITY_TYPES
+  return new Set([ ...MIND_OWN_ENTITY_TYPES, ...extra ])
+}