@mindot/will 0.7.0 → 0.9.0

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

@@ -0,0 +1,260 @@
+// ─────────────────────────────────────────────────────────────
+// 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 }
+
+/** 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

@@ -38,6 +38,7 @@ import {
 import { readEffectiveParams, readPersonaPrior } from '#cognition/persona.prior'
 import { RUPTURE_REVOKE_GATE, revocationEntity } from '#agency/revocation'
 import { liveConsequences, matchConsequenceText } from '#agency/consequence'
+import { asFinality } from '#stem/policy/arbiter'
 
 /**
  * Activation margin (winner − runner-up) below which the choice is "contested" —
@@ -370,6 +371,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
@@ -425,12 +462,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
@@ -477,6 +539,11 @@ export class ActionSelector implements CognitiveEngine {
         targetEntityId:  winner.affordance.targetEntityId,
         parameters:      winner.affordance.parameters,
         source:          winner.affordance.source,
+        // 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 } : {} ),
         // Plan provenance (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 } : {} ),
@@ -657,7 +724,7 @@ function refusedClassSchemas( state: ReadonlySimulationState ): Set<string> {
   for( const e of state.entities.values() ){
     if( e.type !== 'agency.outcome') continue
     const m = e.metadata
-    if( m?.['refused'] !== true || str( m?.['finality'] ) !== 'class') continue
+    if( m?.['refused'] !== true || asFinality( m?.['finality'] ) !== 'class') continue
     const schema = str( m?.['schema'] )
     if( schema ) out.add( schema )
   }
@@ -676,6 +743,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 ),
   }
 }
 
@@ -728,6 +808,8 @@ 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,
     planId:          str( meta['planId'] ),
     stepId:          str( meta['stepId'] ),
     tick:            num( meta['tick'], 0 ),

package/src/cognition/agency/engines/affordance.synthesizer.ts

@@ -36,6 +36,8 @@ import type { Affordance, AffordanceSource, MotorSchema, LearnedSkill, SchemaPre
 import type { SchemaRepertoire } from '#agency/schemas/repertoire'
 import { INNATE_SCHEMAS } from '#agency/schemas/innate'
 import { collectGoalTargets } from '#agency/selection.scoring'
+import { readEffectiveParams } from '#cognition/persona.prior'
+import { liveConsequences, enactionFootprint, spokenAtByEntity, CONSEQUENCE_TTL_TICKS, type ConsequenceDescriptor } from '#agency/consequence'
 
 /** Default field width for non-innate affordances when no attention metric exists. */
 const DEFAULT_ATTENTION_CAP = 5
