@mindot/will 0.9.0 → 0.10.0

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

@@ -35,9 +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, CONSEQUENCE_TTL_TICKS, type ConsequenceDescriptor } from '#agency/consequence'
+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
@@ -68,12 +71,31 @@ export class AffordanceSynthesizer implements CognitiveEngine {
    * 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
@@ -131,7 +153,21 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     // `_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 )
+    // 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.
@@ -140,7 +176,12 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     // 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._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[]      = []
@@ -191,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 )
@@ -208,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, {
@@ -217,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 ──
@@ -255,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,
@@ -367,12 +442,31 @@ export class AffordanceSynthesizer implements CognitiveEngine {
     // 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, ctx.targetEntityId, tick, this._satiationWindow,
+      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
@@ -396,6 +490,7 @@ export class AffordanceSynthesizer implements CognitiveEngine {
       ...( availability < 1 ? { availability } : {} ),
       ...( socialPrior !== 0 ? { socialPrior } : {} ),
       ...( justEnacted > 0 ? { justEnacted } : {} ),
+      ...( settled > 0 ? { settled } : {} ),
       planBias:        ctx.planBias,
       willBias:        ctx.willBias,
       planId:          ctx.planId,
@@ -423,6 +518,15 @@ export class AffordanceSynthesizer implements CognitiveEngine {
         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,

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 )
+}