@mindot/will 0.8.0 → 0.10.0

package/src/cognition/agency/conversation.aim.ts

@@ -0,0 +1,292 @@
+// ─────────────────────────────────────────────────────────────
+// src/agency/conversation.aim.ts  —  did the words achieve what they were for?
+// ─────────────────────────────────────────────────────────────
+//
+// A communicative act has an AIM that is not its EXECUTION. Sending succeeded;
+// that is a fact about the channel. Whether anyone answered is a fact about the
+// world, it arrives later, and until this module existed nothing in the mind
+// represented it.
+//
+// The cost of not representing it, measured on a live Will: `agency.skill` for
+// `reach-out` read `enactments 28, successes 28` — a 100% success rate, because
+// the outbox accepted every one. Habit (0.78) and value (0.5) therefore rose with
+// each repetition while the only opposing term, satiation, is bounded and decays.
+// The mind asked one person the same question eleven times in two and a half
+// minutes and, from the inside, every one of them was the first: it could see
+// `✓ reach-out` in its recent outcomes and nothing at all about being ignored.
+//
+// So this is not a rule against repeating. It is the missing PERCEPT. The mind
+// gets to know that it spoke and was not answered; what to do about that is its
+// own business — a person who has been ignored twice may well try a third time,
+// and should be able to, having noticed.
+//
+// Everything here is pure and tick-denominated: no wall clock, no RNG, no state
+// writes. Ids and decisions stay identical between a recorded run and its replay
+// (R2). The resolution is folded into state by ReafferenceEngine, which already
+// owns the question "did the world confirm my act?".
+// ─────────────────────────────────────────────────────────────
+
+import type { Tick } from '#core/types'
+import { readAliases, canonicalOf } from '#cognition/social.identity'
+
+export const SENT_TYPE     = 'conversation.sent'
+export const RECEIVED_TYPE = 'conversation.received'
+
+/**
+ * How long the mind waits before it counts a silence as an answer in itself.
+ *
+ * Deliberately much longer than the echo window (`CONSEQUENCE_TTL_TICKS`, 30), a
+ * motor await (`AWAIT_TIMEOUT`, 15), or satiation (`repeatWindowTicks`, 60).
+ * Those ask "did my act leave the building?" and "does saying it again feel right
+ * yet?"; this asks "did a person get back to me?", and people take their time. At
+ * the 1s tick a hosted Will actually runs on, 240 is four minutes — long enough
+ * that a silence is genuinely a silence and not somebody typing.
+ *
+ * Tuned through the persona prior rather than fixed, because how long a quiet
+ * takes to mean something is a trait — the same reason `facetIdleTtlTicks` and
+ * `repeatWindowTicks` are not constants.
+ */
+export const DEFAULT_REPLY_WINDOW_TICKS = 240
+
+/** Minimal shape this module needs off a state entity — keeps it testable without a StateManager. */
+export interface EntityLike {
+  type:     string
+  /**
+   * The real field. `StateManager.setEntity` stamps it from the sim clock on
+   * every write, and it is the ONLY tick a record written off-tick can have —
+   * an inbound turn arrives between ticks and its writer has no clock to quote.
+   */
+  updatedAtTick?: number
+  /** Not on `SimulationEntity`; accepted so a test can state a tick directly. */
+  tick?:    number
+  metadata?: ReadonlyMap<string, unknown> | Record<string, unknown>
+}
+
+/**
+ * When a record happened: what its writer declared, else when the state manager
+ * stamped it.
+ *
+ * `SimulationEntity` has no `tick` — it is `updatedAtTick`, and reading the
+ * former silently yields `undefined` on every real entity. That is not a
+ * hypothetical: this module shipped reading `e.tick`, so `lastHeard` was 0 for
+ * everybody, `0 > sentTick` was never true, and NO turn could ever be marked
+ * answered. Caught on a live run where she was mid-conversation and the engine
+ * announced "no answer from Fabrice" about a message he had already replied to.
+ *
+ * The same dead read sits in `spokenAtByEntity` (agency/consequence.ts) behind a
+ * comment explaining why the fallback matters. It never fired there either.
+ */
+export function tickOf( e: EntityLike, meta: Record<string, unknown> ): Tick {
+  return ( num( meta['tick'] ) ?? num( e.updatedAtTick ) ?? num( e.tick ) ?? 0 ) as Tick
+}
+
+/** One thing the mind said to one person, and what became of it. */
+export interface SpokenTurn {
+  entityId:         string
+  targetEntityId:   string
+  targetEntityName?: string
+  preview:          string
+  tick:             Tick
+  /** Set once the target has spoken after this turn. */
+  answeredAt?:      Tick
+  /**
+   * WHAT they said back.
+   *
+   * Recorded on the turn rather than looked up later, because a
+   * `conversation.received` lives exactly one tick — SocialPerception sweeps it as
+   * a one-shot event — so the text is unavailable by the next render. Without it
+   * the mind is told an answer ARRIVED and never shown it, which is worse than
+   * silence: it invites the mind to act as though it has the answer. Live, that
+   * put a wrong meeting time in front of a third party — she asked "same time,
+   * 3pm?", was told `they answered`, never saw the correction to 2pm, and relayed
+   * 3pm as confirmed.
+   */
+  answeredWith?:    string
+  /** Set once the reply window closed on a silence — recorded so it is announced once, not every tick. */
+  unansweredAt?:    Tick
+  /** An acknowledgement closes a turn rather than opening one; it awaits nothing. */
+  isAck:            boolean
+}
+
+function meta( e: EntityLike ): Record<string, unknown> {
+  const m = e.metadata
+  if( !m ) return {}
+  return m instanceof Map ? Object.fromEntries( m ) : m as Record<string, unknown>
+}
+function str( v: unknown ): string | undefined { return typeof v === 'string' ? v : undefined }
+function num( v: unknown ): number | undefined {
+  return typeof v === 'number' && Number.isFinite( v ) ? v : undefined
+}
+
+/**
+ * Every `conversation.sent` in state, as turns.
+ *
+ * The tick comes from `metadata.tick` where the writer set one, else the entity's
+ * own tick — `StateManager.setEntity` stamps that from the sim clock on every
+ * write. The fallback is not decoration: the two writers (ProactiveCommunicator
+ * and AuditionEngine) disagree about which they fill, and defaulting to 0 made
+ * every record of the second kind look infinitely old. Same rule as
+ * `spokenAtByEntity`, deliberately.
+ */
+export function readSpokenTurns( entities: ReadonlyMap<string, EntityLike> ): SpokenTurn[] {
+  // Through the alias table, because the two writers name their target in
+  // different id spaces: a REPLY is addressed to the transport id the percept
+  // arrived with (`discord:1019…`), while a PROACTIVE message is addressed to the
+  // anchor the executive resolved (`ke:…`). Both are the same someone. Matched
+  // raw, an answer to one could never close the other — the same two-halves-in-
+  // two-id-spaces failure that made `answered` impossible the first time.
+  const aliases = readAliases( entities )
+  const out: SpokenTurn[] = []
+  for( const [ id, e ] of entities ){
+    if( e.type !== SENT_TYPE ) continue
+    const m      = meta( e )
+    const target = str( m['targetEntityId'] )
+    if( !target ) continue
+    out.push({
+      entityId:         id,
+      targetEntityId:   canonicalOf( aliases, target ),
+      targetEntityName: str( m['targetEntityName'] ),
+      preview:          str( m['preview'] ) ?? '',
+      tick:             tickOf( e, m ),
+      answeredAt:       num( m['answeredAt'] )   as Tick | undefined,
+      answeredWith:     str( m['answeredWith'] ),
+      unansweredAt:     num( m['unansweredAt'] ) as Tick | undefined,
+      isAck:            m['isAck'] === true,
+    })
+  }
+  // Stable, deterministic order: oldest first, ties broken by id so two turns on
+  // one tick never swap between a run and its replay.
+  return out.sort( ( a, b ) => a.tick - b.tick || ( a.entityId < b.entityId ? -1 : a.entityId > b.entityId ? 1 : 0 ) )
+}
+
+/**
+ * When each person last spoke TO the mind, from `conversation.received`.
+ *
+ * This is the evidence that an utterance was answered. It is deliberately the
+ * whole of the evidence: any turn from them after we spoke counts, without trying
+ * to decide whether it was *about* what we said. Matching on topic would be a
+ * guess dressed as a fact, and getting it wrong in the strict direction would
+ * teach the mind it is being ignored by someone who is talking to it.
+ */
+export function lastHeardByEntity( entities: ReadonlyMap<string, EntityLike> ): Map<string, Heard> {
+  const aliases = readAliases( entities )
+  const out = new Map<string, Heard>()
+  for( const [ , e ] of entities ){
+    if( e.type !== RECEIVED_TYPE ) continue
+    const m      = meta( e )
+    const raw = str( m['sourceKeid'] )
+    if( !raw ) continue
+    const source = canonicalOf( aliases, raw )
+    const at = tickOf( e, m )
+    if( at > ( out.get( source )?.tick ?? -Infinity ) )
+      out.set( source, { tick: at, preview: str( m['preview'] ) ?? '' } )
+  }
+  return out
+}
+
+/** When someone last spoke to us, AND what they said. */
+export interface Heard { tick: Tick; preview: string }
+
+/**
+ * When each person last spoke to the mind — the DURABLE version.
+ *
+ * `lastHeardByEntity` reads `conversation.received`, which lives exactly one
+ * tick: SocialPerception sweeps it as a one-shot event. So it answers "did
+ * someone speak to me THIS tick", never "when did they last speak to me".
+ *
+ * `answeredAt` is the durable half of the same fact, folded onto the mind's own
+ * `conversation.sent` turns by `resolveReplyExpectations` — it is what renders
+ * "they answered" in the prompt, and it survives snapshots.
+ *
+ * Written for the delivery-time re-check (`situationMoved`). That check first
+ * shipped keyed only on the mind having SPOKEN since composing, on the argument
+ * that nothing durable recorded the other direction. That was wrong — this is
+ * it — and the gap was the common case: live, a COO delivered a pre-composed
+ * agenda message two seconds after the person changed the subject, having said
+ * nothing in between, so the stale words arrived BEFORE her real reply and
+ * nothing was looking.
+ */
+export function lastAnsweredByEntity( entities: ReadonlyMap<string, EntityLike> ): Map<string, Tick> {
+  const out = new Map<string, Tick>()
+  for( const [ , e ] of entities ){
+    if( e.type !== SENT_TYPE ) continue
+    const m      = meta( e )
+    const target = str( m['targetEntityId'] )
+    const at     = num( m['answeredAt'] )
+    if( !target || at === undefined ) continue
+    if( at > ( out.get( target ) ?? -Infinity ) ) out.set( target, at as Tick )
+  }
+  return out
+}
+
+/** A turn still in the air: said, not acknowledged-only, and not yet answered. */
+export function isOpen( t: SpokenTurn ): boolean {
+  return !t.isAck && t.answeredAt === undefined
+}
+
+export interface Resolution {
+  /** Turns the target has now answered — fold `answeredAt` + what they said into them. */
+  answered:   Array<{ turn: SpokenTurn; at: Tick; with: string }>
+  /** Turns whose reply window closed in silence, newly, this tick. */
+  unanswered: SpokenTurn[]
+}
+
+/**
+ * Fold the world's answer (or its absence) onto the turns still in the air.
+ *
+ * Pure: reads frozen state, writes nothing, decides nothing about what the mind
+ * should do next. A turn resolves exactly once — `answeredAt`/`unansweredAt` are
+ * the latches, so the announcement fires on one tick rather than every tick for
+ * the rest of the session.
+ *
+ * A silence is only reported once the window has fully elapsed. Before that the
+ * turn is simply open, which is a third state and the honest one: not yet
+ * answered is not the same as ignored, and collapsing them would have the mind
+ * conclude it was being snubbed one tick after speaking.
+ */
+export function resolveReplyExpectations(
+  entities:    ReadonlyMap<string, EntityLike>,
+  tick:        Tick,
+  windowTicks: number = DEFAULT_REPLY_WINDOW_TICKS,
+): Resolution {
+  const turns     = readSpokenTurns( entities )
+  const lastHeard = lastHeardByEntity( entities )
+
+  const answered:   Resolution['answered'] = []
+  const unanswered: SpokenTurn[]           = []
+
+  for( const t of turns ){
+    if( t.isAck || t.answeredAt !== undefined ) continue
+
+    const heard = lastHeard.get( t.targetEntityId )
+    if( heard !== undefined && heard.tick > t.tick ){
+      answered.push({ turn: t, at: heard.tick, with: heard.preview })
+      continue
+    }
+
+    // Already announced as a silence — stays open, but says nothing more.
+    if( t.unansweredAt !== undefined ) continue
+    // A turn stamped LATER than now came back with a restored snapshot whose tick
+    // counter has not caught up. Reading it as `tick - t.tick` negative would make
+    // it trivially "not yet due" forever, which is the benign direction, but a
+    // window <= 0 would then fire on everything at once. Guard both.
+    if( windowTicks > 0 && tick - t.tick >= windowTicks ) unanswered.push( t )
+  }
+
+  return { answered, unanswered }
+}
+
+/**
+ * The turns worth showing the mind: still in the air, newest first, capped.
+ *
+ * This is what makes repetition visible from the inside. `conversation.sent` has
+ * always been in state — 57 records on the Will above — and reached no prompt at
+ * all, so the mind's only view of having spoken was `✓ reach-out` under "Recent
+ * Action Outcomes": a tick mark, no words, no person, no silence.
+ */
+export function openTurns(
+  entities: ReadonlyMap<string, EntityLike>,
+  limit:    number = 6,
+): SpokenTurn[] {
+  return readSpokenTurns( entities ).filter( isOpen ).reverse().slice( 0, limit )
+}

