@mindot/will 0.9.0 → 0.10.0

package/src/cognition/faculties/executive.engine/prompt.factory.ts

@@ -116,6 +116,100 @@ export function traitEmphasis( value: number ): TraitEmphasis | null {
 // low" yet "above my norm" (low overall, but high for me lately).
 const TRAIT_NORM_BAND = 0.12  // deviation from personal baseline to read as above/below my norm
 
+/**
+ * One percept, as the mind reads it: the engine's LABEL, and beneath it the
+ * EVIDENCE the host actually sent.
+ *
+ * The whole line is one unit on purpose. Rendering the label and the data
+ * separately let a mutation that dropped the data from the call site pass every
+ * test — the data renderer stayed correct while the prompt stopped showing it,
+ * which is exactly the state this fix exists to leave behind. Same lesson as
+ * `temporalLine`.
+ */
+export function perceptLine(
+  p: { category: string; summary: string; salience: number; data?: unknown },
+): string {
+  return `- [${ p.category }] ${ p.summary } (salience: ${ p.salience.toFixed( 2 ) })${ perceptData( p.data ) }`
+}
+
+/**
+ * One working-memory item, as the mind reads it — label, then evidence.
+ *
+ * A sibling of `perceptLine` and a unit for the same reason: rendering the data
+ * inline let a mutation that dropped it pass every test. A percept entity is
+ * swept after 2 ticks and the executive fires on its own schedule, so MEMORY is
+ * often where a mind actually meets an observation — dropping the evidence here
+ * loses it just as completely as never storing it, one step later.
+ */
+export function ruminationLine(
+  w: { type: string; summary: string; activation: number; data?: unknown },
+): string {
+  return `- [${ w.type }] ${ w.summary } (activation: ${ w.activation.toFixed( 2 ) })${ perceptData( w.data ) }`
+}
+
+/**
+ * A percept's own data, rendered under its label — what the host actually sent.
+ *
+ * The label is the engine's words about the signal; this is the evidence. A mind
+ * that only ever sees labels is being handed conclusions, and the whole job of a
+ * mind is to make meaning by connecting pieces of information it can see.
+ *
+ * Indented on its own line rather than inlined: it can be long, and a host is
+ * explicitly not asked to keep it short — what it sent is what it sent.
+ */
+function perceptData( data: unknown ): string {
+  if( data === undefined || data === null ) return ''
+  if( typeof data === 'string') return data.length > 0 ? `\n    ${ data }` : ''
+
+  try {
+    // A host's own `summary`, when it offered one, is already the label on the
+    // line above. Repeating it underneath is noise, and noise in a percept is
+    // not free — it is read every tick the percept is alive. NOT reshaping: the
+    // stored data keeps every field, this only declines to print one twice.
+    const shown = Array.isArray( data )
+      ? data
+      : Object.fromEntries( Object.entries( data as Record<string, unknown> ).filter( ( [ k ] ) => k !== 'summary') )
+    const json = JSON.stringify( shown )
+    return json === '{}' || json === '[]' ? '' : `\n    ${ json }`
+  }
+  catch { return '' }
+}
+
+/**
+ * What a phase of the cycle is CALLED, in the words a mind would use.
+ *
+ * NOT the clock. The hour this is computed from is the oscillator's own — free-
+ * running from the tick unless a host entrains it — so it is what the BODY
+ * reads, which is a different claim from what time it is. A jet-lagged body
+ * says night at noon and is not lying; it is reporting itself.
+ *
+ * The prompt used to render the raw hour beside this, and the two disagreed on
+ * every tick of every Will ever run (`Time: 12.0h (night)`). The hour is gone
+ * from the prompt entirely now: it is a fact about the world, and a fact about
+ * the world is something a mind goes and gets — see the `check-time` schema.
+ */
+export function temporalLine( timeOfDay: number, circadian: number ): string {
+  return `Body rhythm: it feels like ${ labelForHour( timeOfDay ) } to me`
+       + ` (my own cycle, not a clock — I use \`check-time\` to find out the actual hour).`
+       + ` Circadian phase: ${ circadian.toFixed( 2 ) }.`
+}
+
+/**
+ * The label, from the hour. Kept separate from `temporalLine` only so the bands
+ * are readable; nothing outside this file should need it.
+ */
+export function labelForHour( h: number ): string {
+  const hour = ( ( h % 24 ) + 24 ) % 24
+  return hour <  2 ? 'deep night'
+       : hour <  5 ? 'late night'
+       : hour <  8 ? 'early morning'
+       : hour < 11 ? 'morning'
+       : hour < 14 ? 'midday'
+       : hour < 17 ? 'afternoon'
+       : hour < 21 ? 'evening'
+       : 'night'
+}
+
 export function normEmphasis( value: number, mean: number ): 'above' | 'below' | null {
   const d = value - mean
   if( d >=  TRAIT_NORM_BAND ) return 'above'
@@ -270,7 +364,15 @@ export interface PromptBuildOptions {
    * how one mind ends up opening a second conversation with someone it is already
    * talking to — or telling one person it has contacted another when it has not.
    */
-  activeConversations?: { entityId: string; name?: string; sinceTick: number }[]
+  activeConversations?: {
+    entityId: string
+    name?: string
+    sinceTick: number
+    /** What the mind worked out in that thread — its own reasoning, come back. */
+    concluded?: string
+    /** Commitments it made there toward someone NOT in the thread. */
+    promised?: Array<{ what: string; target?: string; gist?: string; tick: number }>
+  }[]
 }
 
 // ── PromptFactory ────────────────────────────────────────────
@@ -616,16 +718,6 @@ completionType guide:
     const timeOfDay     = context.worldState.timeOfDay
     const threatLevel   = context.worldState.threatLevel
 
-    // Map raw circadian phase (0–1) to a human-readable label for full temporal awareness.
-    // 0 = midnight, 0.5 = noon, 1 = midnight.
-    const phaseLabel = circadian < 0.083 ? 'deep night'
-                     : circadian < 0.208 ? 'late night'
-                     : circadian < 0.333 ? 'early morning'
-                     : circadian < 0.458 ? 'morning'
-                     : circadian < 0.583 ? 'midday'
-                     : circadian < 0.708 ? 'afternoon'
-                     : circadian < 0.833 ? 'evening'
-                     : 'night'
 
     const energyGuidance = this._buildEnergyGuidance( energy )
     const stressGuidance = this._buildStressGuidance( stress )
@@ -676,7 +768,7 @@ completionType guide:
 Energy: ${energy.toFixed( 1 )}/100
 Sleep Pressure: ${sleepPressure.toFixed( 1 )}/100
 Stress: ${stress.toFixed( 1 )}/100${threatLine}
-Time: ${timeOfDay.toFixed( 1 )}h (${phaseLabel}, circadian: ${circadian.toFixed( 2 )})
+${temporalLine( timeOfDay, circadian )}
 Cognitive capacity:${capacityNote}
 Epistemic uncertainty: ${( epistemicUncertainty * 100 ).toFixed( 0 )}%${uncertaintyLabel}
 Tick: ${state.tick}
@@ -721,7 +813,7 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       : ''
 
     const perceptsBlock = has('percepts')
-      ? `## Percepts (What I Notice)\n${context.percepts.slice( 0, 10 ).map( p => `- [${p.category}] ${p.summary} (salience: ${p.salience.toFixed( 2 )})`).join('\n') || 'Nothing notable'}`
+      ? `## Percepts (What I Notice)\n${context.percepts.slice( 0, 10 ).map( perceptLine ).join('\n') || 'Nothing notable'}`
       : ''
 
     // Host abilities afforded right now + what each is for. Framed as
@@ -734,7 +826,7 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       : ''
 
     const ruminationsBlock = has('ruminations')
-      ? `## Active Ruminations (retrieved memories & thoughts)\n${context.workingMemory.map( w => `- [${w.type}] ${w.summary} (activation: ${w.activation.toFixed( 2 )})`).join('\n') || 'Nothing actively held in mind'}`
+      ? `## Active Ruminations (retrieved memories & thoughts)\n${context.workingMemory.map( ruminationLine ).join('\n') || 'Nothing actively held in mind'}`
       : ''
 
     const memoriesBlock = has('memories')
@@ -787,10 +879,33 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
     // can hold several conversations as one situation rather than as N strangers.
     // Names come from what the mind has actually learned; the id is shown because
     // that is what a reach-out must be addressed to.
+    // WHAT I worked out there, not only WHO I am with.
+    //
+    // `executive.facet.sync` has always carried the facet's full reasoning and the
+    // master discarded it, so the return leg of the loop was empty: my thinking
+    // went down to a facet as "What I've Been Turning Over" and came back as a
+    // name. A facet is this same mind with a focus — reading back what it worked
+    // out is not a report from a subordinate, it is remembering where my attention
+    // has been. First person throughout, for that reason.
+    //
+    // A promise made in one thread to someone NOT in it is stated as the plain
+    // fact it is. There is deliberately no instruction about it: whether to keep
+    // it, drop it, or make a goal of it is mine to decide, and I have a whole
+    // faculty for that.
     const conversationsBlock = ( options.mode !== 'facet' && options.activeConversations?.length )
-      ? `## In Conversation Now\n${options.activeConversations.map( c =>
-          `- ${c.name ?? 'someone'} (id: ${c.entityId})`
-        ).join('\n')}\nThese threads are already open — I am in them. Reaching out to one of these people again starts a second, parallel thread with them.`
+      ? `## In Conversation Now\n${options.activeConversations.map( c => {
+          const who       = `- ${c.name ?? 'someone'} (id: ${c.entityId})`
+          const concluded = c.concluded ? `\n    What I worked out there: ${c.concluded.trim()}` : ''
+          const promised  = ( c.promised ?? [] ).map( p =>
+            `\n    I said there that I would ${p.what}${ p.gist ? ` — about: "${p.gist}"` : '' }`
+            + `, at tick ${p.tick}.`
+            // Only a CONTACT can be mistaken for already done by having been
+            // said, which is the confusion this clause exists to break. A
+            // promise about work carries no such ambiguity and gets no lecture.
+            + ( p.target ? ' Saying it in that thread did not send it.' : '')
+          ).join('')
+          return `${who}${concluded}${promised}`
+        } ).join('\n')}\nThese threads are already open — I am in them. Reaching out to one of these people again starts a second, parallel thread with them.`
       : ''
 
     // Task focus — what the Will is committed to and the felt cost of switching away.
@@ -997,6 +1112,13 @@ Rest and sleep RESTORE energy. All other actions CONSUME energy. Do not let ener
    */
 
 
+  /**
+   * What the mind has been CHOOSING lately — action types, for the variety
+   * check. Not a history of what happened: nothing here says an act landed.
+   * Retitled from `## Recent Actions` at P3 for exactly that reason (see
+   * `_buildRecentOutcomesSection`) — it sat beside a real history under a name
+   * that claimed to be one.
+   */
   private static _buildActionDiversitySection( recentActionTypes: string[] ): string {
     if( recentActionTypes.length === 0 ) return ''
 
@@ -1006,14 +1128,27 @@ Rest and sleep RESTORE energy. All other actions CONSUME energy. Do not let ener
       ? `\n⚠️ **Action variety alert**: "${recent.filter( t => t === 'reflect' || t === 'observe').join('", "')}" dominated my last ${recent.length} cycles. Choose something DIFFERENT this cycle — e.g. learn, express_emotion, explore, communicate, set_goal, or rest.`
       : ''
 
-    return `## Recent Actions (last ${recent.length})
+    return `## What I Have Been Choosing (last ${recent.length})
 ${recent.map( ( t, i ) => `${i + 1}. ${t}`).join(' → ')}${warning}
 
 `
   }
 
   /**
-   * Render the recent action outcomes section — closes the Act→Confirm→Perceive loop.
+   * Render what became of what the mind did — closes the Act→Confirm→Sense loop.
+   *
+   * NAMED FOR WHAT IT RENDERS (SIGNAL_BOUNDARY P3). It was `## Recent Action
+   * Outcomes`, which named the `action.outcome` BUS EVENT — a different shape
+   * this section never touches. It renders `action.record` entities: what became
+   * of acts the mind actually took. Meanwhile the section two above it,
+   * `## Recent Actions`, listed action TYPES THE MIND CHOSE — a list of
+   * intentions wearing the name of a history, directly beside a history.
+   *
+   * A mind that cannot tell those two apart cannot tell an intention from an
+   * act, and one live COO could not: asked "have you completed that?", she said
+   * "Yes — it's done", having posted nothing and having no effectors at all. The
+   * section titles are the mind's own labels for its own memory; they are not
+   * decoration.
    * Shows the executive what it tried, whether it landed, and if anything timed out.
    * Only rendered when there are status-bearing action records in state.
    */
@@ -1114,6 +1249,9 @@ ${recent.map( ( t, i ) => `${i + 1}. ${t}`).join(' → ')}${warning}
     const STATUS_BADGE: Record<string, string> = {
       completed:    '✓',
       failed:       '✗',
+      // Not a failure. I formed it and chose not to complete it — reading that
+      // back as ✗ is how a mind learns it is bad at something it decided against.
+      withheld:     '⊘ chose not to',
       awaiting_host: '⏳',
       timed_out:    '⏱ TIMED OUT',
     }
@@ -1126,12 +1264,19 @@ ${recent.map( ( t, i ) => `${i + 1}. ${t}`).join(' → ')}${warning}
       return `- ${badge} **${a.type}** (tick ${a.tick}, ${age} ticks ago${planCtx})${outcome}`
     } )
 
-    const hasTimeout = recentActions.some( a => a.status === 'timed_out')
-    const timeoutNote = hasTimeout
-      ? '\n⚠️ **One or more actions timed out** — my body dispatched them but received no confirmation. Check if the external handler is working, or choose a different approach.'
+    // A note that can actually fire. The one here before keyed on a `timed_out`
+    // status nothing produces — and it sat inside a section that had never
+    // rendered at all, so neither could ever have been seen.
+    const failed = recentActions.filter( a => a.status === 'failed').length
+    const didNotLand = failed > 0
+      ? `\n⚠️ **${ failed } of these did not land** — my body attempted them and they did not complete.`
       : ''
+    // Invariant, and identical on every branch: this is the sentence that makes
+    // the section load-bearing rather than decorative, and a mind must not get a
+    // differently-worded version of it depending on how its week went.
+    const note = `${ didNotLand }\nThis is what I HAVE done, not what I meant to do. If something I intended is not on this list, it did not happen.`
 
-    return `## Recent Action Outcomes\n${lines.join('\n')}${timeoutNote}\n\n`
+    return `## What Became Of What I Did\n${lines.join('\n')}${note}\n\n`
   }
 
   /**

package/src/cognition/faculties/executive.engine/types.ts

@@ -96,15 +96,6 @@ export interface ExecutiveOutputFull {
    * Present ⇒ nothing is sent, whatever else the response contains.
    */
   noMessage?: string
