@mindot/will 0.7.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

@@ -29,7 +29,12 @@ import type { CognitiveEngine, EngineResult } from '#cognition/types'
 import type { CognitiveEventSchema } from '#cognition/schema.registry'
 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
 
@@ -80,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. */
@@ -201,8 +211,17 @@ export class ReafferenceEngine implements CognitiveEngine {
       // is merely forbidden to do. The awaiting intent is still freed, and a
       // refused plan step is signalled unsuccessful so the plan doesn't hang.
       if( m['refused'] === true ){
-        const finality = str( m['finality'] ) === 'class' ? 'class' : 'instance'
-        this._repertoire.recordRefusal( schema, finality, tick )
+        const finality = asFinality( m['finality'] )
+
+        // P5 — 'context' means the refusal was NOT ABOUT THE ACTION (tainted
+        // context, an unavailable dependency, the arbiter itself down). Denting
+        // availability here would teach a lesson the policy never taught:
+        // "reach for this less", when nothing about the ability was the problem.
+        // So the intent is freed and the plan step signalled — the mind must not
+        // hang — and NOTHING else is written. Not competence, not availability.
+        if( finality !== 'context')
+          this._repertoire.recordRefusal( schema, finality, tick )
+
         if( fromState ) del.push( id )
         const refusedIntent = str( m['intentId'] )
         if( refusedIntent ) del.push( refusedIntent )
@@ -271,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
@@ -281,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 ])
@@ -288,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/reconcile.learning.ts

@@ -16,6 +16,7 @@
 // ─────────────────────────────────────────────────────────────
 
 import type { EntityInput, Tick } from '#core/types'
+import type { DenialFinality, PolicyCounterfactual } from '#stem/policy/arbiter'
 
 export interface HostAckResult {
   success:        boolean
@@ -31,7 +32,17 @@ export interface HostAckResult {
    * forbidden to do. `finality` decides how hard availability is cut.
    */
   refused?:       boolean
-  finality?:      'class' | 'instance'
+  finality?:      DenialFinality
+  /**
+   * ENVELOPE_NARROWING P0 — what WOULD have been permitted, e.g.
+   * `{ field: 'amount', requested: 500, allowed: 100 }`.
+   *
+   * Carried onto the outcome so the tape and the thing the mind actually learns
+   * from agree about what happened. Until ENVELOPE_NARROWING P1 lands nothing
+   * READS it — that fold is blocked upstream on whether a scalar `allowed` is a
+   * ceiling or a floor — but dropping it here is what made the two disagree.
+   */
+  counterfactual?: PolicyCounterfactual
 }
 
 /**
@@ -79,7 +90,10 @@ export function reconcileInvocation(
       mode:             'external',
       tick,
       reconciled:       true,
-      ...( result.refused ? { refused: true, finality: result.finality ?? 'instance' } : {} ),
+      ...( result.refused ? { refused: true, finality: result.finality ?? 'parameter' } : {} ),
+      // Only when the arbiter actually reported a bound — a refusal without one
+      // writes no key at all, so the quiet path is unchanged.
+      ...( result.refused && result.counterfactual ? { counterfactual: result.counterfactual } : {} ),
       ...( provenance.planId ? { planId: provenance.planId } : {} ),
       ...( provenance.stepId ? { stepId: provenance.stepId } : {} ),
     },

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/schemas/repertoire.ts

@@ -26,6 +26,7 @@
 
 import type { MotorSchema, LearnedSkill } from '#agency/types'
 import type { EntityInput, ReadonlySimulationState } from '#core/types'
+import type { DenialFinality } from '#stem/policy/arbiter'
 import { INNATE_SCHEMAS } from '#agency/schemas/innate'
 
 const VALUE_ALPHA       = 0.2   // value EMA rate
@@ -50,8 +51,8 @@ const DROP_HABIT        = 0.05  // below this (and learned) the skill is forgott
 // availability never floors at zero, and it climbs back toward 1 with disuse of
 // the refusal. P2 keys availability by SCHEMA; per-(schema, params) envelope
 // narrowing is a follow-up that belongs at selection time, not fielding time.
-const AVAIL_DROP_CLASS    = 0.50  // multiplicative cut on a class-final refusal
-const AVAIL_DROP_INSTANCE = 0.12  // lighter cut on an instance-final refusal
+const AVAIL_DROP_CLASS     = 0.50  // multiplicative cut on a class-final refusal
+const AVAIL_DROP_PARAMETER = 0.12  // lighter cut when only the arguments were refused
 const AVAIL_FLOOR         = 0.05  // never zero — re-probe must always be possible
 const AVAIL_RECOVERY      = 0.02  // per-decay climb back toward 1
 const AVAIL_RECOVERED     = 0.999 // at/above this the entry is dropped (quiet path)
@@ -119,13 +120,19 @@ export class SchemaRepertoire {
 
   /**
    * Fold a policy refusal into the availability layer (NOT competence). A
-   * `class` refusal cuts availability hard; an `instance` refusal dents it
+   * `class` refusal cuts availability hard; a `parameter` refusal dents it
    * lightly. Multiplicative so repeated refusals compound toward — but never
    * reach — zero, keeping re-probe alive.
+   *
+   * `context` is EXCLUDED FROM THE SIGNATURE, not handled inside: a refusal
+   * that was not about the action must never reach the availability layer at
+   * all, and making that a type error rather than a convention means a future
+   * caller cannot quietly re-introduce the dent. The routing decision lives in
+   * the ReafferenceEngine's refused branch (P5).
    */
-  recordRefusal( schema: string, finality: 'class' | 'instance', tick: number ): number {
+  recordRefusal( schema: string, finality: Exclude<DenialFinality, 'context'>, tick: number ): number {
     const prev = this._availability.get( schema )?.value ?? 1
-    const drop = finality === 'class' ? AVAIL_DROP_CLASS : AVAIL_DROP_INSTANCE
+    const drop = finality === 'class' ? AVAIL_DROP_CLASS : AVAIL_DROP_PARAMETER
     const value = Math.max( AVAIL_FLOOR, prev * ( 1 - drop ) )
     this._availability.set( schema, { value, lastRefusedTick: tick } )
     return value

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