package/src/cognition/agency/engines/action.selector.ts

@@ -37,6 +37,7 @@ import {
 } from '#agency/selection.scoring'
 import { readEffectiveParams, readPersonaPrior } from '#cognition/persona.prior'
 import { RUPTURE_REVOKE_GATE, revocationEntity } from '#agency/revocation'
+import { liveSettlements, settlementId } from '#agency/settlement'
 import { liveConsequences, matchConsequenceText } from '#agency/consequence'
 import { asFinality } from '#stem/policy/arbiter'
 
@@ -285,8 +286,23 @@ export class ActionSelector implements CognitiveEngine {
       catch( err ){ logger.warn(`[selector] rupture publish failed: ${ err instanceof Error ? err.message : String( err ) }`) }
     }
 
+    // A verdict is held only while the situation that produced it stands. A hard
+    // rupture means the world just contradicted the premises the mind decided
+    // on, so every standing settlement lapses and those questions are genuinely
+    // open again — the same reasoning that revokes a commitment still being
+    // weighed, applied to the ones already settled.
+    //
+    // Deliberately NOT conditioned on something being deliberated right now: the
+    // entire point of a settlement is that it outlives the intent that formed
+    // it, so it has to be able to lapse without one.
+    const settlementDrops = rupture >= RUPTURE_REVOKE_GATE
+      ? liveSettlements( state.entities, tick ).map( s => settlementId( s.schema, s.targetEntityId ) )
+      : []
+    const dropSettled = settlementDrops.length > 0 ? { delete: settlementDrops } : {}
+
     const busy = ( n: number ): EngineResult => ({
       commands: {
+        ...dropSettled,
         metrics: [
           [ 'agency.field.eligible', n ],
           [ 'agency.selection.busy', 1 ],
@@ -323,6 +339,7 @@ export class ActionSelector implements CognitiveEngine {
       return {
         commands: {
           set: [ revocationEntity( deliberating.id, deliberating.schema, revRupture, tick ) ],
+          ...dropSettled,
           metrics: [
             [ 'agency.field.eligible', eligible.length ],
             [ 'agency.selection.busy', 1 ],
@@ -340,6 +357,7 @@ export class ActionSelector implements CognitiveEngine {
     if( eligible.length === 0 )
       return {
         commands: {
+          ...dropSettled,
           metrics: [
             [ 'agency.field.eligible', 0 ],
             [ 'agency.selection.busy',( awaiting || composite ) ? 1 : 0 ],
@@ -371,6 +389,42 @@ export class ActionSelector implements CognitiveEngine {
     const winner = scored[0]
     if( !winner ) return busy( eligible.length )
 
+    // Whenever more than one person is a candidate for contact, record how the
+    // competition between them actually resolved. A Will that names someone and
+    // never messages them looks identical from outside whether the intention was
+    // never formed or was formed and beaten every cycle; this is the only place
+    // that difference is visible, and it is one line per contested tick.
+    // Why a WILLED contact did not happen. Gated on the executive having actually
+    // willed one (source 'ideomotor') that is not the winner — so a mind whose
+    // decision is being enacted logs nothing, and a mind that decided to contact
+    // someone and then did not says exactly what beat it.
+    //
+    // The earlier version of this gated on `reachers.length > 1`, assuming the
+    // failure was one addressee out-competing another. It is not: each master cycle
+    // sweeps every executive intent it did not name that cycle, so there is usually
+    // exactly ONE reach-out candidate in the field and the contest log never fired.
+    // The competition that matters is the willed contact against the rest of the
+    // field, which is what this prints.
+    // EVERY willed contact that lost, not just the strongest. An earlier version
+    // used `.find()`, which reports only the highest-scoring one — so with two
+    // live intents a second loser went unlogged, and the log would have quietly
+    // understated how many people the mind decided to contact and then did not.
+    const lostReaches = scored.filter( s =>
+      s !== winner
+      && s.affordance.schema === 'reach-out'
+      && s.affordance.source === 'ideomotor'
+      && s.affordance.targetEntityId )
+
+    for( const lost of lostReaches )
+      logger.info(
+        `[selector] willed reach-out → ${ lost.affordance.targetEntityId } NOT selected: ` +
+        `${ lost.activation.toFixed( 3 ) }` +
+        `${ lost.affordance.justEnacted ? ` (justEnacted ${ lost.affordance.justEnacted.toFixed( 2 ) })` : '' }` +
+        ` < ${ winner.affordance.schema }` +
+        `${ winner.affordance.targetEntityId ? `→${ winner.affordance.targetEntityId }` : '' }` +
+        ` ${ winner.activation.toFixed( 3 ) }`
+      )
+
     // ── Preempt a mid-composite routine (IMMEDIATE SWITCH) ────────
     // A strong/high-stakes challenger cuts the routine off AND takes the body
     // the same tick. We cannot delete the parent here: the executor runs later
@@ -426,12 +480,37 @@ export class ActionSelector implements CognitiveEngine {
       const sameAction = winner.affordance.schema === awaiting.schema && ( winner.affordance.targetEntityId ?? '') === awaiting.target
       if( sameAction ) return busy( eligible.length )   // field still favours what we await
 
-      const staleness         = Math.min( 1, ( tick - awaiting.dispatchedAt ) / AWAIT_STALE_TICKS )
+      // Clamped at BOTH ends. The upper bound was always there; the lower one matters
+      // because a restored intent's age is negative (state snapshots, the tick counter
+      // restarts at 1), and an unclamped negative staleness flips the decay into
+      // amplification: `1 - (-39 × 0.5)` = 20.6×, turning a 0.47 incumbent into 9.74 and
+      // making it permanently unpreemptable. The executor now clears such intents, so
+      // this is the second line of defence rather than the fix — but an incumbent's
+      // hysteresis must never be able to exceed its own recorded activation, whatever
+      // arithmetic feeds it.
+      const staleness         = Math.min( 1, Math.max( 0, ( tick - awaiting.dispatchedAt ) / AWAIT_STALE_TICKS ) )
       const incumbentStrength = awaiting.activation * ( 1 - staleness * STALE_DECAY )
       const switchCost        = effSwitchCost * ( 1 - stakes( winner.affordance, bias ) )
 
-      if( winner.activation <= incumbentStrength + switchCost )
+      if( winner.activation <= incumbentStrength + switchCost ){
+        // A challenger aimed at a DIFFERENT person losing to an awaiting incumbent
+        // is the starvation shape: every proactive reach-out sits 'awaiting' while a
+        // facet authors its words (8–18s = many ticks), and the incumbent's recorded
+        // activation does not decay with the challenger's damping. If one addressee
+        // can hold the channel this way, a Will can decide to contact someone else
+        // every cycle and never once do it — which is exactly the report.
+        if( winner.affordance.schema === 'reach-out'
+            && winner.affordance.targetEntityId
+            && winner.affordance.targetEntityId !== awaiting.target )
+          logger.info(
+            `[selector] reach-out → ${ winner.affordance.targetEntityId } BLOCKED by awaiting ` +
+            `${ awaiting.schema } → ${ awaiting.target || '—' }: ` +
+            `challenger ${ winner.activation.toFixed( 3 ) } ≤ incumbent ${ incumbentStrength.toFixed( 3 ) } ` +
+            `+ switch ${ switchCost.toFixed( 3 ) } (awaiting ${ tick - awaiting.dispatchedAt } ticks)`
+          )
+
         return busy( eligible.length )   // not worth interrupting — keep waiting
+      }
 
       preemptDelete = awaiting.id        // PREEMPT — fall through and commit the challenger
       preemptedFrom = awaiting.schema
@@ -478,7 +557,12 @@ export class ActionSelector implements CognitiveEngine {
         targetEntityId:  winner.affordance.targetEntityId,
         parameters:      winner.affordance.parameters,
         source:          winner.affordance.source,
-        // Plan provenance (when a plan's frontier-step prior won the competition) —
+        // What evoked this — for an ideomotor winner, the `ideomotor.intent` entity
+        // the executive wrote. Carried so the executor can DISCHARGE it once the act
+        // happens: an intention that has been acted on is no longer an intention, and
+        // nothing was deleting these. See MotorSchemaExecutor._dischargeWill.
+        ...( winner.affordance.evokedBy ? { evokedBy: winner.affordance.evokedBy } : {} ),
+        // The plan link (when a plan's frontier-step prior won the competition) —
         // flows through the executor's action.outcome so the PlanningEngine advances.
         ...( winner.affordance.planId ? { planId: winner.affordance.planId } : {} ),
         ...( winner.affordance.stepId ? { stepId: winner.affordance.stepId } : {} ),
@@ -562,7 +646,9 @@ export class ActionSelector implements CognitiveEngine {
       set: compositeTombstone
         ? [ intent, revocationEntity( compositeTombstone, compositeFrom ?? '', rupture, tick ) ]
         : [ intent ],
-      ...( preemptDelete ? { delete: [ preemptDelete ] } : {} ),
+      ...( preemptDelete || settlementDrops.length > 0
+        ? { delete: [ ...( preemptDelete ? [ preemptDelete ] : [] ), ...settlementDrops ] }
+        : {} ),
       metrics: [
         [ 'agency.field.eligible',       eligible.length ],
         [ 'agency.selection.busy',       0 ],
@@ -619,6 +705,14 @@ function computeRupture(
   for( const e of state.entities.values() ){
     if( e.type !== 'percept') continue
     const m = e.metadata
+    // Deliberately NOT asProvenance(). Absence is load-bearing here and only
+    // here: an UNTAGGED percept is excluded from rupture, and three writers
+    // are untagged — `escalation.buffer` (x2) and the wake percept in
+    // `stem/index.ts`. Normalizing would default them to 'exafferent' and make
+    // them rupture-eligible. That is a real behaviour change, and probably the
+    // right one — a mind waking after hours offline currently cannot be
+    // ruptured by that fact — but it belongs to the phase that tags those
+    // writers, with tests. See .TODO/SIGNAL_BOUNDARY.md.
     if( str( m?.['provenance'] ) !== 'exafferent') continue
     const pTick = num( m?.['tick'], -1 )
     if( pTick < 0 || tick - pTick > RUPTURE_WINDOW_TICKS ) continue
@@ -677,6 +771,19 @@ function effectiveWeights( state: ReadonlySimulationState ): ScoreWeights {
     ...DEFAULT_WEIGHTS,
     risk:    Math.max( 0, num( p['riskWeight'],    DEFAULT_WEIGHTS.risk    ) ),
     novelty: Math.max( 0, num( p['noveltyWeight'], DEFAULT_WEIGHTS.novelty ) ),
+    // How long the mind sits with something it has already said before saying it
+    // again. Agreeableness raises it (does not badger); demonstrated persistence
+    // lowers it (follows up sooner). Clamped at 0 so a prior can flatten the
+    // damping into indifference but never turn repeating into a *reward*.
+    repeat:  Math.max( 0, num( p['repeatDamping'], DEFAULT_WEIGHTS.repeat  ) ),
+    // How much the mind's learned read on a person biases acting toward them.
+    // Deliberately NOT clamped at 0 — this weight is genuinely signed territory,
+    // and it is the tenant's to occupy. A warm, reciprocal mind leans toward
+    // whoever answers; a dogged, duty-bound one chases a silence precisely
+    // because it is silent. Both are coherent people. The container supplies the
+    // term and the persona supplies the sign; hardcoding it here would be the
+    // container deciding what kind of colleague every tenant has to be.
+    social:  num( p['socialWeight'], DEFAULT_WEIGHTS.social ),
   }
 }
 
@@ -713,7 +820,31 @@ function buildBias( state: ReadonlySimulationState ): BiasContext {
 
 // ─── entity decoding ─────────────────────────────────────────────────────────
 
-function readAffordance( id: string, m: ReadonlyMap<string, unknown> | Record<string, unknown> | undefined ): Affordance {
+/**
+ * Decode an `affordance` entity back into the thing the competition scores.
+ *
+ * This is the ONE hop between synthesis and selection, and three fields did not
+ * cross it — each the payload of a mechanism that therefore never ran:
+ *
+ *   • `justEnacted` — `scoreAffordance` subtracts `w.repeat × justEnacted`, the
+ *     largest damping weight in the competition (0.30). Undefined here meant ×0
+ *     always, so no act has ever been damped for having just been done. EXAFFERENCE
+ *     P5 and the `spokenAt` durability fix both landed on a field nothing read.
+ *   • `availability` — POLICY_REAFFERENCE P2 damps a refused ability so it competes
+ *     weakly instead of vanishing. `a.availability ?? 1` read the fallback forever.
+ *   • `settled` — a verdict System 2 already reached. Same weight class as
+ *     `justEnacted` and the same failure if dropped: the mind re-deliberates a
+ *     question it has answered, forever. Added WITH its decoder rather than
+ *     after someone notices the mechanism is dark.
+ *   • `description` — the schema's MEANING. The selector snapshots it onto
+ *     `metadata.candidates` and the DeliberationEngine renders it as `— <what>`,
+ *     so the candidate list the mind reasons over listed acts with no meanings.
+ *
+ * Exported for the round-trip guard: what synthesis writes, selection must read.
+ * Four fields in this arc have been carried most of the way and lost at the last
+ * hop, so the property is pinned rather than re-checked by eye.
+ */
+export function readAffordance( id: string, m: ReadonlyMap<string, unknown> | Record<string, unknown> | undefined ): Affordance {
   const meta = ( m ?? {} ) as Record<string, unknown>
   return {
     id,
@@ -729,6 +860,12 @@ function readAffordance( id: string, m: ReadonlyMap<string, unknown> | Record<st
     available:       meta['available'] === true,
     tags:            Array.isArray( meta['tags'] ) ? ( meta['tags'] as unknown[] ).filter( ( t ): t is string => typeof t === 'string') : [],
     planBias:        typeof meta['planBias'] === 'number' ? ( meta['planBias'] as number ) : undefined,
+    willBias:        typeof meta['willBias'] === 'number' ? ( meta['willBias'] as number ) : undefined,
+    socialPrior:     typeof meta['socialPrior'] === 'number' ? ( meta['socialPrior'] as number ) : undefined,
+    justEnacted:     typeof meta['justEnacted'] === 'number' ? ( meta['justEnacted'] as number ) : undefined,
+    settled:         typeof meta['settled'] === 'number' ? ( meta['settled'] as number ) : undefined,
+    availability:    typeof meta['availability'] === 'number' ? ( meta['availability'] as number ) : undefined,
+    description:     str( meta['description'] ),
     planId:          str( meta['planId'] ),
     stepId:          str( meta['stepId'] ),
     tick:            num( meta['tick'], 0 ),