@mindot/will 0.8.0 → 0.10.0

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

@@ -24,7 +24,7 @@
 
 import { logger } from '#core/logger'
 import type {
-  Duration, Tick, SimulationContext,
+  Duration, Tick, SimulationContext, SimulationEvent,
   ReadonlySimulationState, StateCommands, EntityInput,
 } from '#core/types'
 import type { CognitiveBus } from '#cognition/bus'
@@ -39,10 +39,21 @@ 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 { addressesOf } from '#cognition/social.identity'
+import { lastAnsweredByEntity } from '#agency/conversation.aim'
 import {
-  CONSEQUENCE_TYPE, CONSEQUENCE_TTL_TICKS,
-  consequenceEntity, fnv1a, paramsKey,
-} from '#agency/consequence'
+  CONSEQUENCE_TYPE, CONSEQUENCE_TTL_TICKS, ENACTED_TYPE,
+  consequenceEntity, enactedEntity, fnv1a, paramsKey, spokenAtByEntity } from '#agency/consequence'
+
+/**
+ * How long a durable enaction record is kept. Generous against the satiation
+ * window (`repeatWindowTicks`, 60 by default) rather than equal to it, because
+ * the window is persona-tunable and read in the synthesizer, not here — a
+ * retention shorter than some tenant's window would silently reintroduce the
+ * very gap this record exists to close. Past this the satiation term is 0
+ * regardless, so keeping it longer buys nothing.
+ */
+const ENACTED_RETENTION_TICKS = 600
 
 /** Ticks an async (communicate/external) intent may stay 'awaiting' before it is
  *  abandoned. Exported: the ReafferenceEngine's sensory-confirmation path (P5)
@@ -71,11 +82,48 @@ interface Intent {
    */
   planId?:         string
   planStepId?:     string
