@mindot/will 0.8.0 → 0.10.0

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

@@ -31,6 +31,11 @@ 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 { asProvenance } from '#senses/provenance'
+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 +86,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. */
@@ -152,7 +162,11 @@ export class ReafferenceEngine implements CognitiveEngine {
     for( const [ , e ] of state.entities ){
       if( e.type !== 'percept') continue
       const m = ( e.metadata ?? {} ) as Record<string, unknown>
-      if( str( m['provenance'] ) !== 'reafferent') continue
+      // asProvenance(), not a literal compare: this is an untyped read out of
+      // entity metadata, exactly what that normalizer exists for. Behaviour is
+      // unchanged — absent and garbage both normalize to 'exafferent', which
+      // fails this test the same way `str()` returning undefined did.
+      if( asProvenance( m['provenance'] ) !== 'reafferent') continue
       const iid = str( m['sourceIntentId'] )
       if( !iid || gradedIntentIds.has( iid ) || sensedIntentIds.has( iid ) ) continue
       const aw = awaiting.get( iid )
@@ -192,6 +206,7 @@ export class ReafferenceEngine implements CognitiveEngine {
     let updates    = 0
     let discovered = 0
     let refused    = 0
+    let withheld   = 0
     for( const { id, meta: m, fromState } of outcomes ){
       const schema = str( m['schema'] )
       if( !schema ){ if( fromState ) del.push( id ); continue }
@@ -201,6 +216,25 @@ export class ReafferenceEngine implements CognitiveEngine {
       // habit, param priors), or the Will learns it is unskilled at something it
       // 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.
+      // Chosen silence. The mind considered speaking and decided not to, which
+      // is a decision — not a failure, and not a refusal either: nothing forbade
+      // it, so availability must not be dented and `recordRefusal` must not run.
+      // Free the intent, signal any plan step, and teach NOTHING: the question
+      // was never whether it can speak.
+      //
+      // Before this, a declined outreach timed out at AWAIT_TIMEOUT and folded
+      // into `reach-out`'s competence as a failure — the mind learning it is bad
+      // at speaking from the times it chose not to speak.
+      if( m['withheld'] === true ){
+        if( fromState ) del.push( id )
+        const heldIntent = str( m['intentId'] )
+        if( heldIntent ) del.push( heldIntent )
+        const heldPlan = str( m['planId'] )
+        if( heldPlan ) this._emitPlanOutcome( heldPlan, str( m['stepId'] ), schema, false, 0, 0, tick )
+        withheld++
+        continue
+      }
+
       if( m['refused'] === true ){
         const finality = asFinality( m['finality'] )
 
@@ -242,13 +276,13 @@ export class ReafferenceEngine implements CognitiveEngine {
       updates++
 
       // Plan advancement for the async path: a host-acked outcome that carries plan
-      // provenance is the ONLY signal the PlanningEngine will get (the executor never
+      // the plan link is the ONLY signal the PlanningEngine will get (the executor never
       // saw the ack — the intent was 'awaiting'). Emit the action.outcome it advances
       // on. Sync/timeout outcomes never carry planId here (the executor emitted their
       // action.outcome already), so this never double-advances.
       const planId = str( m['planId'] )
       if( planId )
-        this._emitPlanOutcome( planId, str( m['stepId'] ), schema, m['success'] === true, num( m['outcomeQuality'], 0 ), num( m['surprise'], 0 ), tick )
+        this._emitPlanOutcome( planId, str( m['stepId'] ), schema, m['success'] === true, num( m['outcomeQuality'], 0 ), num( m['surprise'], 0 ), tick, str( m['description'] ) )
 
       // Discovery: the first time the Will enacts a schema, it becomes a known part
       // of its repertoire (the new model's "discovered" — earned by doing, not catalogued).
@@ -281,6 +315,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,13 +338,112 @@ 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 ])
+    // Counted separately from refusals on purpose: one is the world saying no,
+    // the other is the mind saying not now. Collapsing them would read as a
+    // policy problem in the telemetry when nothing was forbidden.
+    if( withheld > 0 ) metrics.push([ 'agency.withheld.count', withheld ])
 
     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 {
@@ -318,6 +464,9 @@ export class ReafferenceEngine implements CognitiveEngine {
   private _emitPlanOutcome(
     planId: string, stepId: string | undefined, schema: string,
     success: boolean, outcomeQuality: number, surprise: number, tick: Tick,
+    /** The host's own words for what happened. Absent on withheld/refused paths,
+     *  where there was no host and nothing to say beyond the fate. */
+    description?: string,
   ): void {
     if( !this._bus ) return
     try {
@@ -326,7 +475,14 @@ export class ReafferenceEngine implements CognitiveEngine {
         salience: Math.min( 1, outcomeQuality * 0.6 ),
         payload: {
           actionType: schema, domain: schema, success, outcomeQuality, surprise,
-          description: success ? 'The world confirmed the action.' : 'The world rejected the action.',
+          // The host's own words for what happened, not a stock sentence. This
+          // hardcoded `'The world confirmed the action.'` — and since
+          // `action.record` is built from this payload, that phrase (or nothing,
+          // from the executor's side) is ALL the prompt's `## Recent Action
+          // Outcomes` ever showed. The `agency.outcome` entity has carried the
+          // real description the whole time (`reconcile.learning.ts:89`); it was
+          // read here as `m['description']` and dropped on the floor.
+          description: description ?? ( success ? 'The world confirmed the action.' : 'The world rejected the action.'),
           planId,
           ...( stepId ? { stepId } : {} ),
           tick,

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

@@ -95,10 +95,23 @@ function syncStance( ctx: EnactionContext ): Enaction {
       return sync( 0.5, 0.0, 'I let time pass; regulatory processes continue their quiet work.')
     case 'express':
       return sync( 0.6, 0.1, 'My inner state becomes outwardly visible.')
-    case 'inspect': {
-      const focus = str( parameters['focus'] ) ?? 'it'
-      return sync( 0.65, 0.05, `I examine ${ focus } closely; more of its detail resolves.`)
-    }
+    // No `inspect` case, deliberately.
+    //
+    // Looking is now outward ONLY — a question put to the world, tagged external
+    // and dispatched. Turning attention inward already has three names on this
+    // very floor: `orient` sweeps the situation, `attend` mobilises attention,
+    // `reflect` turns inward and lets patterns settle. `inspect` naming that too
+    // was a second name for an act that already had one.
+    //
+    // The cost of the collision was not stylistic. The two readings have
+    // DIFFERENT failure modes — "I hold no record of it" versus "the world did not
+    // answer" — and one verb covering both meant a pure function needed three
+    // flags passed in to tell which it was. Live, the inward reading could not
+    // fail at all: a fresh Will proceduralized inspect to habit 0.64 in fifteen
+    // ticks, examining its own affordance entities and being told it went well.
+    //
+    // Outward-only, that is structurally impossible rather than conditionally
+    // caught. An unanswered look fails because nothing answered.
     default:
       return sync( 0.5, 0.0, `I enact ${ schema.id }.`)
   }

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

@@ -17,6 +17,7 @@
 
 import type { EntityInput, Tick } from '#core/types'
 import type { DenialFinality, PolicyCounterfactual } from '#stem/policy/arbiter'
+import type { PlanLink } from '#agency/types'
 
 export interface HostAckResult {
   success:        boolean
@@ -55,7 +56,7 @@ export interface HostAckResult {
  * `agency.invocation` payload); `predictedReward`/`predictedValence` are the
  * efference copy the executor persisted on the intent, so surprise is honest.
  *
- * `provenance` carries the awaiting intent's plan link (planId/stepId) when it was
+ * `planLink` carries the awaiting intent's plan step (planId/stepId) when it was
  * committed from a plan's frontier prior. It rides on the agency.outcome so the
  * ReafferenceEngine — the engine that consumes async-acked outcomes — can emit the
  * `action.outcome{planId,stepId}` the PlanningEngine advances on. (The executor
@@ -68,7 +69,7 @@ export function reconcileInvocation(
   result:   HostAckResult,
   tick:     Tick,
   predicted: { reward: number; valence: number } = { reward: 0.5, valence: 0 },
-  provenance: { planId?: string; stepId?: string } = {},
+  planLink: PlanLink = {},
 ): EntityInput {
   const outcomeQuality = result.outcomeQuality ?? ( result.success ? 0.8 : 0.1 )
   const valence        = result.valence ?? ( result.success ? 0.2 : -0.2 )
@@ -94,8 +95,8 @@ export function reconcileInvocation(
       // 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 } : {} ),
+      ...( planLink.planId ? { planId: planLink.planId } : {} ),
+      ...( planLink.stepId ? { stepId: planLink.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/innate.ts

@@ -92,7 +92,102 @@ export const INNATE_SCHEMAS: MotorSchema[] = [
     cost:       0.06,
     preconditions: [ { metric: 'energy.level', op: 'gt', value: 8 } ],
     baseValence: 0.05,
-    tags:       [ 'perception', 'information' ],
+    /**
+     * Outward only — a question put to the world, which is the only thing that
+     * can answer it.
+     *
+     * Turning attention inward already has three names on this very floor:
+     * `orient` sweeps the situation, `attend` mobilises attention, `reflect`
+     * turns inward and lets patterns settle. `inspect` naming that too was a
+     * second name for an act that already had one.
+     *
+     * The collision was not stylistic. The two readings have DIFFERENT failure
+     * modes — "I hold no record of it" versus "the world did not answer" — so one
+     * verb covering both forced three disambiguation flags into a pure function,
+     * and left the inward reading unable to fail at all. Live, a fresh Will
+     * proceduralized this to habit 0.64 within fifteen ticks of birth and spent
+     * five of its first eight decisions on it, examining its own affordance
+     * entities and being told each time that it went well.
+     *
+     * Tagged external it rides the path `reach-out` already rides: dispatched to
+     * the host, held awaiting, acked or timed out. The ACK ITSELF carries the
+     * answer — `observation`, in whatever shape the host keeps it — and the
+     * engine turns that into a reafferent percept the mind judges for itself
+     * (SIGNAL_BOUNDARY P2). One act, one answer, one percept.
+     *
+     * This paragraph used to say the opposite: that an ack carried only
+     * `{success, description}` and so a host CANNOT hand facts back, which
+     * obliged every host to call `perceive()` a second time with its own result
+     * — the laundering that made a Will's own act arrive looking like news from
+     * the world. P2 removed the obligation; this comment outlived it by two
+     * merges, which is the ordinary way a false comment survives: nothing
+     * compiles it.
+     *
+     * A look nothing answers still fails, and that is what teaches a mind to
+     * stop examining what will not resolve. Through the SDK an effector with no
+     * handler is acked failed inside the tick; a host driving the stem directly
+     * leaves the intent awaiting until AWAIT_TIMEOUT abandons it.
+     *
+     * Innate AND host-dependent is not a contradiction; `reach-out` is both.
+     * Every mind can look, but whether looking finds anything depends on there
+     * being a world.
+     */
+    tags:       [ 'perception', 'information', 'external' ],
+  },
+  {
+    /**
+     * Look at a clock.
+     *
+     * WHY THIS IS AN ACT AND NOT A FACT THE PROMPT HANDS OVER. A body knows its
+     * own rhythm — tired, alert, trough — because a rhythm is something a body
+     * DOES. It does not know that it is 15:42, because that is a fact about the
+     * world, and the only way a fact about the world reaches a mind is by the
+     * mind going and getting it. Every prompt used to carry the hour for free,
+     * and it was wrong in three ways at once precisely because nobody had to
+     * ask where it came from.
+     *
+     * Innate AND host-dependent, exactly as `inspect` and `reach-out` are:
+     * every mind can ask what time it is; whether anything answers depends on
+     * there being a world with a clock in it.
+     *
+     * A host that has one answers on the ack — `observation`, in whatever shape
+     * it keeps time: an ISO string, an hour and a zone, a mission-elapsed count.
+     * It does not have to phrase it, and it should not: the mind reads the data
+     * and makes the meaning of it (SIGNAL_BOUNDARY P2). The answer lands as a
+     * reafferent percept stamped with the intent that sought it, so what she
+     * knows about the hour is something she went and found, with a record of
+     * having found it.
+     *
+     * A host that has none never answers, and the failure is honest in either
+     * shape it takes: through the SDK an unregistered effector is acked failed
+     * inside the tick ("No handler registered for effector ..."), through the
+     * raw stem the intent sits awaiting until AWAIT_TIMEOUT abandons it. Either
+     * way the mind learns that time is not available here — which is a true
+     * thing about this world — rather than being handed a fiction.
+     *
+     * That degradation is the point of putting it here rather than in a config.
+     * A clock injected per-host is a fact one Will has and another does not,
+     * with no way for either to know which it is. Sought, it is the same
+     * mechanism for all of them, and the answer — or its absence — is
+     * something the mind can weigh.
+     *
+     * `binds: 'none'` because the time is not a referent. There is nothing to
+     * point at; you just look.
+     */
+    id:         'check-time',
+    kind:       'primitive',
+    // 'innate', not 'perceptual'. `inspect` is perceptual because a percept
+    // EVOKES it — it binds the thing it looks at. Nothing evokes this; it is
+    // always there, like `orient` and `rest`. The synthesizer caps
+    // percept-evoked affordances at attention capacity and never caps the
+    // floor, and a glance at a clock belongs to the floor.
+    source:     'innate',
+    binds:      'none',
+    // Cheaper than `inspect` (0.06): a glance at a clock, not an examination.
+    cost:       0.03,
+    preconditions: [ { metric: 'energy.level', op: 'gt', value: 5 } ],
+    baseValence: 0.0,
+    tags:       [ 'perception', 'information', 'external' ],
   },
   {
     id:         'reach-out',

package/src/cognition/agency/schemas/repertoire.ts

@@ -24,10 +24,11 @@
 //   paramPriors    — last known-good parameters become defaults
 // ─────────────────────────────────────────────────────────────
 
+import { logger } from '#core/logger'
 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'
+import { INNATE_SCHEMAS, INNATE_SCHEMA_BY_ID } from '#agency/schemas/innate'
 
 const VALUE_ALPHA       = 0.2   // value EMA rate
 const ERROR_BETA        = 0.2   // prediction-error EMA rate
@@ -99,6 +100,23 @@ export class SchemaRepertoire {
    * reafference then builds skill on. Idempotent; re-registering updates it.
    */
   registerExternal( schema: MotorSchema ): void {
+    // An innate schema is part of the body, not a slot a tenant may redefine.
+    //
+    // This sets by id, so a host registering a handler for a name the floor
+    // already uses would REPLACE the innate schema with a generated one —
+    // silently dropping its `binds`, cost, preconditions and tags. `inspect` is
+    // the live case: a Discord bridge answering inquiries would have overwritten
+    // the very schema whose `binds: 'percept'` is how inquiry finds its targets,
+    // and the mind would have lost the ability to look at what it cannot place in
+    // exchange for gaining an answerer.
+    //
+    // Registering the HANDLER is still what the host wanted and still happens —
+    // only the redeclaration is refused. The container supplies the mechanism; a
+    // tenant supplies what answers it.
+    if( INNATE_SCHEMA_BY_ID.has( schema.id ) ){
+      logger.debug(`[repertoire] "${ schema.id }" is innate — keeping the body's schema, binding the handler only`)
+      return
+    }
     this._templates.set( schema.id, schema )
   }
 

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,48 @@ 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
+  /**
+   * How strongly a verdict System 2 already reached holds the competition.
+   *
+   * Peer of `will` and `repeat` in magnitude, and for the same reason each of
+   * those is: having thought a choice through should weigh about what willing it
+   * does, and no more. Large enough that the settled option clears the
+   * selector's ambiguity gate (0.06) for most of the settlement's life, so the
+   * same question is not re-deliberated every few ticks; small enough that a
+   * genuinely pressing affordance — threat, a person waiting, a drive gone
+   * urgent — still out-competes a standing verdict.
+   *
+   * Decays to 0 with the settlement, so the question re-opens on its own.
+   */
+  settled: number
 }
 
 export const DEFAULT_WEIGHTS: ScoreWeights = {
@@ -59,9 +100,13 @@ 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,
+  settled: 0.30,
 }
 
 /**
@@ -154,9 +199,13 @@ 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 )
+    + w.settled * ( a.settled ?? 0 )
   )
   // POLICY_REAFFERENCE P2 — policy availability damps a POSITIVE activation only,
   // never flipping its sign: a refused ability competes weakly (so it is rarely