@mindot/will 0.8.0 → 0.10.0

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

@@ -35,7 +35,12 @@ import type { CognitiveEventSchema } from '#cognition/schema.registry'
 import type { Affordance, AffordanceSource, MotorSchema, LearnedSkill, SchemaPrecondition } from '#agency/types'
 import type { SchemaRepertoire } from '#agency/schemas/repertoire'
 import { INNATE_SCHEMAS } from '#agency/schemas/innate'
+import { CURIOUS_RESOLVED } from '#faculties/known.entity.tracker'
 import { collectGoalTargets } from '#agency/selection.scoring'
+import { readEffectiveParams } from '#cognition/persona.prior'
+import { liveConsequences, enactionFootprint, spokenAtByEntity, enactedAtBySchemaTarget, CONSEQUENCE_TTL_TICKS, type ConsequenceDescriptor } from '#agency/consequence'
+import { readAliases, canonicalOf } from '#cognition/social.identity'
+import { liveSettlements, settlementForce, type SettlementDescriptor } from '#agency/settlement'
 
 /** Default field width for non-innate affordances when no attention metric exists. */
 const DEFAULT_ATTENTION_CAP = 5
@@ -59,6 +64,38 @@ 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[] = []
+  /** Durable "when did I last do this TO them" — the entity-bound peer of
+   *  `_spokenAt`, collected once per tick for the same reason `_inFlight` is. */
+  private _enactedAt: ReadonlyMap<string, number> = new Map()
+
+  /** Ticks an act stays satiating (engine-config-action-selector.repeatWindowTicks). */
+  private _satiationWindow: number = CONSEQUENCE_TTL_TICKS
+  /** Verdicts System 2 has already reached and that have not yet aged out.
+   *  Collected once per tick for the same reason `_inFlight` is — `_build` runs
+   *  per candidate and this is a full-entity scan. */
+  private _settled: SettlementDescriptor[] = []
+
+  /** Tick of the last thing said to each entity — outlives the descriptor sweep. */
+  private _spokenAt: ReadonlyMap<string, number> = new Map()
+  private _spokeAnywhereAt: number | undefined = undefined
+  /**
+   * alias id → anchor id, read once per tick.
+   *
+   * Every surface below is keyed by WHO an act was aimed at, and the mind meets
+   * one person under more than one id: a reply is addressed to the transport id
+   * the percept arrived with (`discord:1019…`), a self-initiated message to the
+   * anchor the executive resolved (`ke:…`). `readSpokenTurns` resolved that for
+   * the PROMPT from the start; nothing resolved it for the WEIGHTS, so having
+   * just answered someone did not damp reaching out to them a cycle later.
+   */
+  private _canon: ( id: string ) => string = id => id
   private _bus:         CognitiveBus | null = null
   private _defaultCap:  number
   private _lastFieldSize = 0
@@ -112,6 +149,40 @@ 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.
+    // One scan, then every target-keyed surface below shares its id space. They
+    // must agree with each other AND with the lookup at the call site: canonical
+    // keys read with a raw target damps nothing, and a raw key read with a
+    // canonical target breaks the damping that already worked.
+    const aliases = readAliases( state.entities )
+    this._canon = ( id: string ) => canonicalOf( aliases, id )
+
+    this._inFlight = liveConsequences( state.entities, tick, this._canon )
+    // Durable per-(schema, target) enaction. Descriptors alone expire at the ECHO
+    // window, so without this the back half of the satiation window damped
+    // nothing for any act with an object that is not speech.
+    this._enactedAt = enactedAtBySchemaTarget( state.entities, this._canon )
+    // What the mind has already decided. Read here so a verdict reaches the
+    // competition as a force in the field rather than a fact about one intent.
+    this._settled = liveSettlements( state.entities, tick, this._canon )
+    // 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, this._canon )
+    // When this mind last spoke to ANYONE — the satiation arm that is not about
+    // the listener. Computed once per tick rather than per candidate.
+    let last = -Infinity
+    for( const t of this._spokenAt.values() ) if( t > last ) last = t
+    this._spokeAnywhereAt = last > -Infinity ? last : undefined
+
     const set:    EntityInput[] = []
     const del:    string[]      = []
 
@@ -161,16 +232,18 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     const personSchemas = schemas.filter( s => s.binds === 'entity')
     const objectSchemas = schemas.filter( s => s.binds === 'object')
 