+  /**
+   * The entity that evoked this — for an ideomotor winner, the `ideomotor.intent`
+   * the executive wrote. Read so enaction can retire it (see _dischargeWill).
+   */
+  evokedBy?:       string
+}
+
+/**
+ * What an authoring pass produced.
+ *
+ * `bubbles` empty is AMBIGUOUS on its own — it is also what a timed-out facet, a
+ * full facet budget, and a pass deferring to one already in flight all return.
+ * `answered` is what disambiguates it: whether a facet actually reasoned and came
+ * back. An empty answer IS an answer; an empty non-answer means the pass never
+ * happened and is worth asking for again.
+ */
+export interface OutreachResult {
+  bubbles:   string[]
+  /** The mind considered speaking and declared silence — the strongest answer. */
+  withheld?: boolean
+  /**
+   * A facet reasoned and its decision came back, whatever it held. Absent means
+   * no pass ran at all (no executive, budget full, deferring to one in flight,
+   * timed out, threw) — only THAT is worth asking again for.
+   *
+   * Without this the caller could not tell the two apart, so it re-asked on
+   * every tick. Observed live: nineteen authoring passes for one outreach, each
+   * returning an empty answer, none of them delivering a word, and the person
+   * she had decided to contact never heard from her.
+   */
+  answered?: boolean
 }
 
 /** Authors the words for a self-initiated communicate the agency selected (no inbound triggered it). */
 export interface OutreachAuthor {
-  authorOutreach( entityId: string, entityName: string, gist?: string ): Promise<string[]>
+  /** An array return is still honoured — it reads as "no words, and I am not saying why". */
+  authorOutreach( entityId: string, entityName: string, gist?: string ): Promise<string[] | OutreachResult>
+  /**
+   * True while a turn with this person is still resolving — they spoke and the
+   * reply has not landed yet. Optional: an author that cannot say is not blocking.
+   */
+  isSpeakingTo?( entityId: string ): boolean
 }
 
 export class MotorSchemaExecutor implements CognitiveEngine {
@@ -88,6 +136,46 @@ export class MotorSchemaExecutor implements CognitiveEngine {
   private _grants: AccessGrants | null = null
   private _bus: CognitiveBus | null = null
 
+  /**
+   * Two-phase outreach authoring. A facet cannot be awaited from inside a tick:
+   * `ExecutiveFacet.report()` only QUEUES in tick-discipline mode and the reasoning
+   * launches from `pump()`, which the ExecutiveEngine calls once per tick — so an
+   * in-tick `await` blocks the very loop that would produce the answer. Observed
+   * live: a 61s freeze of the whole mind inside one tick, then an empty result.
+   * (It passes unit tests because bare facets have no inbox and author inline.)
+   *
+   * So `_deliver` REQUESTS words and returns false (the intent holds 'awaiting'),
+   * the facet answers off-tick, and a later tick delivers. Process-local by design:
+   * an authoring call in flight cannot survive a restart, and the intent would
+   * simply re-request.
+   */
+  private _authoring = new Set<string>()
+  private _authored  = new Map<string, string[]>()
+  /**
+   * Intents whose facet considered speaking and chose NOT to.
+   *
+   * A declined outreach used to resolve by rotting: no words arrived, so the
+   * intent sat 'awaiting' until AWAIT_TIMEOUT abandoned it as a FAILURE — and
+   * reafference folded that into `reach-out`'s competence. The mind was learning
+   * it is bad at speaking from the times it decided not to speak. Live, a COO
+   * declining correctly ("nothing new to add — a sixth message would repeat")
+   * took a competence hit for the judgement.
+   *
+   * Silence is an ANSWER, not the absence of one. Held here so the sweep can
+   * resolve it as what it is: the intent is freed, and nothing is taught about
+   * an ability that was never in question.
+   */
+  private _withheld  = new Map<string, string>()
+
+  /**
+   * The tick at which each held intent's words were REQUESTED from a facet.
+   *
+   * Authoring is off-tick and can take 10–30s of real time. In that window the
+   * situation the words were composed for can move — and until now nothing
+   * looked. See `situationMoved`.
+   */
+  private _composedAt = new Map<string, Tick>()
+
   constructor( schemas: MotorSchema[] = INNATE_SCHEMAS ){
     for( const s of schemas ) this._schemas.set( s.id, s )
   }
@@ -115,6 +203,7 @@ export class MotorSchemaExecutor implements CognitiveEngine {
       { type: 'agency.enacted',    version: 1, validate: () => null },
       { type: 'agency.invocation', version: 1, validate: () => null },
       { type: 'agency.communicate', version: 1, validate: () => null },
+      { type: 'action.withheld',    version: 1, validate: () => null },
     ]
   }
   subscribes(): string[] { return [] }
@@ -123,7 +212,7 @@ export class MotorSchemaExecutor implements CognitiveEngine {
    * The executor is plan-agnostic. A plan does NOT dispatch steps here — it biases
    * the affordance competition (see PLANNING_AS_PRIOR_TODO.md), so a plan-driven
    * action reaches the executor as an ordinary committed `agency.intent` the
-   * selector won. That intent already carries planId/stepId provenance (stamped by
+   * selector won. That intent already carries its planId/stepId link (stamped by
    * the selector from the winning affordance); `_emitActionOutcome` threads it back
    * out, which is how the PlanningEngine advances. Nothing plan-specific here.
    */
@@ -140,6 +229,10 @@ export class MotorSchemaExecutor implements CognitiveEngine {
     const set: EntityInput[]        = []
     const del: string[]            = []
     const metrics: Array<[ string, number ]> = []
+    // Dispatch announcements bound for the SIMULATION bus — the only one the host
+    // hears. See _emitDispatch: the cognitive copy reaches the mind's own
+    // faculties and reaches no host at all.
+    const events: Array<Omit<SimulationEvent, 'id' | 'timestamp' | 'tick'>> = []
 
     const energy = state.metrics.get('energy.level') ?? 100
     const stress = state.metrics.get('stress.load'  ) ?? 0
@@ -152,6 +245,22 @@ export class MotorSchemaExecutor implements CognitiveEngine {
       if( tick >= num( e.metadata?.['expiresAt'], 0 ) ) del.push( id )
     }
 
+    // ── Expire durable enaction records ──────────────────────────
+    // One per (schema, target), refreshed in place, so the live set is bounded
+    // by pairs actually enacted rather than by enactions — but a Will that meets
+    // many people would still accrete one per person per schema forever, and the
+    // soak test asserts entities plateau. Dropped once no satiation window could
+    // still be reading them: past ENACTED_RETENTION_TICKS the term is 0 anyway,
+    // so the record is indistinguishable from its own absence.
+    for( const [ id, e ] of state.entities ){
+      if( e.type !== ENACTED_TYPE ) continue
+      const at = num( e.metadata?.['tick'], 0 )
+      // A record stamped later than now is a restored one from a previous
+      // session (the tick counter restarts on wake) — same trap `liveConsequences`
+      // documents. Drop it rather than let it read as "just now" all session.
+      if( at > tick || tick - at > ENACTED_RETENTION_TICKS ) 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
@@ -173,18 +282,122 @@ export class MotorSchemaExecutor implements CognitiveEngine {
         else if( parentId && revoked.has( parentId ) ) del.push( id )
       }
 
+    // ── Words that landed off-tick → deliver now ─────────────────
+    // Second half of two-phase authoring: a previous tick asked a facet for the words
+    // and held the intent 'awaiting'; the facet answered between ticks. Runs BEFORE
+    // the timeout sweep so words arriving on the same tick the clock would expire are
+    // still spoken rather than discarded.
+    const spokeThisTick = new Set<string>()
+    for( const [ id, e ] of state.entities ){
+      if( e.type !== 'agency.intent' || str( e.metadata?.['status'] ) !== 'awaiting') continue
+      if( !this._authored.has( id ) ) continue
+
+      const intent = readIntent( id, e.metadata )
+      const predicted: EfferenceCopy = {
+        expectedReward:  num( e.metadata?.['predictedReward'],  intent.expectedReward ),
+        expectedValence: num( e.metadata?.['predictedValence'], intent.expectedValence ),
+      }
+      if( await this._deliver( id, intent, predicted, state, tick, set, del, metrics ) )
+        spokeThisTick.add( id )
+    }
+
+    // Words whose intent no longer exists (revoked, timed out, superseded) are words
+    // that will never be said — drop them so the map cannot grow without bound.
+    for( const id of this._authored.keys() )
+      if( !state.entities.has( id ) ) this._authored.delete( id )
+    for( const id of this._withheld.keys() )
+      if( !state.entities.has( id ) ) this._withheld.delete( id )
+    for( const id of this._composedAt.keys() )
+      if( !state.entities.has( id ) ) this._composedAt.delete( 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
+      // Already delivered above — its outcome and deletion are queued for this tick.
+      if( spokeThisTick.has( id ) ) continue
+      // Words are being authored right now. The clock PAUSES rather than extends: a
+      // facet LLM call is 10–30s of latency we do not control, and any fixed budget
+      // large enough to cover a slow one is also large enough to strand a dead one.
+      // While a call is genuinely in flight the world has not failed to answer. The
+      // pause is bounded, not open-ended: `authorOutreach` always settles (its own 60s
+      // timeout resolves empty), so `_authoring` always clears and the clock resumes.
+      if( this._authoring.has( id ) ) continue
+      // The facet was asked and chose silence. Resolve it as that rather than
+      // letting the clock abandon it as a failure — see `_withheld`.
+      if( this._withheld.has( id ) ){
+        const intent = readIntent( id, e.metadata )
+        const why    = this._withheld.get( id ) ?? 'I considered speaking and chose not to.'
+        set.push({
+          id: `agency-outcome-${ tick }-${ id }`,
+          type: 'agency.outcome',
+          metadata: {
+            schema: intent.schema, intentId: id,
+            targetEntityId: intent.targetEntityId,
+            withheld: true,
+            description: why,
+            mode: 'communicate', tick,
+            ...( intent.planId ? { planId: intent.planId } : {} ),
+            ...( intent.planStepId ? { stepId: intent.planStepId } : {} ),
+          },
+        })
+        del.push( id )
+        this._withheld.delete( id )
+        metrics.push([ 'agency.communicate.withheld', 1 ])
+        // A DISTINCT event, never `action.outcome`: six faculties learn from that
+        // one's `success`, and a withheld turn published as `success: false`
+        // teaches the mind it is bad at speaking from the times it decided not to
+        // speak — the exact regression #123 exists to prevent. This one is read
+        // only by the executive's record of what it did.
+        if( this._bus ){
+          try {
+            this._bus.publish({
+              type: 'action.withheld', version: 1, sourceEngine: this.name,
+              salience: 0.4,
+              payload: {
+                actionType: intent.schema, targetEntityId: intent.targetEntityId,
+                description: why, tick,
+                ...( intent.planId ? { planId: intent.planId } : {} ),
+              },
+            })
+          }
+          catch { /* unregistered schema is telemetry-only */ }
+        }
+        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
+      const age          = tick - dispatchedAt
+
+      // Dispatched LATER than now ⇒ it was in flight when the mind went to sleep.
+      // Intents snapshot with the state and the tick counter restarts at 1 on wake,
+      // so a restored `awaiting` intent has a NEGATIVE age — and every guard here
+      // inverts on it: `age < AWAIT_TIMEOUT` is trivially true for -589, so it never
+      // timed out, and the selector's staleness went negative, INFLATING the
+      // incumbent's strength instead of decaying it. Measured on a live Will:
+      // incumbent 9.742 against challengers of 0.52, unpreemptable and immortal.
+      // One person's stale intent held the channel and every attempt to contact
+      // anyone else was refused, indefinitely, across restarts.
+      //
+      // Cleared WITHOUT a failure outcome: hibernating is not the world declining
+      // to answer. Reconciling it as a timeout would teach reafference that
+      // reaching that person does not work, which is a lesson about the process
+      // lifecycle, not about them.
+      if( age < 0 ){
+        del.push( id )
+        logger.info(
+          `[motor] cleared "${ str( e.metadata?.['schema'] ) ?? 'intent' }" left awaiting ` +
+          `across a restart (dispatched at tick ${ dispatchedAt }, now ${ tick })`
+        )
+        continue
+      }
+
+      if( age < AWAIT_TIMEOUT ) continue
 
       const intent    = readIntent( id, e.metadata )
       const predicted: EfferenceCopy = {
@@ -199,7 +412,8 @@ export class MotorSchemaExecutor implements CognitiveEngine {
       del.push( id )
       this._emitEnacted( intent, timedOut, predicted, tick )
       if( intent.planId && intent.planStepId )
-        this._emitActionOutcome( intent, false, 0, 1, tick )
+        this._emitActionOutcome( intent, false, 0, 1, tick,
+          `No answer came back — I gave up waiting after ${ tick - dispatchedAt } ticks.` )
       logger.info(`[motor] ⏱ "${ intent.schema }" timed out after ${ tick - dispatchedAt } ticks`)
     }
 
@@ -242,7 +456,8 @@ export class MotorSchemaExecutor implements CognitiveEngine {
         enactedCount++
         this._emitEnacted( intent, enaction, predicted, tick )
         this._emitActionOutcome( intent, enaction.success, enaction.outcomeQuality,
-          clamp01( Math.abs( predicted.expectedReward - enaction.outcomeQuality ) ), tick )
+          clamp01( Math.abs( predicted.expectedReward - enaction.outcomeQuality ) ), tick,
+          enaction.description )
 
         // If this was a macro step, advance (or finalize) its parent.
         if( intent.parentIntentId )
@@ -281,6 +496,13 @@ export class MotorSchemaExecutor implements CognitiveEngine {
           set.push( consequenceEntity({
             intentId: id, schema: intent.schema,
             mode: enaction.mode === 'communicate' ? 'communicate' : 'external',
+            // A communicate with no words yet has not happened. The footprint is
+            // still written (P1/P2 want it the moment the words land), but it must
+            // not satiate — attempting to speak is not speaking. See
+            // ConsequenceDescriptor.pending. An EXTERNAL dispatch IS the act: the
+            // host is doing it now, and not asking twice while waiting is exactly
+            // what satiation is for.
+            ...( enaction.mode === 'communicate' && !awaitingText ? { pending: true } : {} ),
             ...( enaction.mode === 'communicate'
               ? { effector: COMM_SCHEMA_TO_EFFECTOR[ intent.schema ] ?? intent.schema }
               : {} ),
@@ -289,7 +511,16 @@ export class MotorSchemaExecutor implements CognitiveEngine {
             paramsHash: fnv1a( paramsKey( intent.parameters ) ),
             expiresAt: tick + CONSEQUENCE_TTL_TICKS, tick,
           }) )
-          this._emitDispatch( intent, enaction.mode, tick )
+          // The durable half, for an act with an object that is not speech.
+          // Speech has `conversation.sent` and objectless acts have
+          // `LearnedSkill.lastEnactedTick`; this is the peer those two left out,
+          // and without it satiation expired with the descriptor at the ECHO
+          // window rather than lasting the satiation window. Written at the same
+          // moment as the descriptor — the dispatch IS the act for an external
+          // effector — and keyed per (schema, target) so it refreshes in place.
+          if( intent.targetEntityId && enaction.mode !== 'communicate')
+            set.push( enactedEntity( intent.schema, intent.targetEntityId, tick ) )
+          events.push( ...this._emitDispatch( intent, enaction.mode, tick, state ) )
           metrics.push([ enaction.mode === 'communicate'
             ? 'agency.communicate.dispatched'
             : 'agency.invocation.dispatched', 1 ])
@@ -298,7 +529,7 @@ export class MotorSchemaExecutor implements CognitiveEngine {
     }
 
     metrics.push([ 'agency.executor.enacted', enactedCount ])
-    return { commands: { set, delete: del, metrics } }
+    return { commands: { set, delete: del, metrics }, ...( events.length > 0 ? { events } : {} ) }
   }
 
   // ── composite machinery ──────────────────────────────────────
@@ -374,7 +605,8 @@ export class MotorSchemaExecutor implements CognitiveEngine {
     this._emitEnacted( compIntent, compEnaction,
       { expectedReward: compIntent.expectedReward, expectedValence: compIntent.expectedValence }, tick )
     this._emitActionOutcome( compIntent, true, avgQuality,
-      clamp01( Math.abs( compIntent.expectedReward - avgQuality ) ), tick )
+      clamp01( Math.abs( compIntent.expectedReward - avgQuality ) ), tick,
+      compEnaction.description )
   }
 
   private _subIntent(
@@ -437,17 +669,62 @@ export class MotorSchemaExecutor implements CognitiveEngine {
       return true
     }
 
-    // Content authored upstream when present (host / host-facet); otherwise, for a
-    // self-initiated communicate the agency just selected, author it now via a facet
-    // — the unified conversation voice, since no inbound triggered it. Empty ⇒ await.
+    // ── Am I mid-sentence with them? ─────────────────────────────
+    // A reply and a self-initiated message are two paths to the same person, and
+    // neither can see the other. Observed live: a conversation facet answered a
+    // question and the agency delivered a proactive message to the same human in
+    // the SAME millisecond — one mind speaking to one person twice at once.
+    //
+    // Holding costs a tick and the words keep. If what they just said changes
+    // what I meant to say, `situationMoved` catches that on the way back round,
+    // which is the outcome we want anyway.
+    if( intent.targetEntityId && this._author?.isSpeakingTo?.( intent.targetEntityId ) ){
+      logger.debug(`[motor] holding "${ intent.schema }" — a turn with ${ intent.targetEntityId } is in flight`)
+      metrics.push([ 'agency.communicate.mid_turn', 1 ])
+      return false
+    }
+
+    // Content authored upstream when present (host / host-facet), else words a facet
+    // authored off-tick and landed since a previous tick asked for them. Neither ⇒
+    // request authoring (never awaited here — see `_authoring`) and hold 'awaiting'.
     const authored = str( intent.parameters['content'] ) ?? firstMessage( intent.parameters['messages'] )
-    let bubbles: string[] = authored ? [ authored ] : []
-    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 ) }`) }
+    const fromFacet = !authored
+    let bubbles: string[] = authored ? [ authored ] : ( this._authored.get( id ) ?? [] )
+    this._authored.delete( id )
+    if( bubbles.length === 0 ){
+      this._requestAuthoring( id, intent, tick )
+      return false   // nothing to send yet → await
+    }
+
+    // ── Is this still what I want to say? ─────────────────────────
+    // Words a facet composed off-tick were formed against the situation as it
+    // stood when they were asked for. Delivering them into a situation that has
+    // since moved is not the act that was decided on — it is an older act
+    // arriving late wearing the present's clothes.
+    //
+    // Live: a COO committed to outreach, was told "I need my full attention on
+    // that right now, will brief you later", acknowledged that correctly — and
+    // 41 seconds later delivered the three-bubble message composed beforehand,
+    // asking for a brain-dump. Same shape at 3am with a colleague who had just
+    // said goodnight: "Night. Talk soon." followed one second later by two
+    // unprompted messages. Satiation cannot damp either, because satiation gates
+    // SELECTION and these were already selected. Nothing looked at the door.
+    //
+    // Only facet-composed words are checked. Content supplied upstream
+    // (`parameters.content`) came from the host or a host-facet with the present
+    // situation in hand, and a reply never reaches this path at all — it is
+    // delivered by the audition facet through the outbox.
+    const moved = fromFacet
+      ? situationMoved( state, intent.targetEntityId, this._composedAt.get( id ) )
+      : null
+    if( moved ){
+      this._withheld.set( id, moved )
+      this._composedAt.delete( id )
+      logger.debug(`[motor] "${ intent.schema }" withheld — ${ moved }`)
+      metrics.push([ 'agency.communicate.stale', 1 ])
+      return false   // resolved as withheld by the sweep: freed, and nothing taught
     }
-    if( bubbles.length === 0 ) return false   // nothing authored to send → await
+    this._composedAt.delete( id )
 
     const request: ActionRequest = {
       effector,
@@ -477,13 +754,75 @@ export class MotorSchemaExecutor implements CognitiveEngine {
         text:     bubbles.join('\n'),
         expiresAt: tick + CONSEQUENCE_TTL_TICKS, tick,
       }) )
+    // The words are out. Whatever willed them is DONE being an intention.
+    //
+    // Discharged here rather than at dispatch on purpose: `_deliver` holds the
+    // intent 'awaiting' while a facet authors, and that authoring can time out or
+    // return nothing. Clearing the will at dispatch would lose the intention
+    // silently — the mind would have decided to say something and simply never
+    // have, which is the failure `commands.ts` calls "the whole intention
+    // evaporated without a trace". Enaction is the discharge; a request is not.
+    if( result.success ) this._dischargeWill( intent, del )
+
     this._emitEnacted( intent, out, predicted, tick )
     this._emitActionOutcome( intent, result.success, result.feedback.outcomeQuality,
-      clamp01( Math.abs( predicted.expectedReward - result.feedback.outcomeQuality ) ), tick )
+      clamp01( Math.abs( predicted.expectedReward - result.feedback.outcomeQuality ) ), tick,
+      out.description )
     metrics.push([ 'agency.communicate.delivered', 1 ])
     return true
   }
 
+  /**
+   * Ask a facet for the words, off-tick. Fire-and-forget on purpose: awaiting this
+   * from inside `react()` deadlocks the tick loop against the facet pump. Idempotent
+   * per intent — a request already in flight is not duplicated, so the intent may sit
+   * 'awaiting' across many ticks with exactly one LLM call behind it.
+   */
+  private _requestAuthoring( id: string, intent: Intent, tick: Tick ): void {
+    if( !this._author || this._authoring.has( id ) ) return
+
+    const name = str( intent.parameters['targetEntityName'] ) ?? intent.targetEntityId ?? 'them'
+    this._authoring.add( id )
+    this._composedAt.set( id, tick )
+    void this._author
+      .authorOutreach( intent.targetEntityId ?? '', name, str( intent.parameters['gist'] ) )
+      .then( result => {
+        const bubbles  = Array.isArray( result ) ? result : result.bubbles
+        const declared = !Array.isArray( result ) && result.withheld === true
+        const answered = !Array.isArray( result ) && result.answered === true
+
+        if( bubbles.length > 0 ){ this._authored.set( id, bubbles ); return }
+
+        // Not a warning: the facet was asked and answered. Choosing not to speak
+        // is a decision the mind is entitled to make.
+        if( declared ){
+          this._withheld.set( id, 'I considered speaking and chose not to.')
+          logger.debug(`[motor] "${ intent.schema }" withheld — the facet chose silence`)
+          return
+        }
+        // Asked, reasoned, and came back with nothing — neither words nor a
+        // declared silence. That is still an answer, and re-asking puts the same
+        // question to the same mind against the same situation, so it comes back
+        // the same way. Nineteen times, in the run this exists to prevent.
+        //
+        // Resolved as withheld rather than failed on purpose: nothing was said,
+        // and nothing should be taught about being bad at speaking — the #123
+        // regression. The reason is worded for what actually happened.
+        if( answered ){
+          this._withheld.set( id, 'I turned it over and came back with no words.')
+          logger.info(`[motor] "${ intent.schema }" withheld — the pass produced no words`)
+          return
+        }
+
+        // No pass ran at all — a dead author, a full budget, or one deferring to
+        // a pass already in flight. Keep holding: the clock is the right judge of
+        // those, and the deferring case wants to come back round.
+        logger.warn(`[motor] outreach authoring never ran for "${ intent.schema }"`)
+      } )
+      .catch( err => { logger.warn(`[motor] outreach authoring failed: ${ errMsg( err ) }`) } )
+      .finally( () => { this._authoring.delete( id ) } )
+  }
+
   // ── bus emission ─────────────────────────────────────────────
 
   private _emitEnacted( intent: Intent, enaction: Enaction, predicted: EfferenceCopy, tick: Tick ): void {
@@ -506,8 +845,48 @@ export class MotorSchemaExecutor implements CognitiveEngine {
    * RewardEvaluator reads it as a reward signal. `confidence` carries the agency's
    * own forward-model prior so calibration has a real prediction to score.
    */
+  /**
+   * Retire the `ideomotor.intent` that produced this act.
+   *
+   * Nothing deleted these. They were cleared only when the executive next ran and
+   * declined to name the same action again — and the executive runs on an interval,
+   * so between cycles a willed reach-out STOOD in state, was rebuilt into an
+   * affordance every single tick, and competed every single tick. Observed as
+   * dozens of identical lines:
+   *
+   *   [selector] willed reach-out → … NOT selected: 0.297 < inspect… 0.340
+   *
+   * losing by four thousandths, over and over, until it won — twice. Fabrice got
+   * the same message byte-for-byte 25 ticks apart, two outbox ids.
+   *
+   * `justEnacted` was built to hold this line and cannot: it is a DECAYING
+   * quantity, capped at `repeatDamping` (0.30), and a standing intent outlasts it
+   * by construction. Damping a permanent pull only ever delays it. So the intention
+   * is discharged by being acted on, which is what an intention is — you meant to
+   * tell someone something, you told them, and it is finished. If the mind still
+   * wants to say more, the next executive cycle forms a new one, now seeing "I said
+   * this 25 ticks ago and have had no answer" in front of it.
+   *
+   * Satiation stays exactly as it was, and still earns its keep: it damps saying
+   * the same thing again for reasons that did NOT come from a standing will.
+   */
+  private _dischargeWill( intent: Intent, del: string[] ): void {
+    const willId = intent.evokedBy
+    if( !willId || !willId.startsWith('ideomotor-') ) return
+    del.push( willId )
+    logger.info(`[motor] discharged the will behind "${ intent.schema }" (${ willId })`)
+  }
+
   private _emitActionOutcome(
     intent: Intent, success: boolean, outcomeQuality: number, surprise: number, tick: Tick,
+    /**
+     * What happened, in words. This payload builds `action.record`, which the
+     * prompt renders as `## What Became Of What I Did` — and until now this method
+     * published no description at all, so that section showed the action's NAME
+     * and nothing else. Sixty-five lookups rendered as sixty-five lines saying
+     * `discord_lookup_member` and never once what was found.
+     */
+    description?: string,
   ): void {
     if( !this._bus ) return
     try {
@@ -518,6 +897,7 @@ export class MotorSchemaExecutor implements CognitiveEngine {
           actionType:     intent.schema,
           domain:         intent.schema,
           confidence:     intent.expectedReward,
+          ...( description ? { description } : {} ),
           success,
           outcomeQuality,
           surprise,
@@ -531,21 +911,67 @@ export class MotorSchemaExecutor implements CognitiveEngine {
     catch( err ){ logger.warn(`[motor] action outcome publish failed: ${ errMsg( err ) }`) }
   }
 
-  private _emitDispatch( intent: Intent, mode: 'communicate' | 'external', tick: Tick ): void {
-    if( !this._bus ) return
-    try {
-      this._bus.publish({
-        type: mode === 'communicate' ? 'agency.communicate' : 'agency.invocation',
-        version: 1, sourceEngine: this.name, salience: 0.6,
-        payload: {
+  /**
+   * Announce a dispatched act to its TWO audiences, which live on two buses.
+   *
+   * The mind's own faculties appraise it — affective.blender, stress.regulator
+   * and attention.allocator all subscribe to `agency.invocation` on the
+   * CognitiveBus, the internal fabric. But the act is host-owned, and the HOST
+   * hears only `simulation.eventBus`: `WillStem` buffers an invocation for
+   * delivery from `eventBus.subscribeAll`, and that is the sole path by which an
+   * external effector ever reaches a handler.
+   *
+   * Only the cognitive half was ever published. The two buses have no bridge, so
+   * `bufferInvocation` was subscribed to a bus that has never carried the event
+   * — measured on a live boot: `agency.invocation.dispatched` incremented,
+   * `pendingEffectorInvocations` stayed empty, the intent held `awaiting`, and
+   * fifteen ticks later `[motor] ⏱ "inspect" timed out`. **No host-owned
+   * effector invocation has ever been delivered.** Communication is unaffected —
+   * the outbox is a separate mechanism, which is why a Will could always speak.
+   *
+   * Both ends were unit-tested and the crossing was not: `policy.*.test.ts` calls
+   * `bufferInvocation` directly, which is true about the controller and silent
+   * about whether anything reaches it. Same shape as the affordance-field hop.
+   */
+  private _emitDispatch(
+    intent: Intent, mode: 'communicate' | 'external', tick: Tick,
+    state?: ReadonlySimulationState,
+  ): Array<Omit<SimulationEvent, 'id' | 'timestamp' | 'tick'>> {
+    const payload = this._dispatchPayload( intent, tick, state )
+    const type    = mode === 'communicate' ? 'agency.communicate' : 'agency.invocation'
+
+    if( this._bus )
+      try {
+        this._bus.publish({ type, version: 1, sourceEngine: this.name, salience: 0.6, payload })
+      }
+      catch( err ){ logger.warn(`[motor] dispatch publish failed: ${ errMsg( err ) }`) }
+
+    // The observable bus — where the host is listening.
+    return [ { type, source: this.name, payload } ]
+  }
+
+  private _dispatchPayload(
+    intent: Intent, tick: Tick, state?: ReadonlySimulationState,
+  ): Record<string, unknown> {
+    return {
           schema: intent.schema, intentId: intent.id,
           targetEntityId: intent.targetEntityId, parameters: intent.parameters, tick,
           // The ability's declared meaning, carried to the host handler.
           description: this._resolve( intent.schema )?.description,
-        },
-      })
+          // Where in the world this referent is, so a host can act on it at all.
+          //
+          // The target is an ANCHOR (`ke:1sqlkux`) — 0.9.0 made identity opaque and
+          // separate from address on purpose. A bridge holds channel ids and knows
+          // nothing of anchors, so an invocation naming only the referent is one no
+          // surface can serve. The outbox hit this first and solved it the same way
+          // (mind.ts attachRouting): resolve inside, where the alias table lives.
+          //
+          // Outbound only. This is the mind telling the world which of its own
+          // handles it means — the reverse direction, a surface writing an address
+          // into the mind, is what perception is for.
+          ...( state && intent.targetEntityId
+            ? { targetAddresses: addressesOf( state.entities, intent.targetEntityId ) } : {} ),
     }
-    catch( err ){ logger.warn(`[motor] dispatch publish failed: ${ errMsg( err ) }`) }
   }
 }
 
@@ -588,6 +1014,7 @@ function readIntent( id: string, m: ReadonlyMap<string, unknown> | Record<string
     stepIndex:       typeof meta['stepIndex'] === 'number' ? ( meta['stepIndex'] as number ) : undefined,
     planId:          str( meta['planId'] ),
     planStepId:      str( meta['stepId'] ),
+    evokedBy:        str( meta['evokedBy'] ),
   }
 }
 
@@ -608,3 +1035,53 @@ function clamp01( n: number ): number {
 function errMsg( err: unknown ): string {
   return err instanceof Error ? err.message : String( err )
 }
+
+/**
+ * Has the situation these words were composed for moved on?
+ *
+ * Returns the mind's own account of what changed, or null if the moment still
+ * stands. The account is what the withheld outcome records, so the mind's
+ * history says why it did not speak rather than merely that it didn't.
+ *
+ * The evidence is `conversation.sent` — the durable record of having spoken,
+ * written by every path that speaks (ProactiveCommunicator, the audition facet,
+ * the outbox). If I have said something to this person SINCE these words were
+ * asked for, then these are not my current words to them: I have already
+ * responded to whatever moved in between, and this is an older turn arriving on
+ * top of a newer one.
+ *
+ * And `answeredAt` — when they last spoke to ME. This arm was missing at first,
+ * excluded on the argument that `conversation.received` is a one-shot entity
+ * swept on the tick it is scanned so nothing durable records the other
+ * direction. That was wrong: `answeredAt` is the durable half, folded onto the
+ * mind's own sent turns, and it is what renders "they answered" in the prompt.
+ *
+ * The gap was the COMMON case, not an edge. Live, a COO delivered a pre-composed
+ * agenda message ("I need a list of what's actively in flight…") two seconds
+ * after the person changed the subject, having said nothing in between — so the
+ * stale words arrived BEFORE her real reply and the spoken-since arm had not
+ * fired yet. The two signals were assumed to coincide and do not: whoever moved
+ * the situation, it moved.
+ *
+ * A missing `composedAt` means the words were never requested through
+ * `_requestAuthoring` — nothing is known about when they were formed, so nothing
+ * is claimed and they go out. Silence beats a guess here: withholding on absent
+ * evidence would mute a mind for reasons it could not name.
+ */
+export function situationMoved(
+  state:          ReadonlySimulationState,
+  targetEntityId: string | undefined,
+  composedAt:     Tick | undefined,
+): string | null {
+  if( composedAt === undefined || !targetEntityId ) return null
+
+  const heard = lastAnsweredByEntity( state.entities as never ).get( targetEntityId )
+  if( heard !== undefined && heard > composedAt )
+    return 'They said something after I composed this, so it is an answer to a moment that has passed.'
+
+  const spoke = spokenAtByEntity( state.entities as never ).get( targetEntityId )
+  if( spoke !== undefined && spoke > composedAt )
+    return 'I had already spoken to them since composing this, so it was no longer what I had to say.'
+
+  return null
+}