@mindot/will 0.5.0 → 0.7.0

package/src/cognition/agency/engines/affordance.synthesizer.ts

@@ -103,6 +103,9 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     // means the executor, which ticks later in the SAME tick, sees a whole
     // repertoire and can expand a restored mid-flight macro. Idempotent.
     this._repertoire?.restoreComposites( state.entities )
+    // Availability entries (P2) rehydrate the same way, so a restored Will keeps
+    // its learned suppressions instead of re-probing forbidden abilities.
+    this._repertoire?.restoreAvailability( state.entities )
 
     const schemas   = this._repertoire?.schemas() ?? this._schemas
     const skills    = this._skills?.() ?? this._repertoire?.skills() ?? null
@@ -114,14 +117,12 @@ export class AffordanceSynthesizer implements CognitiveEngine {
 
     // Clear the previous tick's field — affordances are transient.
     for( const [ id, e ] of state.entities )
-      if( e.type === 'affordance' ) del.push( id )
+      if( e.type === 'affordance') del.push( id )
 
     // ── 1. innate floor — always emitted, never attention-capped ──
-    const floor = schemas.filter( s => s.binds === 'none' )
+    const floor = schemas.filter( s => s.binds === 'none')
     for( const schema of floor )
-      set.push( this._toEntity(
-        this._build( schema, tick, state, valence, energyLow, skills, {} ),
-      ) )
+      set.push( this._toEntity( this._build( schema, tick, state, valence, energyLow, skills, {} ) ) )
 
     // ── 2. perception-bound candidates, attention-budgeted ───────
     // Goal-relevance counts at the CAP, not only at selection: an affordance whose
@@ -131,14 +132,16 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     const candidates:  Candidate[]           = []
     const goalTargets: Map<string, number>   = collectGoalTargets( state )
 
-    const perceptSchema = schemas.find( s => s.binds === 'percept' )
+    const perceptSchema = schemas.find( s => s.binds === 'percept')
     if( perceptSchema )
       for( const [ id, e ] of state.entities ){
-        if( e.type !== 'percept' ) continue
+        if( e.type !== 'percept') continue
+
         const m        = e.metadata
         const salience = num( m?.['salience'], 0 )
         const summary  = str( m?.['summary'] ) ?? str( m?.['category'] ) ?? 'something'
         const target   = str( m?.['entityId'] ) ?? str( m?.['targetEntityId'] )
+
         candidates.push({
           salience: salience + ( target ? goalTargets.get( target ) ?? 0 : 0 ),
           affordance: this._build( perceptSchema, tick, state, valence, energyLow, skills, {
@@ -155,21 +158,26 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     // things — so the Will can direct `give`/`greet` at someone or `use`/`pick-up`
     // at something in particular. Each (schema × target) enters as a candidate at
     // the target's salience and competes through the attention cap.
-    const personSchemas = schemas.filter( s => s.binds === 'entity' )
-    const objectSchemas = schemas.filter( s => s.binds === 'object' )
+    const personSchemas = schemas.filter( s => s.binds === 'entity')
+    const objectSchemas = schemas.filter( s => s.binds === 'object')
+
     if( personSchemas.length > 0 || objectSchemas.length > 0 )
       for( const [ id, e ] of state.entities ){
-        if( e.type !== 'known-entity' ) continue
+        if( e.type !== 'known-entity') continue
+
         const m    = e.metadata
         const kind = str( m?.['kind'] )
         const applicable = kind === 'sentient' ? personSchemas : kind === 'thing' ? objectSchemas : null
+
         if( !applicable || applicable.length === 0 ) continue
+
         const keid = str( m?.['keid'] ) ?? id
         const fam  = num( m?.['familiarity'], 0 )
         const val  = num( m?.['valence'], 0 )
         const res  = num( m?.['resolutionConfidence'], 0 )
         const salience = fam * 0.6 + Math.max( 0, val ) * 0.3 + res * 0.1 + ( goalTargets.get( keid ) ?? 0 )
         const name     = str( m?.['name'] ) ?? keid
+
         for( const schema of applicable )
           candidates.push({
             salience,
@@ -188,11 +196,14 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     // it. This is the AffordanceSource.ideomotor leg: executive intention → an
     // affordance that competes like any other.
     for( const [ id, e ] of state.entities ){
-      if( e.type !== 'ideomotor.intent' ) continue
+      if( e.type !== 'ideomotor.intent') continue
+
       const m        = e.metadata
       const schemaId = str( m?.['schema'] )
       const schema   = schemaId ? schemas.find( s => s.id === schemaId ) : undefined
+
       if( !schema ) continue
+
       candidates.push({
         salience: IDEOMOTOR_BASE_SALIENCE + num( m?.['priority'], 0.8 ),
         affordance: this._build( schema, tick, state, valence, energyLow, skills, {
@@ -215,11 +226,14 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     // next tick. The suggested schema must resolve in the repertoire; if it does not,
     // the prior cannot surface as an action and the plan waits / replans.
     for( const [ id, e ] of state.entities ){
-      if( e.type !== 'plan.prior' ) continue
+      if( e.type !== 'plan.prior') continue
+
       const m        = e.metadata
       const schemaId = str( m?.['schema'] )
       const schema   = schemaId ? schemas.find( s => s.id === schemaId ) : undefined
+
       if( !schema ) continue
+
       const planBias = clamp01( num( m?.['planBias'], 0.6 ) )
       candidates.push({
         salience: IDEOMOTOR_BASE_SALIENCE + planBias,
@@ -266,7 +280,7 @@ export class AffordanceSynthesizer implements CognitiveEngine {
         })
       }
       catch( err ){
-        logger.warn( `[affordance] bus publish failed: ${ err instanceof Error ? err.message : String( err ) }` )
+        logger.warn(`[affordance] bus publish failed: ${ err instanceof Error ? err.message : String( err ) }`)
       }
     }
 
@@ -295,9 +309,12 @@ export class AffordanceSynthesizer implements CognitiveEngine {
   ): Affordance {
     const skill = skills?.get( schema.id )
 
+    // Policy availability (P2): omitted when fully available (1), so a never-refused
+    // Will's affordance field is byte-identical. Present only once a refusal dented it.
+    const availability = this._repertoire?.availabilityOf( schema.id ) ?? 1
+
     // Learned value if known, else the schema's intrinsic prior mapped to 0..1.
-    const expectedReward = skill?.valueEstimate
-      ?? clamp01( ( ( schema.baseValence ?? 0 ) + 1 ) / 2 )
+    const expectedReward = skill?.valueEstimate ?? clamp01( ( ( schema.baseValence ?? 0 ) + 1 ) / 2 )
     const expectedValence = schema.baseValence ?? valence
     const habitStrength   = skill?.habitStrength ?? 0
     // Low energy makes everything feel costlier.
@@ -323,6 +340,7 @@ export class AffordanceSynthesizer implements CognitiveEngine {
       available:       this._available( schema.preconditions, ( k ) => metric( state, k, 0 ) ),
       tags:            schema.tags ?? [],
       ...( schema.description ? { description: schema.description } : {} ),
+      ...( availability < 1 ? { availability } : {} ),
       planBias:        ctx.planBias,
       planId:          ctx.planId,
       stepId:          ctx.stepId,
@@ -347,6 +365,7 @@ export class AffordanceSynthesizer implements CognitiveEngine {
         available:       a.available,
         tags:            a.tags,
         description:     a.description,
+        ...( a.availability !== undefined ? { availability: a.availability } : {} ),
         planBias:        a.planBias,
         planId:          a.planId,
         stepId:          a.stepId,
@@ -374,7 +393,7 @@ export class AffordanceSynthesizer implements CognitiveEngine {
   }
 
   private _attentionCap( state: ReadonlySimulationState ): number {
-    const cap = state.metrics.get( 'attention.capacity' ) ?? this._defaultCap
+    const cap = state.metrics.get('attention.capacity') ?? this._defaultCap
     return Math.max( 1, Math.min( MAX_ATTENTION_CAP, Math.round( cap ) ) )
   }
 }

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,48 @@ 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
+      // POLICY_REAFFERENCE P4 — an escalated intent is HELD: the stem owns its
+      // lifecycle (extended TTL → approve/deny/expire), so the executor must not
+      // time it out at AWAIT_TIMEOUT and reconcile it as a phantom failure.
+      if( e.metadata?.['escalated'] === true ) continue
       const dispatchedAt = num( e.metadata?.['dispatchedAt'], tick )
       if( tick - dispatchedAt < AWAIT_TIMEOUT ) continue
 
@@ -160,17 +200,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 +235,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 +269,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 +318,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 +445,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 +459,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 +496,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 +528,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 +545,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 ) }`) }
   }
 }