-    if( personSchemas.length > 0 || objectSchemas.length > 0 )
-      for( const [ id, e ] of state.entities ){
+    // Not gated on there BEING a target-bound schema: `inspect` is offered from
+    // this same loop and belongs to the innate floor, so a mind with no `binds`
+    // schemas at all — which is every mind until a host declares one — must still
+    // reach it. Gating the loop skipped a room entirely, because the innate floor
+    // has no `binds: 'object'` schema for a thing to match.
+    for( const [ id, e ] of state.entities ){
         if( e.type !== 'known-entity') continue
 
         const m    = e.metadata
         const kind = str( m?.['kind'] )
         const applicable = kind === 'sentient' ? personSchemas : kind === 'thing' ? objectSchemas : null
 
-        if( !applicable || applicable.length === 0 ) continue
-
         const keid = str( m?.['keid'] ) ?? id
         const fam  = num( m?.['familiarity'], 0 )
         const val  = num( m?.['valence'], 0 )
@@ -178,7 +251,7 @@ export class AffordanceSynthesizer implements CognitiveEngine {
         const salience = fam * 0.6 + Math.max( 0, val ) * 0.3 + res * 0.1 + ( goalTargets.get( keid ) ?? 0 )
         const name     = str( m?.['name'] ) ?? keid
 
-        for( const schema of applicable )
+        for( const schema of applicable ?? [] )
           candidates.push({
             salience,
             affordance: this._build( schema, tick, state, valence, energyLow, skills, {
@@ -187,6 +260,38 @@ export class AffordanceSynthesizer implements CognitiveEngine {
               parameters:     { targetEntityName: name },
             } ),
           })
+
+        // ── looking at something I cannot place ──────────────────
+        //
+        // The wanting and the doing referenced different things. Curiosity is
+        // per-REFERENT — `drive.curiosity_resolve` rises with
+        // `familiarity × (1 − resolutionConfidence)`, and GoalManager turns it
+        // into a real goal that completes when that referent resolves. But the
+        // only `inspect` on offer bound to PERCEPTS, so a mind could want to know
+        // what a room was, hold a goal about it, and have no act that addressed
+        // it. The pull existed with nowhere to go.
+        //
+        // Offered here at the strength of the not-knowing itself, so the thing it
+        // most wants to place is the thing it is most drawn to look at — and the
+        // affordance appears BECAUSE something is unresolved rather than standing
+        // permanently on offer. A referent it can already place raises no
+        // candidate at all: there is nothing to find out.
+        //
+        // Alongside the percept-bound offering, not instead of it. Examining what
+        // is in front of you and looking up what you cannot place are both real,
+        // and they are not the same act.
+        if( perceptSchema && res < CURIOUS_RESOLVED ){
+          const wonder = fam * ( 1 - res )
+          if( wonder > 0 )
+            candidates.push({
+              salience: wonder + ( goalTargets.get( keid ) ?? 0 ),
+              affordance: this._build( perceptSchema, tick, state, valence, energyLow, skills, {
+                evokedBy:       id,
+                targetEntityId: keid,
+                parameters:     { focus: name, targetEntityName: name },
+              } ),
+            })
+        }
       }
 
     // ── ideomotor candidates: the executive's imagined actions, pre-activated ──
@@ -204,13 +309,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,
         } ),
       })
     }
@@ -220,7 +330,7 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     // action its current frontier needs. The PlanningEngine writes one `plan.prior`
     // per ready frontier step; each enters the field as a HIGH-salience candidate
     // (the frontier is willed) carrying a `planBias` the scorer weighs and the
-    // planId/stepId provenance that flows through to action.outcome so the plan
+    // planId/stepId link that flows through to action.outcome so the plan
     // advances when the field actually enacts it. Like ideomotor, it never bypasses
     // the selector — if a more pressing affordance wins, the plan simply re-projects
     // next tick. The suggested schema must resolve in the repertoire; if it does not,
@@ -303,6 +413,7 @@ export class AffordanceSynthesizer implements CognitiveEngine {
       parameters?:     Record<string, unknown>
       source?:         AffordanceSource
       planBias?:       number
+      willBias?:       number
       planId?:         string
       stepId?:         string
     },