@@ -59,6 +61,19 @@ export class AffordanceSynthesizer implements CognitiveEngine {
   private _schemas:     MotorSchema[]
   private _skills:      SkillAccessor | null = null
   private _repertoire:  SchemaRepertoire | null = null
+
+  /**
+   * This tick's live consequence descriptors — the acts the mind has performed
+   * whose outcome has not yet come back. Refreshed once at the top of react()
+   * because `_build` runs per candidate and reading them is a full-entity scan.
+   */
+  private _inFlight: readonly ConsequenceDescriptor[] = []
+
+  /** Ticks an act stays satiating (engine-config-action-selector.repeatWindowTicks). */
+  private _satiationWindow: number = CONSEQUENCE_TTL_TICKS
+
+  /** Tick of the last thing said to each entity — outlives the descriptor sweep. */
+  private _spokenAt: ReadonlyMap<string, number> = new Map()
   private _bus:         CognitiveBus | null = null
   private _defaultCap:  number
   private _lastFieldSize = 0
@@ -112,6 +127,21 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     const valence   = metric( state, 'affect.valence', 0 )
     const energyLow = metric( state, 'energy.level', 0 ) < 30
 
+    // The mind's own acts still in flight (EXAFFERENCE P5). Read once per tick —
+    // `_build` runs for every candidate and this is a full-entity scan. Each
+    // candidate whose (schema, target) matches one of these carries a decaying
+    // `justEnacted`, so having just done a thing damps doing it again.
+    this._inFlight = liveConsequences( state.entities, tick )
+    // How long this mind sits with something it has already done before doing it
+    // again — the tenant's, not the container's. Falls back to the echo TTL only
+    // when unseeded, so a bare harness behaves as before.
+    this._satiationWindow = readEffectiveParams( state, 'engine-config-action-selector').repeatWindowTicks
+      ?? CONSEQUENCE_TTL_TICKS
+    // Durable "when did I last speak to them". Descriptors alone cannot carry
+    // satiation — the executor deletes them at their echo TTL, so any window
+    // longer than that was a no-op.
+    this._spokenAt = spokenAtByEntity( state.entities )
+
     const set:    EntityInput[] = []
     const del:    string[]      = []
 
@@ -204,13 +234,18 @@ export class AffordanceSynthesizer implements CognitiveEngine {
 
       if( !schema ) continue
 
+      // `priority` is the confidence the executive decided with. It sets BOTH the
+      // evoke-salience (field admission) and — via willBias — the activation the
+      // selector scores, so a decision made at 0.85 pushes harder than one at 0.5.
+      const willBias = clamp01( num( m?.['priority'], 0.8 ) )
       candidates.push({
-        salience: IDEOMOTOR_BASE_SALIENCE + num( m?.['priority'], 0.8 ),
+        salience: IDEOMOTOR_BASE_SALIENCE + willBias,
         affordance: this._build( schema, tick, state, valence, energyLow, skills, {
           evokedBy:       id,
           targetEntityId: str( m?.['targetEntityId'] ),
           parameters:     ( m?.['parameters'] as Record<string, unknown> ) ?? {},
           source:         'ideomotor',
+          willBias,
         } ),
       })
     }
@@ -303,6 +338,7 @@ export class AffordanceSynthesizer implements CognitiveEngine {
       parameters?:     Record<string, unknown>
       source?:         AffordanceSource
       planBias?:       number
+      willBias?:       number
       planId?:         string
       stepId?:         string
     },
@@ -313,6 +349,13 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     // Will's affordance field is byte-identical. Present only once a refusal dented it.
     const availability = this._repertoire?.availabilityOf( schema.id ) ?? 1
 
+    // What the mind has LEARNED about the person this act is aimed at. Only for a
+    // targeted act; 0 for everything else, so the field is unchanged for a mind that
+    // knows no one. See Affordance.socialPrior.
+    const socialPrior = ctx.targetEntityId
+      ? socialStanding( state, ctx.targetEntityId )
+      : 0
+
     // Learned value if known, else the schema's intrinsic prior mapped to 0..1.
     const expectedReward = skill?.valueEstimate ?? clamp01( ( ( schema.baseValence ?? 0 ) + 1 ) / 2 )
     const expectedValence = schema.baseValence ?? valence
@@ -320,6 +363,16 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     // Low energy makes everything feel costlier.
     const cost            = clamp01( schema.cost * ( energyLow ? 1.5 : 1 ) )
 
+    // This act's own footprint, if it is still in flight toward this same person.
+    // Satiation only applies to acts aimed at someone the mind SPEAKS to — the
+    // `conversation.sent` half is keyed by person, so it must not damp, say,
+    // inspecting them.
+    const speaks = schema.tags?.includes('communication') ?? false
+    const justEnacted = enactionFootprint(
+      this._inFlight, schema.id, ctx.targetEntityId, tick, this._satiationWindow,
+      speaks ? this._spokenAt : undefined,
+    )
+
     const key    = ctx.targetEntityId ?? ctx.evokedBy ?? schema.id
     const source = ctx.source ?? schema.source
     // A non-default-source candidate (ideomotor) gets a distinct id so it can coexist
@@ -341,7 +394,10 @@ export class AffordanceSynthesizer implements CognitiveEngine {
       tags:            schema.tags ?? [],
       ...( schema.description ? { description: schema.description } : {} ),
       ...( availability < 1 ? { availability } : {} ),
+      ...( socialPrior !== 0 ? { socialPrior } : {} ),
+      ...( justEnacted > 0 ? { justEnacted } : {} ),
       planBias:        ctx.planBias,
+      willBias:        ctx.willBias,
       planId:          ctx.planId,
       stepId:          ctx.stepId,
       tick,
@@ -366,7 +422,9 @@ export class AffordanceSynthesizer implements CognitiveEngine {
         tags:            a.tags,
         description:     a.description,
         ...( a.availability !== undefined ? { availability: a.availability } : {} ),
+        ...( a.socialPrior !== undefined ? { socialPrior: a.socialPrior } : {} ),
         planBias:        a.planBias,
+        willBias:        a.willBias,
         planId:          a.planId,
         stepId:          a.stepId,
         tick:            a.tick,
@@ -415,3 +473,34 @@ function str( v: unknown ): string | undefined {
 function clamp01( n: number ): number {
   return n < 0 ? 0 : n > 1 ? 1 : n
 }
+
+/**
+ * The mind's learned read on one person, −1..1 (0 = unknown or neutral).
+ *
+ * Every input is something the mind formed from experience, none is a constant:
+ *   • ReputationTracker's `trustworthiness`, centred on 0.5 and scaled by that
+ *     model's own `confidence`, so an opinion held on two interactions pushes
+ *     far less than one held on fifty.
+ *   • the mind's current affective tone, as a gentle tilt — feeling low makes
+ *     reaching for anyone a little less attractive, which is a mood, not a verdict
+ *     on them, so it is weighted small and applies the same way to everybody.
+ *
+ * This is the path by which "they never answer me" reaches the competition: the
+ * ReputationTracker learns it from `interaction.occurred`, which only started firing
+ * once inbound conversation reached social cognition (#113).
+ */
+function socialStanding( state: ReadonlySimulationState, keid: string ): number {
+  let trust = 0
+  for( const e of state.entities.values() ){
+    if( e.type !== 'reputation') continue
+    const m = e.metadata as Record<string, unknown> | undefined
+    if( m?.['keid'] !== keid ) continue
+    const t = num( m['trustworthiness'], 0.5 )
+    const c = clamp01( num( m['confidence'], 0 ) )
+    trust = ( t - 0.5 ) * 2 * c
+    break
+  }
+
+  const mood = num( state.metrics.get('affect.valence'), 0 ) * 0.25
+  return Math.max( -1, Math.min( 1, trust + mood ) )
+}