@mindot/will 0.4.0 → 0.6.0

package/src/cognition/agency/engines/deliberation.engine.ts

@@ -30,6 +30,7 @@ import type {
 import type { CognitiveBus } from '#cognition/bus'
 import type { CognitiveEngine, EngineResult } from '#cognition/types'
 import type { CognitiveEventSchema } from '#cognition/schema.registry'
+import { revokedIntentIds, revocationId } from '#agency/revocation'
 
 // ── Minimal structural view of the executive's facet machinery ───────────────
 // Kept structural (not an import of the executive engine) so the agency module
@@ -42,7 +43,7 @@ interface DeliberationFacetHandle {
   destroy(): void
 }
 export interface DeliberationFacetProvider {
-  spawnFacet( role?: 'deliberation' ): { attention: 'available' | 'full'; handle?: DeliberationFacetHandle }
+  spawnFacet( role?: 'deliberation'): { attention: 'available' | 'full'; handle?: DeliberationFacetHandle }
 }
 
 interface Candidate {
@@ -92,15 +93,23 @@ export class DeliberationEngine implements CognitiveEngine {
     state:    ReadonlySimulationState,
     _context: SimulationContext,
   ): Promise<EngineResult> {
+    // Honor commitment revocations first (EXAFFERENCE P4): a `deliberating`
+    // intent under a live tombstone is dropped — the world ruptured hard enough
+    // to let go of it — and the tombstone with it. We never deliberate a
+    // revoked intent.
+    const revoked = revokedIntentIds( state.entities, tick )
+    const del: string[] = []
+
     // One deliberation per tick (the serial bottleneck).
     let target: { id: string; meta: Record<string, unknown> } | null = null
     for( const [ id, e ] of state.entities ){
-      if( e.type !== 'agency.intent' ) continue
-      if( str( e.metadata?.['status'] ) !== 'deliberating' ) continue
+      if( e.type !== 'agency.intent') continue
+      if( str( e.metadata?.['status'] ) !== 'deliberating') continue
+      if( revoked.has( id ) ){ del.push( id, revocationId( id ) ); continue }   // revoked → drop
       const meta = ( e.metadata ?? {} ) as Record<string, unknown>
       if( !target || id < target.id ) target = { id, meta }   // stable pick
     }
-    if( !target ) return { commands: {} }
+    if( !target ) return del.length > 0 ? { commands: { delete: del } } : { commands: {} }
 
     const { id, meta }   = target
     const provisional    = str( meta['schema'] ) ?? 'wait'
@@ -108,7 +117,8 @@ export class DeliberationEngine implements CognitiveEngine {
 
     // No executive → confirm the substrate's winner (graceful System-1).
     if( !this._provider )
-      return { commands: { set: [ this._commit( id, meta, provisional, candidates, 'no-executive' ) ] } }
+      return { commands: { set: [ this._commit( id, meta, provisional, candidates, 'no-executive') ],
+        ...( del.length > 0 ? { delete: del } : {} ) } }
 
     // Deliberate through a UNIFIED facet (same persona/context as the master).
     const chosen = await this._deliberate( state, candidates, provisional, meta )
@@ -126,7 +136,8 @@ export class DeliberationEngine implements CognitiveEngine {
 
     return {
       commands: {
-        set:     [ this._commit( id, meta, chosen, candidates, 'facet' ) ],
+        set:     [ this._commit( id, meta, chosen, candidates, 'facet') ],
+        ...( del.length > 0 ? { delete: del } : {} ),
         metrics: [ [ 'agency.deliberation.count', 1 ] ],
       },
     }
@@ -145,7 +156,7 @@ export class DeliberationEngine implements CognitiveEngine {
       if( !this._handle ){
         const spawned = this._provider!.spawnFacet('deliberation')
         if( spawned.attention === 'full' || !spawned.handle ){
-          logger.info( '[deliberation] facet budget full — confirming substrate winner' )
+          logger.info('[deliberation] facet budget full — confirming substrate winner')
           return provisional
         }
         this._handle = spawned.handle
@@ -170,7 +181,7 @@ export class DeliberationEngine implements CognitiveEngine {
       // Director/state not ready (e.g. executive hasn't run yet) or LLM failure →
       // fall back to the substrate winner. Drop a possibly-dead handle.
       this._handle = null
-      logger.warn( `[deliberation] facet unavailable, confirming winner: ${ err instanceof Error ? err.message : String( err ) }` )
+      logger.warn(`[deliberation] facet unavailable, confirming winner: ${ err instanceof Error ? err.message : String( err ) }`)
       return provisional
     }
   }
@@ -208,10 +219,13 @@ export class DeliberationEngine implements CognitiveEngine {
     // Channel B: if this choice arose by interrupting a pending action, name it so the
     // facet owns the interruption in-character rather than reasoning in a vacuum.
     const preemptedFrom = str( meta['preemptedFrom'] )
-    if( preemptedFrom )
-      lines.push( `I just broke off a pending action ("${ preemptedFrom }") because something more pressing pulled at me. Decide what to do now:` )
+    const revokedBy     = str( meta['revokedBy'] )
+    if( revokedBy )
+      lines.push(`Something in my situation just shifted and I let go of what I was weighing ("${ revokedBy }"). Decide afresh what to do now:`)
+    else if( preemptedFrom )
+      lines.push(`I just broke off a pending action ("${ preemptedFrom }") because something more pressing pulled at me. Decide what to do now:`)
     else
-      lines.push( 'My automatic action-selection was uncertain. Candidate actions:' )
+      lines.push('My automatic action-selection was uncertain. Candidate actions:')
     candidates.forEach( ( c, i ) => {
       const to   = c.targetEntityId ? ` toward ${ c.targetEntityId }` : ''
       // The ability's meaning, so the facet weighs what each option IS FOR rather
@@ -220,9 +234,9 @@ export class DeliberationEngine implements CognitiveEngine {
       // Channel B: name the plan link so the facet chooses as the self pursuing it,
       // not blindly among labels ("this one is the next step of the plan I'm on").
       const plan = c.fromPlan ? " (my current plan's next step)" : ''
-      lines.push( `${ i + 1 }. ${ c.schema }${ to }${ what }${ plan }` )
+      lines.push(`${ i + 1 }. ${ c.schema }${ to }${ what }${ plan }`)
     })
-    return lines.join( '\n' )
+    return lines.join('\n')
   }
 }
 
@@ -230,7 +244,7 @@ export class DeliberationEngine implements CognitiveEngine {
 
 /** Pull the chosen schema from a facet decision, validated against the candidates. */
 function extractChosen( decision: unknown, candidates: Candidate[] ): string | undefined {
-  if( !decision || typeof decision !== 'object' ) return undefined
+  if( !decision || typeof decision !== 'object') return undefined
   const actions = ( decision as Record<string, unknown> )['actions']
   if( !Array.isArray( actions ) ) return undefined
   const valid = new Set( candidates.map( c => c.schema ) )

package/src/cognition/agency/engines/motor.schema.executor.ts

@@ -38,9 +38,16 @@ import type { AccessGrants } from '#agency/access.grants'
 import type { ActionRequest, ActionResult } from '#types'
 import { INNATE_SCHEMAS } from '#agency/schemas/innate'
 import { enact, type Enaction } from '#agency/execution.primitives'
+import { revokedIntentIds, revocationId, staleRevocationIds } from '#agency/revocation'
+import {
+  CONSEQUENCE_TYPE, CONSEQUENCE_TTL_TICKS,
+  consequenceEntity, fnv1a, paramsKey,
+} from '#agency/consequence'
 
-/** Ticks an async (communicate/external) intent may stay 'awaiting' before it is abandoned. */
-const AWAIT_TIMEOUT = 15
+/** Ticks an async (communicate/external) intent may stay 'awaiting' before it is
+ *  abandoned. Exported: the ReafferenceEngine's sensory-confirmation path (P5)
+ *  stands down at this boundary so the executor's timeout-failure wins. */
+export const AWAIT_TIMEOUT = 15
 
 /** Map a communicate schema to the ProactiveCommunicator effector + the permission name. */
 const COMM_SCHEMA_TO_EFFECTOR: Record<string, string> = {
@@ -134,15 +141,44 @@ export class MotorSchemaExecutor implements CognitiveEngine {
     const del: string[]            = []
     const metrics: Array<[ string, number ]> = []
 
-    const energy = state.metrics.get( 'energy.level' ) ?? 100
-    const stress = state.metrics.get( 'stress.load'  ) ?? 0
+    const energy = state.metrics.get('energy.level') ?? 100
+    const stress = state.metrics.get('stress.load'  ) ?? 0
+
+    // ── Expire consequence descriptors (EXAFFERENCE P1) ──────────
+    // Descriptors deliberately outlive intent resolution (the sensory echo of a
+    // reconciled action still arrives); their only cleanup is this TTL sweep.
+    for( const [ id, e ] of state.entities ){
+      if( e.type !== CONSEQUENCE_TYPE ) continue
+      if( tick >= num( e.metadata?.['expiresAt'], 0 ) ) del.push( id )
+    }
+
+    // ── Revocation tombstones (EXAFFERENCE P4) ───────────────────
+    // Reap expired tombstones (intent vanished otherwise), and collect live ones
+    // so the selected-processing loop can refuse the half-race case: Deliberation
+    // committed `selected` the same tick the tombstone was written (both read the
+    // pre-tombstone snapshot), so the intent surfaces here still needing to die.
+    del.push( ...staleRevocationIds( state.entities, tick ) )
+    const revoked = revokedIntentIds( state.entities, tick )
+
+    // A tombstoned intent dies whatever its status — including an 'expanding'
+    // composite parent preempted mid-routine (registry #4) — and takes its
+    // sub-intents with it, in any state ('selected' queued by the executor's
+    // own in-tick advance, or 'awaiting' a host). The selected-loop guard below
+    // additionally prevents enacting any of them this tick.
+    if( revoked.size > 0 )
+      for( const [ id, e ] of state.entities ){
+        if( e.type !== 'agency.intent') continue
+        const parentId = str( e.metadata?.['parentIntentId'] )
+        if( revoked.has( id ) ) del.push( id, revocationId( id ) )
+        else if( parentId && revoked.has( parentId ) ) del.push( id )
+      }
 
     // ── Timeout stranded async intents ───────────────────────────
     // An 'awaiting' intent whose host/delivery never returned would block the
     // serial Will forever. After AWAIT_TIMEOUT ticks, abandon it as a failed
     // outcome (which also teaches reafference the action is unreliable here).
     for( const [ id, e ] of state.entities ){
-      if( e.type !== 'agency.intent' || str( e.metadata?.['status'] ) !== 'awaiting' ) continue
+      if( e.type !== 'agency.intent' || str( e.metadata?.['status'] ) !== 'awaiting') continue
       const dispatchedAt = num( e.metadata?.['dispatchedAt'], tick )
       if( tick - dispatchedAt < AWAIT_TIMEOUT ) continue
 
@@ -160,17 +196,22 @@ export class MotorSchemaExecutor implements CognitiveEngine {
       this._emitEnacted( intent, timedOut, predicted, tick )
       if( intent.planId && intent.planStepId )
         this._emitActionOutcome( intent, false, 0, 1, tick )
-      logger.info( `[motor] ⏱ "${ intent.schema }" timed out after ${ tick - dispatchedAt } ticks` )
+      logger.info(`[motor] ⏱ "${ intent.schema }" timed out after ${ tick - dispatchedAt } ticks`)
     }
 
     // Process committed intents in a stable order (determinism / replay).
     const selected = [ ...state.entities.entries() ]
-      .filter( ( [ , e ] ) => e.type === 'agency.intent' && str( e.metadata?.['status'] ) === 'selected' )
+      .filter( ( [ , e ] ) => e.type === 'agency.intent' && str( e.metadata?.['status'] ) === 'selected')
       .sort( ( a, b ) => ( a[0] < b[0] ? -1 : a[0] > b[0] ? 1 : 0 ) )
 
     let enactedCount = 0
 
     for( const [ id, e ] of selected ){
+      // Revoked mid-commit (P4), or a sub of a preempted composite (#4) — refuse
+      // to enact; the sweep above already queued the deletes.
+      if( revoked.has( id ) ) continue
+      const parentOf = str( e.metadata?.['parentIntentId'] )
+      if( parentOf && revoked.has( parentOf ) ) continue
       const intent = readIntent( id, e.metadata )
       const schema = this._resolve( intent.schema )
 
@@ -190,7 +231,7 @@ export class MotorSchemaExecutor implements CognitiveEngine {
         : { mode: 'external', success: true, outcomeQuality: 0.5, valence: 0,
             description: `Unknown schema "${ intent.schema }" routed to the host.` }
 
-      if( enaction.mode === 'sync' ){
+      if( enaction.mode === 'sync'){
         set.push( outcomeEntity( tick, intent, enaction, predicted ) )
         del.push( id )
         if( enaction.metricDeltas ) metrics.push( ...enaction.metricDeltas )
@@ -224,6 +265,26 @@ export class MotorSchemaExecutor implements CognitiveEngine {
               predictedValence: predicted.expectedValence,
             },
           })
+          // EXAFFERENCE P1 — the dispatched action's expected sensory footprint,
+          // so the world's answer can be recognized as ours when it arrives
+          // through the senses (P2). Host acks correlate by intent id already.
+          // For a communicate whose words are authored, also carry the text so an
+          // echo of them can be matched (P2) and, if the intent is still awaiting,
+          // confirm it through the senses (P5) instead of timing out as a failure.
+          const awaitingText = enaction.mode === 'communicate'
+            ? ( str( intent.parameters['content'] ) ?? firstMessage( intent.parameters['messages'] ) )
+            : undefined
+          set.push( consequenceEntity({
+            intentId: id, schema: intent.schema,
+            mode: enaction.mode === 'communicate' ? 'communicate' : 'external',
+            ...( enaction.mode === 'communicate'
+              ? { effector: COMM_SCHEMA_TO_EFFECTOR[ intent.schema ] ?? intent.schema }
+              : {} ),
+            ...( intent.targetEntityId ? { targetEntityId: intent.targetEntityId } : {} ),
+            ...( awaitingText ? { text: awaitingText, textHash: fnv1a( awaitingText ) } : {} ),
+            paramsHash: fnv1a( paramsKey( intent.parameters ) ),
+            expiresAt: tick + CONSEQUENCE_TTL_TICKS, tick,
+          }) )
           this._emitDispatch( intent, enaction.mode, tick )
           metrics.push([ enaction.mode === 'communicate'
             ? 'agency.communicate.dispatched'
@@ -253,7 +314,7 @@ export class MotorSchemaExecutor implements CognitiveEngine {
       metadata: { ...meta, status: 'expanding', steps, cursor: 0, accumQuality: 0, accumValence: 0, completed: 0 },
     })
     set.push( this._subIntent( parentId, intent.targetEntityId, intent.parameters, steps[0]!, 0, tick ) )
-    logger.info( `[motor] composite "${ intent.schema }" → ${ steps.length } steps` )
+    logger.info(`[motor] composite "${ intent.schema }" → ${ steps.length } steps`)
   }
 
   private _advance(
@@ -380,7 +441,7 @@ export class MotorSchemaExecutor implements CognitiveEngine {
     if( bubbles.length === 0 && this._author ){
       const name = str( intent.parameters['targetEntityName'] ) ?? intent.targetEntityId ?? 'them'
       try { bubbles = await this._author.authorOutreach( intent.targetEntityId ?? '', name, str( intent.parameters['gist'] ) ) }
-      catch( err ){ logger.warn( `[motor] outreach authoring failed: ${ errMsg( err ) }` ) }
+      catch( err ){ logger.warn(`[motor] outreach authoring failed: ${ errMsg( err ) }`) }
     }
     if( bubbles.length === 0 ) return false   // nothing authored to send → await
 
@@ -394,13 +455,24 @@ export class MotorSchemaExecutor implements CognitiveEngine {
     }
     let result: ActionResult
     try { result = await this._comms.executeAction( request, state ) }
-    catch( err ){ logger.warn( `[motor] communicate delivery failed: ${ errMsg( err ) }` ); return false }
+    catch( err ){ logger.warn(`[motor] communicate delivery failed: ${ errMsg( err ) }`); return false }
 
     if( result.commands.set?.length ) set.push( ...result.commands.set )
     const out: Enaction = { mode: 'communicate', success: result.success,
       outcomeQuality: result.feedback.outcomeQuality, valence: 0, description: result.description }
     set.push( outcomeEntity( tick, intent, out, predicted ) )
     del.push( id )
+    // EXAFFERENCE P1 — the delivered words' sensory footprint: the channel echo
+    // or a quote-back of this exact text should read as ours, not as the world
+    // surprising us (P2 matches on the content hash).
+    if( result.success )
+      set.push( consequenceEntity({
+        intentId: id, schema: intent.schema, mode: 'communicate', effector,
+        ...( intent.targetEntityId ? { targetEntityId: intent.targetEntityId } : {} ),
+        textHash: fnv1a( bubbles.join('\n') ),
+        text:     bubbles.join('\n'),
+        expiresAt: tick + CONSEQUENCE_TTL_TICKS, tick,
+      }) )
     this._emitEnacted( intent, out, predicted, tick )
     this._emitActionOutcome( intent, result.success, result.feedback.outcomeQuality,
       clamp01( Math.abs( predicted.expectedReward - result.feedback.outcomeQuality ) ), tick )
@@ -420,7 +492,7 @@ export class MotorSchemaExecutor implements CognitiveEngine {
         payload: { schema: intent.schema, success: enaction.success, outcomeQuality: enaction.outcomeQuality, surprise, tick },
       })
     }
-    catch( err ){ logger.warn( `[motor] enacted publish failed: ${ errMsg( err ) }` ) }
+    catch( err ){ logger.warn(`[motor] enacted publish failed: ${ errMsg( err ) }`) }
   }
 
   /**
@@ -452,7 +524,7 @@ export class MotorSchemaExecutor implements CognitiveEngine {
         },
       })
     }
-    catch( err ){ logger.warn( `[motor] action outcome publish failed: ${ errMsg( err ) }` ) }
+    catch( err ){ logger.warn(`[motor] action outcome publish failed: ${ errMsg( err ) }`) }
   }
 
   private _emitDispatch( intent: Intent, mode: 'communicate' | 'external', tick: Tick ): void {
@@ -469,7 +541,7 @@ export class MotorSchemaExecutor implements CognitiveEngine {
         },
       })
     }
-    catch( err ){ logger.warn( `[motor] dispatch publish failed: ${ errMsg( err ) }` ) }
+    catch( err ){ logger.warn(`[motor] dispatch publish failed: ${ errMsg( err ) }`) }
   }
 }
 

package/src/cognition/agency/engines/reafference.engine.ts

@@ -29,9 +29,38 @@ import type { CognitiveEngine, EngineResult } from '#cognition/types'
 import type { CognitiveEventSchema } from '#cognition/schema.registry'
 import type { SchemaRepertoire } from '#agency/schemas/repertoire'
 import { schemaEntityId } from '#agency/schemas/repertoire'
+import { AWAIT_TIMEOUT } from '#agency/engines/motor.schema.executor'
 
 const PROC_THRESHOLD = 0.60   // mirror of repertoire's threshold for the habitual-count metric
 
+/**
+ * EXAFFERENCE P5 — soft outcome quality for a purely *sensory* confirmation: the
+ * world echoed our action back (a reafferent percept), but no host ack graded it.
+ * A modest positive — "it manifested" — below a host ack's 0.8, enough to free the
+ * awaiting intent and accrue competence instead of letting it time out as a failure.
+ */
+const SENSORY_SOFT_QUALITY = 0.6
+
+/**
+ * Registry #5 — the affect→percept valence seam, consumed. The echo now carries
+ * how the mind FEELS about what came back (Exteroception stamps it), so a
+ * sensory confirmation is graded rather than flat: quality = the soft base
+ * shifted by that valence within a bounded band.
+ *
+ * Two spans, because the two valence sources are not equal evidence:
+ *  • `'entity'` — the KnownEntityTracker's felt valence toward this very thing.
+ *    Real appraisal of the outcome ⇒ the wider span.
+ *  • `'ambient'` — the mind's mood at perception time. Weak context, NOT a
+ *    judgement of this action ⇒ a narrow span, so a bad mood cannot teach the
+ *    Will that a working skill failed.
+ *
+ * Neutral (or absent) valence reproduces the pre-seam 0.6 exactly.
+ */
+const SENSORY_VALENCE_SPAN_ENTITY  = 0.25
+const SENSORY_VALENCE_SPAN_AMBIENT = 0.10
+/** Below this the world's reflection reads as a failed outcome, not a success. */
+const SENSORY_SUCCESS_FLOOR = 0.5
+
 export class ReafferenceEngine implements CognitiveEngine {
   readonly name = 'reafference'
 
@@ -56,11 +85,11 @@ export class ReafferenceEngine implements CognitiveEngine {
   /** Creation seam: register a composite proposed by the executive/deliberation facet. */
   subscribes(): string[] { return [ 'agency.composite.proposed' ] }
   onCognitiveEvent( e: CognitiveEvent ): void {
-    if( e.type !== 'agency.composite.proposed' ) return
+    if( e.type !== 'agency.composite.proposed') return
     const p = e.payload as { id?: string; name?: string; composedOf?: unknown; tags?: unknown; cost?: number }
     const id    = p.id ?? p.name
     const steps = Array.isArray( p.composedOf )
-      ? ( p.composedOf as unknown[] ).filter( ( s ): s is string => typeof s === 'string' )
+      ? ( p.composedOf as unknown[] ).filter( ( s ): s is string => typeof s === 'string')
       : []
     if( !id || steps.length < 2 ) return   // a composite needs a name + ≥2 sub-schemas
 
@@ -68,9 +97,9 @@ export class ReafferenceEngine implements CognitiveEngine {
       id, kind: 'composite', source: 'repertoire', binds: 'none',
       cost: typeof p.cost === 'number' ? p.cost : 0.1,
       composedOf: steps,
-      tags: Array.isArray( p.tags ) ? ( p.tags as unknown[] ).filter( ( t ): t is string => typeof t === 'string' ) : [ 'composite' ],
+      tags: Array.isArray( p.tags ) ? ( p.tags as unknown[] ).filter( ( t ): t is string => typeof t === 'string') : [ 'composite' ],
     })
-    logger.info( `[reafference] registered proposed composite "${ id }" (${ steps.join( ' → ' ) })` )
+    logger.info(`[reafference] registered proposed composite "${ id }" (${ steps.join(' → ') })`)
   }
   snapshot(): Record<string, unknown> {
     return { skills: this._repertoire.skills().size }
@@ -86,14 +115,84 @@ export class ReafferenceEngine implements CognitiveEngine {
     const del:     string[]                = []
     const metrics: Array<[ string, number ]> = []
 
-    // ── 1. Fold each new outcome into its skill ──────────────────
-    let updates    = 0
-    let discovered = 0
+    // ── 0. Gather outcomes: real ones from state + synthesized sensory ones ──
+    // A `reafferent` percept (P2) carrying a `sourceIntentId` is the world echoing
+    // our own action back. If that intent is still `awaiting` and no outcome graded
+    // it this tick (a host ack / sync / timeout — those WIN), synthesize a soft
+    // outcome so the skill learns and the intent is freed through the senses rather
+    // than timing out as a failure (EXAFFERENCE P5). Ack-less awaiting intents only.
+    const outcomes: Array<{ id: string; meta: Record<string, unknown>; fromState: boolean }> = []
+    const gradedIntentIds = new Set<string>()
+    for( const [ id, e ] of state.entities ){
+      if( e.type !== 'agency.outcome') continue
+      const m = ( e.metadata ?? {} ) as Record<string, unknown>
+      outcomes.push({ id, meta: m, fromState: true })
+      const iid = str( m['intentId'] ); if( iid ) gradedIntentIds.add( iid )
+    }
+
+    const awaiting = new Map<string, { schema: string; predictedReward: number; predictedValence: number }>()
     for( const [ id, e ] of state.entities ){
-      if( e.type !== 'agency.outcome' ) continue
+      if( e.type !== 'agency.intent' || str( e.metadata?.['status'] ) !== 'awaiting') continue
+      const m = ( e.metadata ?? {} ) as Record<string, unknown>
+      // Timeout boundary: at tick - dispatchedAt ≥ AWAIT_TIMEOUT the executor
+      // (which ran earlier this tick, off the same frozen snapshot) is writing
+      // its timeout-failure outcome right now — stand down so one enaction is
+      // never scored twice (soft success here + failure next tick).
+      if( tick - num( m['dispatchedAt'], tick ) >= AWAIT_TIMEOUT ) continue
+      awaiting.set( id, {
+        schema:           str( m['schema'] ) ?? '',
+        predictedReward:  num( m['predictedReward'],  0.5 ),
+        predictedValence: num( m['predictedValence'], 0 ),
+      })
+    }
+
+    let sensory = 0
+    const sensedIntentIds = new Set<string>()
+    for( const [ , e ] of state.entities ){
+      if( e.type !== 'percept') continue
       const m = ( e.metadata ?? {} ) as Record<string, unknown>
+      if( str( m['provenance'] ) !== 'reafferent') continue
+      const iid = str( m['sourceIntentId'] )
+      if( !iid || gradedIntentIds.has( iid ) || sensedIntentIds.has( iid ) ) continue
+      const aw = awaiting.get( iid )
+      if( !aw || !aw.schema ) continue          // only ack-less awaiting intents
+      sensedIntentIds.add( iid )
+      sensory++
+
+      // Registry #5: grade the confirmation by how the echo FELT, within a band
+      // whose width reflects how much that valence really says about THIS action.
+      const feltRaw = m['valence']
+      const felt    = typeof feltRaw === 'number' && Number.isFinite( feltRaw ) ? feltRaw : undefined
+      const span    = str( m['valenceSource'] ) === 'entity'
+        ? SENSORY_VALENCE_SPAN_ENTITY
+        : SENSORY_VALENCE_SPAN_AMBIENT
+      const quality = felt === undefined
+        ? SENSORY_SOFT_QUALITY
+        : clamp01( SENSORY_SOFT_QUALITY + Math.max( -1, Math.min( 1, felt ) ) * span )
+
+      outcomes.push({ id: `agency-outcome-${ tick }-${ iid }-sensory`, fromState: false, meta: {
+        schema:           aw.schema,
+        intentId:         iid,
+        success:          quality >= SENSORY_SUCCESS_FLOOR,
+        outcomeQuality:   quality,
+        valence:          felt ?? aw.predictedValence,
+        predictedReward:  aw.predictedReward,
+        predictedValence: aw.predictedValence,
+        surprise:         clamp01( Math.abs( aw.predictedReward - quality ) ),
+        mode:             'external',
+        reconciled:       true,
+        sensory:          true,
+        ...( felt !== undefined ? { sensoryValence: felt, valenceSource: str( m['valenceSource'] ) } : {} ),
+        tick,
+      } })
+    }
+
+    // ── 1. Fold each outcome into its skill ──────────────────────
+    let updates    = 0
+    let discovered = 0
+    for( const { id, meta: m, fromState } of outcomes ){
       const schema = str( m['schema'] )
-      if( !schema ){ del.push( id ); continue }
+      if( !schema ){ if( fromState ) del.push( id ); continue }
 
       const { skill, proceduralized } = this._repertoire.recordOutcome({
         schema,
@@ -105,10 +204,11 @@ export class ReafferenceEngine implements CognitiveEngine {
       })
 
       set.push( skillEntity( skill ) )
-      del.push( id )                       // outcome consumed
-      // Host-ack reconciliation: a reconciled outcome carries the awaiting intent's
-      // id — free it so the serial Will can act again. The executor's own sync
-      // outcomes already deleted their intent, so this is a harmless no-op there.
+      if( fromState ) del.push( id )       // real outcome consumed (synthetic ones were never in state)
+      // Host-ack reconciliation OR sensory confirmation: the outcome carries the
+      // awaiting intent's id — free it so the serial Will can act again. The
+      // executor's own sync outcomes already deleted their intent, so this is a
+      // harmless no-op there.
       const intentId = str( m['intentId'] )
       if( intentId ) del.push( intentId )
       updates++
@@ -131,14 +231,14 @@ export class ReafferenceEngine implements CognitiveEngine {
 
       if( proceduralized ){
         this._emitProceduralized( skill, tick )
-        logger.info( `[reafference] "${ schema }" proceduralized (habit ${ skill.habitStrength.toFixed( 2 ) })` )
+        logger.info(`[reafference] "${ schema }" proceduralized (habit ${ skill.habitStrength.toFixed( 2 ) })`)
       }
     }
 
     // ── 2. Forgetting curve over the competence layer ────────────
     const dropped = this._repertoire.decay( tick )
     for( const id of dropped ){
-      del.push( `agency-skill-${ id }` )
+      del.push(`agency-skill-${ id }`)
       del.push( schemaEntityId( id ) )   // composite mirror (harmless no-op for primitives)
     }
 
@@ -157,6 +257,7 @@ export class ReafferenceEngine implements CognitiveEngine {
       [ 'agency.discovered.count', discovered ],
       [ 'agency.skill.count',      skills.size ],
       [ 'agency.habitual.count',   habitual ],
+      [ 'agency.sensory.confirmed', sensory ],
     )
 
     return { commands: { set, delete: del, metrics } }
@@ -171,7 +272,7 @@ export class ReafferenceEngine implements CognitiveEngine {
         payload: { schema: skill.schema, habitStrength: skill.habitStrength, tick },
       })
     }
-    catch( err ){ logger.warn( `[reafference] publish failed: ${ err instanceof Error ? err.message : String( err ) }` ) }
+    catch( err ){ logger.warn(`[reafference] publish failed: ${ err instanceof Error ? err.message : String( err ) }`) }
   }
 
   /**
@@ -197,7 +298,7 @@ export class ReafferenceEngine implements CognitiveEngine {
         },
       })
     }
-    catch( err ){ logger.warn( `[reafference] plan outcome publish failed: ${ err instanceof Error ? err.message : String( err ) }` ) }
+    catch( err ){ logger.warn(`[reafference] plan outcome publish failed: ${ err instanceof Error ? err.message : String( err ) }`) }
   }
 
   private _emitDiscovered( schema: string, tick: Tick ): void {
@@ -208,7 +309,7 @@ export class ReafferenceEngine implements CognitiveEngine {
         salience: 0.5, payload: { schema, tick },
       })
     }
-    catch( err ){ logger.warn( `[reafference] discovered publish failed: ${ err instanceof Error ? err.message : String( err ) }` ) }
+    catch( err ){ logger.warn(`[reafference] discovered publish failed: ${ err instanceof Error ? err.message : String( err ) }`) }
   }
 }
 
@@ -239,3 +340,6 @@ function str( v: unknown ): string | undefined {
 function num( v: unknown, fallback: number ): number {
   return typeof v === 'number' && Number.isFinite( v ) ? v : fallback
 }
+function clamp01( n: number ): number {
+  return n < 0 ? 0 : n > 1 ? 1 : n
+}

package/src/cognition/agency/execution.primitives.ts

@@ -46,8 +46,8 @@ const COMM_SCHEMAS = new Set([ 'reach-out', 'talk', 'text', 'broadcast', 'gestur
 
 /** Classify how a primitive schema executes. */
 export function modeOf( schema: MotorSchema ): EnactionMode {
-  if( schema.tags?.includes( 'external' ) ) return 'external'
-  if( schema.tags?.includes( 'communication' ) || COMM_SCHEMAS.has( schema.id ) ) return 'communicate'
+  if( schema.tags?.includes('external') ) return 'external'
+  if( schema.tags?.includes('communication') || COMM_SCHEMAS.has( schema.id ) ) return 'communicate'
   return 'sync'
 }
 
@@ -55,7 +55,7 @@ export function modeOf( schema: MotorSchema ): EnactionMode {
 export function enact( ctx: EnactionContext ): Enaction {
   const mode = modeOf( ctx.schema )
 
-  if( mode === 'communicate' ){
+  if( mode === 'communicate'){
     const name = str( ctx.parameters['targetEntityName'] ) ?? ctx.targetEntityId ?? 'them'
     return {
       mode, success: true, outcomeQuality: 0.7, valence: 0.1,
@@ -63,7 +63,7 @@ export function enact( ctx: EnactionContext ): Enaction {
     }
   }
 
-  if( mode === 'external' )
+  if( mode === 'external')
     return {
       mode, success: true, outcomeQuality: 0.5, valence: 0,
       description: `"${ ctx.schema.id }" dispatched to the host; awaiting the world's reply.`,
@@ -82,25 +82,25 @@ function syncStance( ctx: EnactionContext ): Enaction {
   switch( schema.id ){
     case 'rest':
       // More restorative the more depleted the Will was.
-      return sync( 0.5 + ( 1 - e01 ) * 0.4, 0.15, 'I let myself recover; the pressure eases a little.' )
+      return sync( 0.5 + ( 1 - e01 ) * 0.4, 0.15, 'I let myself recover; the pressure eases a little.')
     case 'withdraw':
-      return sync( 0.5 + s01 * 0.3, 0.05 + s01 * 0.1, 'I pull back from the press of things; the world quietens.' )
+      return sync( 0.5 + s01 * 0.3, 0.05 + s01 * 0.1, 'I pull back from the press of things; the world quietens.')
     case 'reflect':
-      return sync( 0.6, 0.05, 'I turn inward; patterns from recent events settle into place.' )
+      return sync( 0.6, 0.05, 'I turn inward; patterns from recent events settle into place.')
     case 'attend':
-      return sync( 0.6, 0.0, 'I concentrate, mobilizing more of my attention.' )
+      return sync( 0.6, 0.0, 'I concentrate, mobilizing more of my attention.')
     case 'orient':
-      return sync( 0.5, 0.0, 'My awareness sweeps the situation, taking its measure.' )
+      return sync( 0.5, 0.0, 'My awareness sweeps the situation, taking its measure.')
     case 'wait':
-      return sync( 0.5, 0.0, 'I let time pass; regulatory processes continue their quiet work.' )
+      return sync( 0.5, 0.0, 'I let time pass; regulatory processes continue their quiet work.')
     case 'express':
-      return sync( 0.6, 0.1, 'My inner state becomes outwardly visible.' )
+      return sync( 0.6, 0.1, 'My inner state becomes outwardly visible.')
     case 'inspect': {
       const focus = str( parameters['focus'] ) ?? 'it'
-      return sync( 0.65, 0.05, `I examine ${ focus } closely; more of its detail resolves.` )
+      return sync( 0.65, 0.05, `I examine ${ focus } closely; more of its detail resolves.`)
     }
     default:
-      return sync( 0.5, 0.0, `I enact ${ schema.id }.` )
+      return sync( 0.5, 0.0, `I enact ${ schema.id }.`)
   }
 }
 

package/src/cognition/agency/proactive.communicator.ts

@@ -203,7 +203,7 @@ export class ProactiveCommunicator {
         content:     bubble,
         effectorName,
         replyToMessageId,
-      }, `-${ i }` ) )
+      }, `-${ i }`) )
     })
 
     // Write the intent record at push time so context-builder can see what we said.

package/src/cognition/agency/reconcile.learning.ts

@@ -67,7 +67,7 @@ export function reconcileInvocation(
       predictedReward:  predicted.reward,
       predictedValence: predicted.valence,
       surprise,
-      description:      result.description ?? ( result.success ? 'The world confirmed the action.' : 'The world rejected the action.' ),
+      description:      result.description ?? ( result.success ? 'The world confirmed the action.' : 'The world rejected the action.'),
       mode:             'external',
       tick,
       reconciled:       true,