@@ -313,6 +424,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 +438,35 @@ 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.
+    //
+    // For an act with NO OBJECT the footprint is the act itself: there is no
+    // target to key on, and "I have just done this" is the whole of the fact.
+    // The innate floor is entirely objectless, so without this it could not
+    // satiate at all and whichever stance won once won harder each tick after.
+    const speaks = schema.tags?.includes('communication') ?? false
+    // The lookup half. Only the QUESTION "have I just done this to them" is asked
+    // in canonical form — the affordance keeps the id it was built with, because
+    // that is the id the act will be delivered against.
+    const asked = ctx.targetEntityId ? this._canon( ctx.targetEntityId ) : undefined
+    const justEnacted = enactionFootprint(
+      this._inFlight, schema.id, asked, tick, this._satiationWindow,
+      speaks ? this._spokenAt : undefined,
+      skill?.lastEnactedTick,
+      speaks ? this._spokeAnywhereAt : undefined,
+      // Not gated on `speaks`: this is exactly the arm speech does NOT need
+      // (it has `spokenAt`) and every other entity-bound act was missing.
+      this._enactedAt,
+    )
+
+    // The mirror of satiation: having thought this through holds the choice for
+    // a while, and fades. Keyed exactly as `justEnacted` is, so an objectless
+    // verdict cannot leak onto an act that has an object.
+    const settled = settlementForce( this._settled, schema.id, asked, tick )
+
     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 +488,11 @@ export class AffordanceSynthesizer implements CognitiveEngine {
       tags:            schema.tags ?? [],
       ...( schema.description ? { description: schema.description } : {} ),
       ...( availability < 1 ? { availability } : {} ),
+      ...( socialPrior !== 0 ? { socialPrior } : {} ),
+      ...( justEnacted > 0 ? { justEnacted } : {} ),
+      ...( settled > 0 ? { settled } : {} ),
       planBias:        ctx.planBias,
+      willBias:        ctx.willBias,
       planId:          ctx.planId,
       stepId:          ctx.stepId,
       tick,
@@ -366,7 +517,18 @@ export class AffordanceSynthesizer implements CognitiveEngine {
         tags:            a.tags,
         description:     a.description,
         ...( a.availability !== undefined ? { availability: a.availability } : {} ),
+        ...( a.socialPrior !== undefined ? { socialPrior: a.socialPrior } : {} ),
+        // The act's own footprint. Omitted when 0 so a mind that has done nothing
+        // twice writes a byte-identical field — but WRITTEN when it is not, which
+        // it never was: this is the state hop between synthesis and the
+        // competition, and `justEnacted` did not cross it.
+        ...( a.justEnacted !== undefined ? { justEnacted: a.justEnacted } : {} ),
+        // The verdict's standing weight — same hop, same rule. A field the
+        // synthesizer computes and the entity does not carry is a field the
+        // competition never sees, which is how `justEnacted` stayed dormant.
+        ...( a.settled !== undefined ? { settled: a.settled } : {} ),
         planBias:        a.planBias,
+        willBias:        a.willBias,
         planId:          a.planId,
         stepId:          a.stepId,
         tick:            a.tick,
@@ -415,3 +577,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 ) )
+}

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

@@ -31,6 +31,8 @@ import type { CognitiveBus } from '#cognition/bus'
 import type { CognitiveEngine, EngineResult } from '#cognition/types'
 import type { CognitiveEventSchema } from '#cognition/schema.registry'
 import { revokedIntentIds, revocationId } from '#agency/revocation'
+import { settlementEntity, expiredSettlementIds, SETTLEMENT_TTL_TICKS } from '#agency/settlement'
+import { nameOf, isReferentId } from '#cognition/social.identity'
 
 // ── Minimal structural view of the executive's facet machinery ───────────────
 // Kept structural (not an import of the executive engine) so the agency module
