@mindot/will 0.8.0 → 0.9.0

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

@@ -71,6 +71,11 @@ 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
 }
 
 /** Authors the words for a self-initiated communicate the agency selected (no inbound triggered it). */
@@ -88,6 +93,22 @@ 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[]>()
+
   constructor( schemas: MotorSchema[] = INNATE_SCHEMAS ){
     for( const s of schemas ) this._schemas.set( s.id, s )
   }
@@ -173,18 +194,76 @@ 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 )
+
     // ── 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
       // 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 = {
@@ -437,17 +516,16 @@ 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.
+    // 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 ) }`) }
+    let bubbles: string[] = authored ? [ authored ] : ( this._authored.get( id ) ?? [] )
+    this._authored.delete( id )
+    if( bubbles.length === 0 ){
+      this._requestAuthoring( id, intent )
+      return false   // nothing to send yet → await
     }
-    if( bubbles.length === 0 ) return false   // nothing authored to send → await
 
     const request: ActionRequest = {
       effector,
@@ -477,6 +555,16 @@ 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 )
@@ -484,6 +572,27 @@ export class MotorSchemaExecutor implements CognitiveEngine {
     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 ): void {
+    if( !this._author || this._authoring.has( id ) ) return
+
+    const name = str( intent.parameters['targetEntityName'] ) ?? intent.targetEntityId ?? 'them'
+    this._authoring.add( id )
+    void this._author
+      .authorOutreach( intent.targetEntityId ?? '', name, str( intent.parameters['gist'] ) )
+      .then( bubbles => {
+        if( bubbles.length > 0 ) this._authored.set( id, bubbles )
+        else logger.warn(`[motor] outreach authoring returned nothing 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,6 +615,38 @@ 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,
   ): void {
@@ -588,6 +729,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'] ),
   }
 }
 

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

@@ -31,6 +31,10 @@ import type { SchemaRepertoire } from '#agency/schemas/repertoire'
 import { schemaEntityId, availabilityEntityId } from '#agency/schemas/repertoire'
 import { asFinality } from '#stem/policy/arbiter'
 import { AWAIT_TIMEOUT } from '#agency/engines/motor.schema.executor'
+import { readEffectiveParams } from '#cognition/persona.prior'
+import {
+  SENT_TYPE, DEFAULT_REPLY_WINDOW_TICKS, resolveReplyExpectations,
+} from '#agency/conversation.aim'
 
 const PROC_THRESHOLD = 0.60   // mirror of repertoire's threshold for the habitual-count metric
 
@@ -81,6 +85,11 @@ export class ReafferenceEngine implements CognitiveEngine {
       // action.outcome the PlanningEngine advances on. (The executor is the emitter
       // for sync/timeout outcomes; this is its async counterpart — one emitter each.)
       { type: 'action.outcome',              version: 1, validate: () => null },
+      // Whether a person answers the mind when it speaks to them. Distinct from
+      // `interaction.occurred`, which reports something someone DID — a silence is
+      // not an act and so can never appear there, which is why "they never answer
+      // me" was unlearnable despite `socialStanding` being built to carry it.
+      { type: 'social.responsiveness',       version: 1, validate: () => null },
     ]
   }
   /** Creation seam: register a composite proposed by the executive/deliberation facet. */
@@ -281,6 +290,19 @@ export class ReafferenceEngine implements CognitiveEngine {
     // Availability entries (P2) mirror the same way — empty until a refusal lands.
     for( const e of this._repertoire.availabilityEntities() ) set.push( e )
 
+    // ── 3.5 Did the words achieve what they were for? ────────────
+    // The motor loop above graded whether each act EXECUTED. For a communicative
+    // act that is the smaller half of the question: the outbox accepting a message
+    // is not the world answering it. Both were the same fact until now, which is
+    // how `reach-out` came to sit at 28 enactments / 28 successes while the person
+    // it kept reaching had said nothing back.
+    //
+    // Folded here rather than in a new engine because this is the same question
+    // this engine already exists to ask, one layer out — reafference over a social
+    // act instead of a motor one. The resolution itself is pure (conversation.aim);
+    // all that happens here is writing it down and saying it out loud.
+    const replied = this._resolveReplies( tick, state, set )
+
     // ── 4. Telemetry ─────────────────────────────────────────────
     const skills    = this._repertoire.skills()
     const habitual  = [ ...skills.values() ].filter( s => s.habitStrength >= PROC_THRESHOLD ).length
@@ -291,6 +313,10 @@ export class ReafferenceEngine implements CognitiveEngine {
       [ 'agency.habitual.count',   habitual ],
       [ 'agency.sensory.confirmed', sensory ],
     )
+    // Quiet path stays byte-identical: a Will that has spoken to nobody, or whose
+    // every turn was answered, writes nothing here (cf. EXAFFERENCE P3).
+    if( replied.answered   > 0 ) metrics.push([ 'social.answered.count',   replied.answered ])
+    if( replied.unanswered > 0 ) metrics.push([ 'social.unanswered.count', replied.unanswered ])
     // Only emit the refusal metric when it fired — a never-refused Will writes
     // nothing here, preserving the byte-identical quiet path (cf. EXAFFERENCE P3).
     if( refused > 0 ) metrics.push([ 'agency.refused.count', refused ])
@@ -298,6 +324,97 @@ export class ReafferenceEngine implements CognitiveEngine {
     return { commands: { set, delete: del, metrics } }
   }
 
+  /**
+   * Latch each open turn's fate onto its own record and announce it once.
+   *
+   * Two rules earn their keep here:
+   *
+   *  • MERGE, never replace. `StateManager.setEntity` overwrites the whole entity,
+   *    and a `conversation.sent` carries `outboxMessageIds` — the sole key by which
+   *    a later delivery ack can find it. Rewriting the record with only the fields
+   *    this method cares about would sever that, silently, for every turn that got
+   *    an answer.
+   *
+   *  • Latch, don't recompute. `answeredAt`/`unansweredAt` persist, so the event
+   *    fires on the one tick the fact changed rather than every tick for the rest
+   *    of the session — which for an unanswered turn would be thousands of
+   *    identical reputation hits against one person for one silence.
+   */
+  private _resolveReplies(
+    tick:  Tick,
+    state: ReadonlySimulationState,
+    set:   EntityInput[],
+  ): { answered: number; unanswered: number } {
+    // A trait, not a constant: how long a silence takes to mean something differs
+    // between minds, so it tunes through the persona prior like every other
+    // developable parameter. Absent ⇒ the default ⇒ the pre-seam behaviour.
+    //
+    // Read from the SELECTOR's config despite being applied here, because it and
+    // `repeatWindowTicks` are two readings of one disposition — how long this mind
+    // sits with something it has said. Held apart, a mind could tune itself into
+    // saying a thing again while still calling the silence too fresh to count.
+    const window = Math.max(
+      1,
+      Math.round(
+        readEffectiveParams( state, 'engine-config-action-selector').replyWindowTicks
+          ?? DEFAULT_REPLY_WINDOW_TICKS
+      ),
+    )
+
+    const { answered, unanswered } = resolveReplyExpectations( state.entities, tick, window )
+    if( answered.length === 0 && unanswered.length === 0 ) return { answered: 0, unanswered: 0 }
+
+    const merge = ( id: string, patch: Record<string, unknown> ): void => {
+      const existing = state.entities.get( id )
+      if( !existing ) return
+      set.push({
+        id, type: SENT_TYPE,
+        metadata: { ...( existing.metadata as Record<string, unknown> ?? {} ), ...patch },
+      })
+    }
+
+    for( const { turn, at, with: said } of answered ){
+      // Their words, not merely the fact of them — see SpokenTurn.answeredWith.
+      merge( turn.entityId, { answeredAt: at, ...( said ? { answeredWith: said } : {} ) } )
+      this._emitResponsiveness( turn.targetEntityId, true, at - turn.tick, tick )
+    }
+
+    for( const turn of unanswered ){
+      merge( turn.entityId, { unansweredAt: tick } )
+      this._emitResponsiveness( turn.targetEntityId, false, tick - turn.tick, tick )
+      logger.info(
+        `[reafference] no answer from ${ turn.targetEntityName ?? turn.targetEntityId } ` +
+        `after ${ tick - turn.tick } ticks — "${ turn.preview.slice( 0, 60 ) }"`
+      )
+    }
+
+    return { answered: answered.length, unanswered: unanswered.length }
+  }
+
+  /**
+   * Publish how a person responded to being spoken to.
+   *
+   * Deliberately NOT an `interaction.occurred`: that event means "someone did
+   * something toward us" and carries a valence for what they did. A silence is
+   * nobody doing anything, and forcing it through that channel would have the
+   * ReputationTracker book a hostile *act* where there was only an absence — the
+   * mind would come to think it was being rebuffed rather than simply not
+   * answered yet. Separate signal, separate meaning, one consumer decides what
+   * either is worth.
+   */
+  private _emitResponsiveness( keid: string, answered: boolean, waitedTicks: number, tick: Tick ): void {
+    if( !this._bus ) return
+    try {
+      this._bus.publish({
+        type: 'social.responsiveness', version: 1, sourceEngine: this.name,
+        // An answer is ordinary; being ignored is the one worth interrupting for.
+        salience: answered ? 0.3 : 0.55,
+        payload: { keid, answered, waitedTicks, tick },
+      })
+    }
+    catch( err ){ logger.warn(`[reafference] responsiveness publish failed: ${ err instanceof Error ? err.message : String( err ) }`) }
+  }
+
   private _emitProceduralized( skill: LearnedSkill, tick: Tick ): void {
     if( !this._bus ) return
     try {

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

@@ -190,7 +190,17 @@ export class ProactiveCommunicator {
     // Generate outbox message IDs first so we can embed them in conversation.sent
     // and correlate deliveries back to this intent (TODO 11.3).
     const originalMessage  = ( request.parameters?.originalMessage as string ) ?? ''
-    const deliveryTick     = ( request.parameters?.tick as number ) ?? 0
+    // `decidedAt` is the enacting tick and is always set by the caller; the
+    // `parameters.tick` fallback is for hosts that build a request by hand.
+    //
+    // This defaulted to 0 for every agency-path delivery, because MotorSchemaExecutor
+    // builds `parameters` from the intent and never put a tick in it. Two
+    // consequences, both silent: every `conversation.sent` was stamped tick 0, so
+    // anything comparing against it (satiation, undertaking discharge) compared
+    // against zero and never fired; and the id `conv-sent-<target>-0` was CONSTANT,
+    // so each send to a person overwrote the record of the last one — the mind kept
+    // exactly one memory of having spoken to each person, forever.
+    const deliveryTick     = ( request.parameters?.tick as number ) ?? request.decidedAt ?? 0
     const replyToMessageId = ( request.parameters?.replyToMessageId as string ) ?? undefined
     const isAck            = ( request.parameters?.isAck as boolean ) ?? false
 
@@ -264,9 +274,15 @@ export class ProactiveCommunicator {
       description: `I reach out to ${targetEntityName}: "${fullReply.slice( 0, 80 )}${fullReply.length > 80 ? '…' : ''}"`,
       commands,
       feedback: {
-        outcomeQuality: 0.85,
+        // NOT a success yet. This reports the TRANSPORT, and the act's point is to be
+        // answered — an outcome not yet known at this moment. Scoring delivery as 0.85
+        // taught the mind that reaching out works every time, including the times it
+        // was ignored, which is why it re-asked the same question 19 times in two
+        // minutes. Neutral here; the unanswered/answered signal in outreach.silence.ts
+        // is what actually moves the pull toward this person.
+        outcomeQuality: 0.5,
         surprise: 0.15,
-        lessons: [ `My message is queued for delivery to ${targetEntityName}.` ],
+        lessons: [ `My words are on their way to ${targetEntityName}. Whether they land is not yet known.` ],
       },
     }
   }

package/src/cognition/agency/restart.ts

@@ -0,0 +1,66 @@
+// ─────────────────────────────────────────────────────────────
+// src/cognition/agency/restart.ts  —  the restart boundary
+// ─────────────────────────────────────────────────────────────
+//
+// Two different things happen when a Will wakes from a snapshot, and conflating
+// them is what made this a recurring class of bug rather than a single one:
+//
+//   1. TIME must not go backwards. Entities come back stamped with the tick they
+//      were written at, so the clock has to resume from the snapshot's tick
+//      rather than restart at 0 (WillStem.createWill does this via
+//      `clock.setTick`). Otherwise every `tick - stampedTick` in the codebase —
+//      42 comparison sites across 19 files — computes a NEGATIVE age, and the
+//      guards built on them inverted spectacularly: an awaiting intent whose age
+//      read -589 could never time out, and the selector's staleness decay
+//      `1 - staleness × STALE_DECAY` became `1 + 19.6`, AMPLIFYING an incumbent
+//      from 0.47 to 9.74 and making it permanently unpreemptable.
+//
+//   2. Work that was IN FLIGHT does not resume. Resuming the clock fixes the
+//      arithmetic but says nothing about the semantics: an action dispatched
+//      moments before hibernation is not still dispatched hours later, and the
+//      window in which the world might have echoed our own words has closed.
+//      Leaving these behind is worse under a resumed clock than under a reset
+//      one, because they now look plausibly RECENT — an awaiting intent would be
+//      reconciled as a genuine timeout, teaching the mind that reaching that
+//      person does not work, when all that happened is that it slept.
+//
+// This module owns (2): what the agency considers in-flight, and therefore what
+// must not cross the boundary. It is deliberately a short, explicit list rather
+// than a heuristic — anything the agency stamps with a tick and expects to
+// resolve within a few of them belongs here.
+// ─────────────────────────────────────────────────────────────
+
+import { CONSEQUENCE_TYPE } from '#agency/consequence'
+
+/** Entity type of a committed action awaiting the world's answer. */
+const INTENT_TYPE = 'agency.intent'
+
+/**
+ * Ids of the restored entities that represent work in flight when the mind went
+ * to sleep. Pure — the caller drops them.
+ *
+ *   • `agency.intent` with status 'awaiting' — dispatched, never answered. It is
+ *     ABANDONED, not failed: sleeping is not the world declining to answer, and
+ *     recording a failure here would teach reafference a lesson about the process
+ *     lifecycle rather than about the action.
+ *   • `agency.consequence` — the expected sensory footprint of an act, used both
+ *     to recognise our own echo (P2) and to damp repeating ourselves (P5). Its
+ *     TTL is a handful of ticks; across a sleep the echo will never arrive, and a
+ *     stale one both mis-attributes genuine replies as self-caused and suppresses
+ *     contact that should now be free to happen.
+ *
+ * A `selected` intent is deliberately NOT cleared: it has not been dispatched, so
+ * it is still an intention the mind holds rather than an action in flight.
+ */
+export function inFlightOnRestore(
+  entities: ReadonlyMap<string, { type: string; metadata?: Record<string, unknown> }>,
+): string[] {
+  const drop: string[] = []
+
+  for( const [ id, e ] of entities ){
+    if( e.type === CONSEQUENCE_TYPE ){ drop.push( id ); continue }
+    if( e.type === INTENT_TYPE && e.metadata?.['status'] === 'awaiting') drop.push( id )
+  }
+
+  return drop
+}

package/src/cognition/agency/selection.scoring.ts

@@ -13,6 +13,8 @@
 //              + driveUrgency
 //              + habitStrength·W                              (additive habit bonus)
 //              + planBias·W                                   (top-down prior)
+//              + willBias·W                                   (deliberate volition)
+//              + socialPrior·W                                (learned read on WHO)
 //              − cost
 //              − inhibition
 //              − risk
@@ -47,9 +49,34 @@ export interface ScoreWeights {
   habit:   number
   /** Top-down planning prior — how strongly an executing plan biases the competition. */
   plan:    number
+  /**
+   * Volitional prior — how strongly a DELIBERATE executive decision biases the
+   * competition. Peer of `plan`: a plan's frontier is a standing prior, a willed act
+   * is a prior formed this cycle. Strong enough that no habit (≤1) can out-weigh a
+   * confident decision, weak enough that inhibition, threat, or a genuinely more
+   * pressing affordance still can — willing is not a rubber stamp.
+   */
+  will:    number
+  /**
+   * How strongly the mind's LEARNED read on an addressee biases acting toward them.
+   * Peer of `goal` in magnitude: who someone has shown themselves to be should weigh
+   * about as much as a goal pointed at them. Signed — a person the mind has come to
+   * trust pulls it toward contact, one who never answers pulls it away — and it
+   * reaches zero for anyone unknown, so a mind that knows no one scores as before.
+   */
+  social:  number
   cost:    number
   inhib:   number
   risk:    number
+  /**
+   * How strongly an act's own live footprint damps doing it again (EXAFFERENCE
+   * P5). Satiation, not a lock: it decays with the descriptor, so the pull
+   * returns once the window in which the world could have answered has passed.
+   * Peer of `will` in magnitude — a freshly-delivered message should roughly
+   * cancel the volitional prior that produced it, and no more, so a genuinely
+   * pressing reason to speak again still wins.
+   */
+  repeat:  number
 }
 
 export const DEFAULT_WEIGHTS: ScoreWeights = {
@@ -59,9 +86,12 @@ export const DEFAULT_WEIGHTS: ScoreWeights = {
   drive:   0.25,
   habit:   0.20,
   plan:    0.30,
+  will:    0.30,
+  social:  0.30,
   cost:    0.20,
   inhib:   0.30,
   risk:    0.20,
+  repeat:  0.30,
 }
 
 /**
@@ -154,9 +184,12 @@ export function scoreAffordance(
     + w.drive   * driveUrgency( a, bias )
     + w.habit   * a.habitStrength
     + w.plan    * ( a.planBias ?? 0 )
+    + w.will    * ( a.willBias ?? 0 )
+    + w.social  * ( a.socialPrior ?? 0 )
     - w.cost    * a.cost
     - w.inhib   * bias.inhibition
     - w.risk    * risk( a, bias )
+    - w.repeat  * ( a.justEnacted ?? 0 )
   )
   // POLICY_REAFFERENCE P2 — policy availability damps a POSITIVE activation only,
   // never flipping its sign: a refused ability competes weakly (so it is rarely

package/src/cognition/agency/types.ts

@@ -140,6 +140,29 @@ export interface Affordance {
    * competition WITHOUT bypassing it (the plan biases; the field still decides).
    */
   planBias?:       number
+  /**
+   * Top-down volitional bias 0..1 — set when the executive DELIBERATELY willed this
+   * affordance (source 'ideomotor'), carrying the confidence it decided with. Like
+   * planBias it lifts activation without bypassing the competition: a willed act must
+   * still out-compete the field, but it no longer arrives with the same standing as an
+   * ambient possibility. Without this term the ideomotor leg created candidates the
+   * arithmetic could not tell apart from idle ones, and a cheap unconditional reflex
+   * ('express', cost 0.02) beat a deliberate 'reach-out' 176 times out of 176.
+   */
+  willBias?:       number
+  /**
+   * Learned social standing of this affordance's addressee, −1..1 (0 = neutral or
+   * unknown). Set only for an act aimed at someone. Every input is LEARNED, none
+   * hardcoded: ReputationTracker's trustworthiness — which is fed by
+   * `interaction.occurred` and so only became live once inbound conversation reached
+   * social cognition (#113) — weighted by that model's own confidence, plus the mind's
+   * current affective tone as a gentle tilt on reaching out at all.
+   *
+   * This is what makes "they never answer me" reach the competition: it arrives as a
+   * fading opinion of a person the mind formed itself and can revise, not as a damping
+   * curve applied behind its back.
+   */
+  socialPrior?:    number
   /**
    * Policy availability 0..1 (POLICY_REAFFERENCE P2) — learned from refusals,
    * distinct from `available` (precondition satisfaction) and from competence.
@@ -149,6 +172,18 @@ export interface Affordance {
    * gets an occasional re-probe and can climb back as availability recovers.
    */
   availability?:   number
+  /**
+   * How much of this act's OWN footprint is still live, 1 → 0 (EXAFFERENCE P5).
+   * Set when a consequence descriptor for the same (schema, target) has not yet
+   * expired — the mind has just done this and does not yet know how it landed.
+   *
+   * Damps the pull to do it again, and decays back to 0 on its own, so a silence
+   * that starts to matter can still out-compete it. Without this the executive's
+   * standing `ideomotor.intent` outlived the act it produced: the same two
+   * messages were delivered to the same person three times, ~21 ticks apart,
+   * each time as though it were the first.
+   */
+  justEnacted?:    number
   /** Provenance: the plan whose frontier step projected this affordance. */
   planId?:         string
   /** Provenance: the frontier step id — flows through to action.outcome so the plan advances. */