-  /**
-   * @deprecated Legacy JSON reply format — no longer emitted by conversation facets.
-   * Kept for backward compatibility with any tests/tooling that inspect parsed output.
-   */
-  conversationReplies?: Array<{
-    targetEntityId: string
-    targetEntityName: string
-    messages: string[]
-  }>
   /**
    * System 2 only — the distinct approaches the master generated and weighed before
    * committing, retained for explainability/auditability (and a future regret /
@@ -254,8 +245,11 @@ export interface ExecutiveContext {
   relevantPlanIds: string[]
   percepts: Array<{
     category: string
+    /** The engine's label for the signal. */
     summary: string
     salience: number
+    /** What the host actually sent, whole — the evidence under the label. */
+    data?: unknown
   }>
   /**
    * Host-declared abilities afforded to the Will *right now* — what it can do in
@@ -272,8 +266,11 @@ export interface ExecutiveContext {
   }>
   workingMemory: Array<{
     type: string
+    /** The engine's label for the item. */
     summary: string
     activation: number
+    /** What a host sent, whole — carried through memory, not only into it. */
+    data?: unknown
   }>
   memories: Array<{
     content: string
@@ -290,15 +287,21 @@ export interface ExecutiveContext {
   /** How many beliefs exist but were not included due to the relevance cap. */
   beliefsOmitted: number
   /**
-   * Recent action outcomes — shows the executive what it already tried and whether it
-   * landed.  Built from `decision.record` entities with an `actionStatus` set.
-   * Surfaces the Act→Confirm→Perceive feedback loop into the executive's reasoning.
+   * What became of what it did — the Act→Confirm→Perceive loop, surfaced.
+   *
+   * Built from `action.record` entities the executive writes from the
+   * `action.outcome` / `action.withheld` events it already receives. It used to
+   * be built from `decision.record` entities carrying an `actionStatus`, a field
+   * read in one place and written in none — so this was empty in every prompt a
+   * live mind ever received, and it could see what it had SAID but never what it
+   * had DONE. See `action.record.ts`.
    */
   recentActions: Array<{
     /** Effector name that was invoked */
     type: string
-    /** Lifecycle status set by ActionExecutor */
-    status: 'completed' | 'failed' | 'awaiting_host' | 'timed_out'
+    /** How it resolved. `withheld` is distinct from `failed` on purpose: the
+     *  mind formed the act and chose not to complete it. */
+    status: 'completed' | 'failed' | 'withheld'
     /** Tick the action was executed or dispatched */
     tick: number
     /** Short outcome description — truncated to 120 chars */
@@ -312,7 +315,7 @@ export interface ExecutiveContext {
    * The one thing it could never see about itself. `conversation.sent` has been in
    * state since the beginning — 57 records on the Will this was found on — and
    * reached no prompt at all, so the sole evidence of having spoken was a `✓
-   * reach-out` line under Recent Action Outcomes: no words, no person, and a tick
+   * reach-out` line under What Became Of What I Did: no words, no person, and a tick
    * mark asserting it had worked. That is why the same question went out eleven
    * times in two and a half minutes; from the inside each one was the first.
    *

package/src/cognition/faculties/exteroception.ts

@@ -24,18 +24,18 @@ import type {
   SimulationContext,
   ReadonlySimulationState,
   StateCommands,
-  SimulationEvent,
   SimulationEntity,
 } from '#core/types'
 import type { SimulationEngine, EngineResult, CognitiveEngine } from '#cognition/types'
 import type { CognitiveEventSchema } from '#cognition/schema.registry'
 import type { CognitiveEvent, CognitiveBus } from '#cognition/bus'
+import { perceptEntity, PERCEPT_SUMMARY_CAP } from '#cognition/percept.entity'
 import { GenerativeModel } from '#cognition/generative.model'
 import {
-  CONSEQUENCE_TYPE, ATTENUATION, CORRESPONDENCE_ATTENUATION,
+  ATTENUATION, CORRESPONDENCE_ATTENUATION,
   liveConsequences, matchConsequenceText, matchConsequenceEntity,
 } from '#agency/consequence'
-import { REVOCATION_TYPE } from '#agency/revocation'
+import { MIND_OWN_ENTITY_TYPES } from '#cognition/sense.boundary'
 
 export interface ExteroceptionConfig {
   /** Maximum percepts to produce per tick */
@@ -43,9 +43,18 @@ export interface ExteroceptionConfig {
   /** Default salience for unmarked percepts */
   defaultSalience?: number
   /** Whether to emit percept events */
-  emitPerceptEvents?: boolean
   /** Entity types to always treat as high-salience */
   highPriorityTypes?: string[]
+  /**
+   * Where this mind ends — the entity types its own engines write about its own
+   * operation, which it therefore cannot encounter as world events. Live, so a
+   * host adding a cognitive engine after assembly is accounted for.
+   *
+   * Unwired (a bare harness, a unit test) it falls back to the shipped anatomy,
+   * which is right for every assembly that adds no cognitive engine of its own.
+   * See `#cognition/sense.boundary`.
+   */
+  endogenous?: () => ReadonlySet<string>
   bus?: CognitiveBus
 }
 
@@ -63,51 +72,60 @@ interface RawPercept {
   valenceSource?: 'entity' | 'ambient'
 }
 
-// Skip internal entities — they're not external percepts.
-// Percepts about percepts create a feedback loop that floods
-// working memory and episodic storage with noise.
-const internalTypes = new Set([
-  'percept', 'percept.social', 'working_memory.item',
-  'interoception', 'attention.focus', 'decision.record',
-  'task.focus', 'self_observation',
-  'goal', 'belief', 'plan', 'narrative_chapter',
-  'introspection', 'self_narrative', 'cognitive_bias',
-  'effector.created', 'empathic_state', 'attachment.bond',
-  'theory_of_mind', 'reputation', 'episodic_memory',
-  // Internal state entities written by our own engines — not external events
-  'affect.blends', 'executive.summary',
-  // The agency's own forward-model records (EXAFFERENCE P1/P2): perceiving our
-  // expected-consequence descriptors would be a self-noise loop.
-  CONSEQUENCE_TYPE,
-  // The agency's own revocation tombstones (EXAFFERENCE P4) — internal bookkeeping.
-  REVOCATION_TYPE,
-])
-
 export class Exteroception implements SimulationEngine, CognitiveEngine {
   readonly name     = 'exteroception'
   
   private _maxPerceptsPerTick: number
   private _defaultSalience: number
-  private _emitPerceptEvents: boolean
   private _highPriorityTypes: Set<string>
-  private _previousEntityVersions = new Map<string, number>()  // entityId → updatedAt
+  /**
+   * entityId → what was last seen of it. The TYPE is remembered alongside the
+   * version because a removal has to answer the same question an appearance
+   * does — "was this mine?" — and by then the entity is gone. It used to be
+   * answered by a second, separately-drifting list of id prefixes.
+   */
+  private _previousEntityVersions = new Map<string, { at: Timestamp; type: string }>()
 
   private _bus: CognitiveBus | null = null
 
   private readonly _model    = new GenerativeModel()
 
+  /** Live sense boundary + a memo, so a 50-engine union isn't rebuilt per tick. */
+  private _boundary: ( () => ReadonlySet<string> ) | null
+  private _endogenousMemo: ReadonlySet<string> = MIND_OWN_ENTITY_TYPES
+
 
   constructor( config: ExteroceptionConfig = {} ){
     this._bus = config.bus ?? null
+    this._boundary = config.endogenous ?? null
     this._maxPerceptsPerTick = config.maxPerceptsPerTick ?? 50
     this._defaultSalience    = config.defaultSalience    ?? 0.3
-    this._emitPerceptEvents  = config.emitPerceptEvents  ?? true
     this._highPriorityTypes  = new Set( config.highPriorityTypes ?? [
       'message', 'notification', 'alert', 'threat', 'goal',
     ])
   }
   attachBus( bus: CognitiveBus ): void { this._bus = bus }
 
+  /**
+   * Wire the live sense boundary. Separate from construction because the
+   * boundary is derived from the assembled engine list, and this sense is
+   * constructed before that list exists (same reason `attachBus` exists).
+   */
+  attachBoundary( resolve: () => ReadonlySet<string> ): void { this._boundary = resolve }
+
+  /**
+   * The types that are THIS mind rather than its world.
+   *
+   * Re-read each tick so a host engine registered after assembly still lands
+   * inside the boundary; the memo makes that a set-identity check in the common
+   * case, since `endogenousTypes` returns the shipped set unchanged when nothing
+   * extra is declared.
+   */
+  private _endogenous(): ReadonlySet<string> {
+    if( this._boundary ) this._endogenousMemo = this._boundary()
+    return this._endogenousMemo
+  }
+
   // ── Engine interface ─────────────────────────────────────
 
   subscribes(): string[] { return ['executive.prediction.formed'] }
@@ -132,9 +150,7 @@ export class Exteroception implements SimulationEngine, CognitiveEngine {
     state: ReadonlySimulationState,
     context: SimulationContext
   ): Promise<EngineResult> {
-    const
-    events:   Array<Omit<SimulationEvent, 'id' | 'timestamp' | 'tick'>> = [],
-    commands: StateCommands = { set: [], delete: [], metrics: [] }
+    const commands: StateCommands = { set: [], delete: [], metrics: [] }
 
     const rawPercepts = this._scanWorld( state )
 
@@ -168,37 +184,27 @@ export class Exteroception implements SimulationEngine, CognitiveEngine {
         : entityHit ? rp.salience * CORRESPONDENCE_ATTENUATION
         : rp.salience
 
-      const perceptEntity = {
-        id: `percept-${tick}-${i}`,
-        type: 'percept',
-        metadata: {
-          entityId: rp.entityId,
-          changeType: rp.changeType,
-          salience,
-          category: rp.category,
-          summary: rp.summary,
-          provenance: hit ? 'reafferent' : 'exafferent',
-          ...( hit ? { sourceIntentId: hit.intentId } : {} ),
-          // affect→percept seam (registry #5): what this percept FEELS like
-          ...( rp.valence !== undefined ? { valence: rp.valence, valenceSource: rp.valenceSource } : {} ),
-          tick,
-        },
-      }
-
-      commands.set!.push( perceptEntity )
-
-      // Emit percept event for downstream engines
-      if( this._emitPerceptEvents )
-        events.push({
-          type: `percept.${rp.changeType}.${rp.category}`,
-          source: this.name,
-          payload: {
-            entityId: rp.entityId,
-            salience,
-            category: rp.category,
-            summary: rp.summary,
-          },
-        })
+      // Through the shared constructor (SIGNAL_BOUNDARY P0) rather than a
+      // hand-rolled literal. A no-op here — this writer already set every core
+      // field — which is exactly why it is the one that proves the shape: four
+      // other writers reach it having each forgotten a different one.
+      //
+      // `provenance` is INFERRED here, legitimately: a match against our own
+      // live consequence descriptors is the efference copy doing its job. The
+      // sense door asserts instead, because it has nothing to match against.
+      commands.set!.push( perceptEntity( {
+        id:         `percept-${tick}-${i}`,
+        tick,
+        salience,
+        category:   rp.category,
+        summary:    rp.summary,
+        provenance: hit ? 'reafferent' : 'exafferent',
+        entityId:   rp.entityId,
+        changeType: rp.changeType,
+        ...( hit ? { sourceIntentId: hit.intentId } : {} ),
+        // affect→percept seam (registry #5): what this percept FEELS like
+        ...( rp.valence !== undefined ? { valence: rp.valence, valenceSource: rp.valenceSource } : {} ),
+      } ) )
     }
 
     // Clean up old percepts from previous ticks (keep last 2 ticks of percepts)
@@ -211,13 +217,12 @@ export class Exteroception implements SimulationEngine, CognitiveEngine {
     )
 
 
-    // Phase C + F: publish cognitive event — gated by prediction error
+    // The percept RATE is still learned — `percept.rate` carries a precision set
+    // from `executive.prediction.formed`, and the observation is what keeps that
+    // baseline honest. What is gone is the `percept.batch.ingested` event it used
+    // to publish: one publisher, zero subscribers, ever.
     const _bus = this._bus
-    if( _bus && capped.length > 0 ){
-      const predErr = this._model.observe('percept.rate', capped.length )
-      if( !predErr.gated )
-        _bus.publish({ type: 'percept.batch.ingested', version: 1, sourceEngine: this.name, salience: Math.max( 0.2, predErr.salience ), payload: { count: capped.length } })
-    }
+    if( capped.length > 0 ) this._model.observe('percept.rate', capped.length )
 
     // percept.category.updated — one event per distinct category so subscribers
     // (aesthetic.evaluator etc.) get a structured signal without scanning percepts
@@ -229,7 +234,7 @@ export class Exteroception implements SimulationEngine, CognitiveEngine {
         _bus.publish({ type: 'percept.category.updated', version: 1, sourceEngine: this.name, salience: Math.min( 1, count * 0.15 + 0.2 ), payload: { category, count } })
     }
 
-    return { events: events.length > 0 ? events : undefined, commands }
+    return { commands }
   }
 
   // ── Internal ─────────────────────────────────────────────
@@ -243,18 +248,19 @@ export class Exteroception implements SimulationEngine, CognitiveEngine {
 private _scanWorld( state: ReadonlySimulationState ): RawPercept[] {
     const percepts: RawPercept[] = []
     const currentIds = new Set<string>()
+    const mine       = this._endogenous()
 
     for( const [ id, entity ] of state.entities ){
       currentIds.add( id )
 
-      if( internalTypes.has( entity.type ) ){
-        // Still track the version so we don't get "appeared" events
-        // when these internal entities are first created
-        this._previousEntityVersions.set( id, entity.updatedAt )
+      if( mine.has( entity.type ) ){
+        // Still track it, so it never reads as "appeared" if the boundary later
+        // widens — but it is machinery, not world, and is not perceived.
+        this._previousEntityVersions.set( id, { at: entity.updatedAt, type: entity.type } )
         continue
       }
 
-      const previousVersion = this._previousEntityVersions.get( id )
+      const previousVersion = this._previousEntityVersions.get( id )?.at
 
       if( previousVersion === undefined ){
         percepts.push({
@@ -279,32 +285,27 @@ private _scanWorld( state: ReadonlySimulationState ): RawPercept[] {
         })
       }
 
-      this._previousEntityVersions.set( id, entity.updatedAt )
+      this._previousEntityVersions.set( id, { at: entity.updatedAt, type: entity.type } )
     }
 
-    // Detect removed entities (not internal types)
-    for( const [ id ] of this._previousEntityVersions ){
-      if( !currentIds.has( id ) ){
-        // Only report removal of meaningful entities
-        // We can't check the type here since the entity is gone,
-        // but we can infer from the ID prefix
-        if( !id.startsWith('percept-') 
-            && !id.startsWith('wm-')
-            && !id.startsWith('attention-')
-            && !id.startsWith('decision-')
-            && !id.startsWith('interoception-')
-            && !id.startsWith('task-')
-            && !id.startsWith('self-obs-') ){
-          percepts.push({
-            entityId: id,
-            changeType: 'removed',
-            salience: 0.4,
-            category: 'removed',
-            summary: `Entity removed: ${id}`,
-          })
-        }
-        this._previousEntityVersions.delete( id )
-      }
+    // Something that was there is gone. The same question as an appearance —
+    // was it mine or the world's? — and answerable now because the remembered
+    // type outlives the entity. It used to be guessed from a handful of id
+    // prefixes, which is why 17,802 of one quiet run's 36,721 percepts were the
+    // mind watching its own affordance field be torn down each tick.
+    for( const [ id, seen ] of this._previousEntityVersions ){
+      if( currentIds.has( id ) ) continue
+
+      if( !mine.has( seen.type ) )
+        percepts.push({
+          entityId: id,
+          changeType: 'removed',
+          salience: 0.4,
+          category: 'removed',
+          summary: `Entity removed: ${id}`,
+        })
+
+      this._previousEntityVersions.delete( id )
     }
 
     percepts.sort( ( a, b ) => b.salience - a.salience )
@@ -374,7 +375,7 @@ private _scanWorld( state: ReadonlySimulationState ): RawPercept[] {
         ? `${name} appears` : `${name} changed`
     }
     if( description ){
-      return description.slice( 0, 100 )
+      return description.slice( 0, PERCEPT_SUMMARY_CAP )
     }
 
     return `New ${entity.type}: ${entity.id.slice(0, 30)}`