@@ -98,7 +100,10 @@ export class DeliberationEngine implements CognitiveEngine {
     // to let go of it — and the tombstone with it. We never deliberate a
     // revoked intent.
     const revoked = revokedIntentIds( state.entities, tick )
-    const del: string[] = []
+    // Aged-out verdicts go with them. Nothing else owns settlements, and a
+    // question whose settlement has expired must be genuinely open again — not
+    // merely inert-but-present, which would leave the state growing forever.
+    const del: string[] = expiredSettlementIds( state.entities, tick )
 
     // One deliberation per tick (the serial bottleneck).
     let target: { id: string; meta: Record<string, unknown> } | null = null
@@ -136,7 +141,15 @@ export class DeliberationEngine implements CognitiveEngine {
 
     return {
       commands: {
-        set:     [ this._commit( id, meta, chosen, candidates, 'facet') ],
+        set: [
+          this._commit( id, meta, chosen, candidates, 'facet'),
+          // The verdict's trace in the field it was called in to resolve.
+          // Written ONLY here, on the path where System 2 actually thought —
+          // the no-executive path below confirms the substrate's winner without
+          // reaching a conclusion, and a mind should not be held to a verdict it
+          // never formed.
+          this._settle( chosen, candidates, tick ),
+        ],
         ...( del.length > 0 ? { delete: del } : {} ),
         metrics: [ [ 'agency.deliberation.count', 1 ] ],
       },
@@ -186,6 +199,25 @@ export class DeliberationEngine implements CognitiveEngine {
     }
   }
 
+  /**
+   * Record that this contest was weighed and settled.
+   *
+   * Keyed on what WON, not on the rival set, so a slightly differently-framed
+   * contest still meets a verdict the mind has already reached — the rivals ride
+   * along as the introspectable reason rather than as a matching key.
+   */
+  private _settle( chosen: string, candidates: Candidate[], tick: Tick ): EntityInput {
+    const cand = candidates.find( c => c.schema === chosen )
+    const over = candidates.filter( c => c.schema !== chosen ).map( c => c.schema )
+    return settlementEntity({
+      schema:         chosen,
+      targetEntityId: cand?.targetEntityId,
+      ...( over.length > 0 ? { over } : {} ),
+      tick,
+      expiresAt:      tick + SETTLEMENT_TTL_TICKS,
+    })
+  }
+
   /** Write the deliberating intent back as 'selected' with the chosen action. */
   private _commit(
     id:         string,
@@ -227,7 +259,35 @@ export class DeliberationEngine implements CognitiveEngine {
     else
       lines.push('My automatic action-selection was uncertain. Candidate actions:')
     candidates.forEach( ( c, i ) => {
-      const to   = c.targetEntityId ? ` toward ${ c.targetEntityId }` : ''
+      // What the target IS, never the id it is filed under.
+      //
+      // This printed `c.targetEntityId` raw, so a mind deliberating was offered
+      // "inspect toward agency-intent-30" and "inspect toward
+      // affordance-1-orient-orient" — engine bookkeeping ids, and by the time a
+      // facet reasons off-tick the affordance entities are already swept. Live,
+      // she said so herself: "the content of all three is opaque — I don't know
+      // what agency-intent-30 actually is", and chose at 0.3 confidence anyway
+      // because the instructions forbid inventing an action outside the list.
+      //
+      // The prompt factory already holds this line for "## People I Know"
+      // ("never leak the raw keid"); the deliberation focus is the one place that
+      // did not. Resolved through the same dossier lookup, so a `reach-out toward
+      // ke:1sqlkux` now reads as the person's name.
+      //
+      // Unresolvable ⇒ the clause is DROPPED rather than filled with an id. An
+      // option the mind cannot identify should look like what it is — a bare act
+      // — instead of borrowing authority from a number it cannot read.
+      const to = ( () => {
+        const id = c.targetEntityId
+        if( !id ) return ''
+        const named = nameOf( state.entities as never, id )
+        if( named ) return ` toward ${ named }`
+        // Unnamed: show it only if it means something to the MIND. A host-supplied
+        // target ("ada") does; an opaque anchor or a piece of engine bookkeeping
+        // does not, and printing those is what produced "inspect toward
+        // agency-intent-30" as a thing to choose.
+        return opaqueToTheMind( id ) ? '' : ` toward ${ id }`
+      } )()
       // The ability's meaning, so the facet weighs what each option IS FOR rather
       // than choosing among bare labels ("give" vs "attack" is a real difference).
       const what = c.description ? ` — ${ c.description }` : ''
@@ -258,3 +318,16 @@ function extractChosen( decision: unknown, candidates: Candidate[] ): string | u
 function str( v: unknown ): string | undefined {
   return typeof v === 'string' ? v : undefined
 }
+
+/**
+ * Ids the mind cannot read anything off.
+ *
+ * A `ke:` anchor is opaque BY DESIGN — 0.9.0 made identity deliberately
+ * meaningless as a string — and the rest are the engine's own bookkeeping
+ * entities, which exist for one tick and say nothing about the world. Neither
+ * belongs in a choice a mind has to make; a host-supplied target does.
+ */
+function opaqueToTheMind( id: string ): boolean {
+  return isReferentId( id )
+    || /^(affordance|agency-intent|agency-outcome|ideomotor|facet|percept)[-:]/.test( id )
+}