@mindot/will 0.8.0 → 0.9.0

package/src/pma/index.ts

@@ -32,6 +32,7 @@ import { readFileSync, existsSync } from 'node:fs'
 import { join }                     from 'node:path'
 
 import type { SimulationState }    from '#core/types'
+import { mergeEngineConfig }        from '#cognition/config.mirror.entities'
 import type { DefaultSimulation }  from '#core/simulation'
 import type { Cognition }          from '#types'
 import type {
@@ -45,6 +46,7 @@ import {
   loadCompetence,
   type CompetenceSnapshot,
 } from '#agency/competence.codec'
+import { mergeIdentity, composeIdentityPrompt, readPersona, IDENTITY_ENTITY_ID } from '#cognition/identity.entity'
 
 // ── Schema version ─────────────────────────────────────────────
 // Bump this when any field is removed or semantically changed.
@@ -361,7 +363,12 @@ export class PMADistiller {
       if( entity.type === 'will.identity'){
         const m = entity.metadata ?? {}
         return {
-          prompt:  ( m['prompt']  as string )                     ?? '',
+          // The TENANT's text only. Capturing the composed `prompt` baked the
+          // container's WILL_CORE_PREAMBLE into the artifact, so a woken mind
+          // recited whichever build's preamble had distilled it — forever, and
+          // invisibly. `readPersona` falls back to stripping it out of a composed
+          // prompt, so artifacts written before the split load clean too.
+          prompt:  readPersona( m ),
           values:  ( m['values']  as string[] )                   ?? [],
           traits:  ( m['traits']  as Record<string, number> )     ?? {},
           traitStats: ( m['traitStats'] as PMAIdentity['traitStats'] ) ?? undefined,
@@ -792,22 +799,31 @@ export class PMALoader {
     const sm = simulation.stateManager
 
     // ── 1. Identity (with enhanced fields) ────────────────────
-    sm.setEntity({
-      id:        'identity-self',
-      type:      'will.identity',
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-      metadata: {
-        prompt:  pma.identity.prompt,
-        values:  pma.identity.values,
-        traits:  pma.identity.traits,
-        traitStats: pma.identity.traitStats,   // restore the Will's own norm (graded salience B/C)
-        version: pma.identity.version,
-        style:   pma.identity.style,
-        socialOrientation: pma.identity.socialOrientation,
-        trustPropensity:   pma.identity.trustPropensity,
-        memoryPersistence: pma.identity.memoryPersistence,
-      },
+    // MERGING (see cognition/identity.entity). An artifact carries what the mind
+    // LEARNED about itself; it does not carry the mind's name, because the name is
+    // supplied at boot by whoever is renting the container. This used to replace
+    // the entity outright, so `_seedIdentity`'s `name` — written moments earlier
+    // in the same wake — was erased before the first tick, every single wake.
+    // Recomposed, never restored verbatim: `pma.identity.prompt` is layer 2 (the
+    // persona), and layer 1 comes from the build that is running NOW. This is what
+    // makes a preamble fix reach minds that already exist.
+    const environment = sm.getEntity( IDENTITY_ENTITY_ID )?.metadata?.['environment']
+    // Through `readPersona`, NOT raw. An artifact written before the layers were
+    // split stores the COMPOSED prompt, so composing over it again gives the mind
+    // its own architecture twice. Putting this fallback only in the distiller was
+    // not enough — the loader is what every existing artifact goes through.
+    const persona = readPersona({ prompt: pma.identity.prompt })
+    mergeIdentity( sm, {
+      persona,
+      prompt:  composeIdentityPrompt( persona, typeof environment === 'string' ? environment : undefined ),
+      values:  pma.identity.values,
+      traits:  pma.identity.traits,
+      traitStats: pma.identity.traitStats,   // restore the Will's own norm (graded salience B/C)
+      version: pma.identity.version,
+      style:   pma.identity.style,
+      socialOrientation: pma.identity.socialOrientation,
+      trustPropensity:   pma.identity.trustPropensity,
+      memoryPersistence: pma.identity.memoryPersistence,
     })
 
     // ── 1b. Persona (learned self-tuning from the metacognition cycle) ──
@@ -889,55 +905,53 @@ export class PMALoader {
     const temperamentValence = pma.emotionalBaseline.temperamentValence
     const reactivity = pma.emotionalBaseline.reactivity
 
-    sm.setEntity({
-      id:        'engine-config-affective-blender',
-      type:      'engine.config',
-      createdAt: Date.now(),
-      updatedAt: Date.now(),
-      metadata: {
-        engine: 'affective-blender',
-        params: {
-          inertia: 1 - reactivity,
-          temperamentValence,
-        },
+    // MERGE, never replace — same trap as engine-config-executive. The mirror
+    // seeds `emitBlendEvents` here and the PMA carries only `inertia`, so a
+    // whole-entity write silently dropped it for every restored Will.
+    mergeEngineConfig( sm, {
+      id: 'engine-config-affective-blender', engine: 'affective-blender',
+      params: {
+        inertia: 1 - reactivity,
+        temperamentValence,
       },
-    })
+    }, 'incoming')
 
     // ── 6. Behavioral parameters ──────────────────────────────
     if( pma.behavioral.riskTolerance !== undefined ||
         pma.behavioral.explorationRate !== undefined ||
         pma.behavioral.impulsivity !== undefined ){
 
-      sm.setEntity({
-        id:        'engine-config-executive',
-        type:      'engine.config',
-        createdAt: Date.now(),
-        updatedAt: Date.now(),
-        metadata: {
-          engine: 'executive',
-          params: {
-            riskTolerance:   pma.behavioral.riskTolerance   ?? 0.5,
-            explorationRate: pma.behavioral.explorationRate ?? 0.3,
-            impulsivity:     pma.behavioral.impulsivity     ?? 0.3,
-          },
+      // MERGE onto the seeded mirror, never replace it.
+      //
+      // createWill() seeds engine-config-executive first (executiveInterval,
+      // cooldownTicks, deliberateThreshold, maxFacets); loadPMA() runs after. A
+      // whole-entity write here dropped every param the PMA does not carry — so
+      // for every Will restored from an artifact (i.e. every production Will), the
+      // executive's dual-process gate lost its base, `readBaseParams` returned
+      // nothing for `deliberateThreshold`, and consolidatePrior skipped its
+      // adjustments outright: the analytical/decisiveness edges that are supposed
+      // to develop how readily this mind stops to think had no base to move.
+      mergeEngineConfig( sm, {
+        id: 'engine-config-executive', engine: 'executive',
+        params: {
+          riskTolerance:   pma.behavioral.riskTolerance   ?? 0.5,
+          explorationRate: pma.behavioral.explorationRate ?? 0.3,
+          impulsivity:     pma.behavioral.impulsivity     ?? 0.3,
         },
-      })
+      }, 'incoming')
     }
 
     // Configure memory persistence for ForgettingCurve
     if( pma.identity.memoryPersistence !== undefined ){
-      sm.setEntity({
-        id:        'engine-config-forgetting',
-        type:      'engine.config',
-        createdAt: Date.now(),
-        updatedAt: Date.now(),
-        metadata: {
-          engine: 'forgetting-curve',
-          params: {
-            baseForgettingRate: 1 - ( pma.identity.memoryPersistence * 0.7 ),
-          },
+      // MERGE — the mirror seeds emotionProtection / pruningThreshold /
+      // maxPrunePerTick here and the PMA carries only baseForgettingRate, so a
+      // whole-entity write dropped three params on every restore.
+      mergeEngineConfig( sm, {
+        id: 'engine-config-forgetting', engine: 'forgetting-curve',
+        params: {
+          baseForgettingRate: 1 - ( pma.identity.memoryPersistence * 0.7 ),
         },
-      })
+      }, 'incoming')
     }
 
     // ── 7. Relationship stubs ─────────────────────────────────

package/src/sdk/will.ts

@@ -56,6 +56,8 @@ export interface Stimulus {
   speaker?: string
   /** Conversation/thread id (default = `from`). */
   thread?: string
+  /** True when `thread` is private — just this someone and the Will. See TextMessage.direct. */
+  direct?: boolean
 }
 
 /** A message the Will emitted to someone. */
@@ -66,6 +68,20 @@ export interface WillMessage {
   content: string
   /** Entity id the Will addressed (the speaker you used in say()/tell(), or a bond). */
   to: string
+  /**
+   * The conversation this belongs to — the `thread` from the `perceive()` that
+   * prompted it. Absent when the Will spoke unprompted, which genuinely has no
+   * thread.
+   *
+   * WHERE, not just to whom. The engine knew this the whole way down —
+   * `OutboxMessage.threadId` carries it — and the projection dropped it here, so
+   * a channel adapter had nothing to answer INTO and had to guess from a roster.
+   * Observed live: a DM arrived on `discord:1532693…`, she answered it correctly
+   * and in seconds, and the reply went to the shared server channel because that
+   * was the last room the roster had seen this person in. From the operator's
+   * side she had simply ignored him.
+   */
+  thread?: string
 }
 
 /**
@@ -319,17 +335,29 @@ export class Will {
     pma: PMASnapshot,
     opts: Omit<CreateWillOptions, 'identity'> & { identity?: Partial<WillIdentity> },
   ): Promise<Will> {
-    const id = opts.id ?? `${slug( opts.name )}-${Math.random().toString( 36 ).slice( 2, 8 )}`
+    // Waking IS being the same mind, so the id continues from the artifact unless the
+    // caller overrides it. The id is the path key for everything durable that lives
+    // OUTSIDE the artifact — `data/wills/<id>/vector_index`, snapshots, session logs.
+    // Minting a fresh `name-<random>` here gave a woken mind a brand-new, empty vector
+    // store every boot: identity/beliefs/goals returned (those are in the artifact) while
+    // episodic recall came back permanently empty, and the orphaned index was left behind
+    // on disk. Observed: four boots, four `lora-*` directories, four 4KB indexes, and a
+    // mind that concluded at 100% confidence that its own channel might not be viable
+    // because it could not recall a conversation it had just had.
+    const id = opts.id ?? pma.willId ?? `${slug( opts.name )}-${Math.random().toString( 36 ).slice( 2, 8 )}`
     const stem = new WillStem()
     const will = new Will( stem, id, opts.name )
 
     for( const [ name, entry ] of Object.entries( opts.effectors ?? {} ) )
       will._register( name, entry )
 
-    await stem.createWill(
-      will._buildConfig( id, { ...opts, identity: { prompt: '', ...opts.identity } } ),
-      true /* startPaused — load the artifact before the first tick */,
-    )
+    const config = will._buildConfig( id, { ...opts, identity: { prompt: '', ...opts.identity } } )
+    // Say out loud that this identity is a placeholder. Otherwise the creation
+    // guard warns about the empty persona we just constructed on purpose — three
+    // alarms per wake, drowning the real check that runs when the artifact loads.
+    config.identityFromArtifact = true
+
+    await stem.createWill( config, true /* startPaused — load the artifact before the first tick */ )
     stem.loadPMA( id, pma )
     stem.resumeWill( id )
     will._attach()
@@ -358,6 +386,8 @@ export class Will {
       // the Will knows the person as "someone" until a real one is learned. (The live
       // conversation focus still falls back to the entity id for its Speaker line.)
       ...( stimulus.speaker ? { speakerName: stimulus.speaker } : {} ),
+      // Omitted rather than defaulted: an unknown room is not known to be public.
+      ...( stimulus.direct !== undefined ? { direct: stimulus.direct } : {} ),
     } )
   }
 
@@ -561,7 +591,10 @@ export class Will {
     this._unsub = this.stem.addTickListener( this.id, ( _snapshot, _tick, outbox, invocations ) => {
       // Outbound messages → event + auto delivery-ack.
       for( const msg of outbox ){
-        this._emitMessage( { id: msg.id, content: msg.content, to: msg.targetEntityId } )
+        this._emitMessage( {
+          id: msg.id, content: msg.content, to: msg.targetEntityId,
+          ...( msg.threadId ? { thread: msg.threadId } : {} ),
+        } )
         try { this.stem.confirmMessageDelivery( this.id, msg.id, true ) } catch { /* best-effort */ }
       }
       // Effector invocations → project the motor act, then run the handler → ack.

package/src/stem/assembly.audit.ts

@@ -86,3 +86,4 @@ export function auditAssemblyWiring( engines: readonly SimulationEngine[] ): Wir
 export function wiringKeys( records: WiringRecord[], status: WiringRecord['status'] ): string[] {
   return records.filter( r => r.status === status ).map( r => `${r.engine}.${r.method}`).sort()
 }
+

package/src/stem/guards/identity.coherence.ts

@@ -51,7 +51,7 @@ export interface IdentityReviewer {
 // MODEL_ROUTING W0 — a one-shot classification at creation time; constant low
 // demand (structurally background, and it runs before there is a mind whose
 // state could modulate it).
-const COHERENCE_META: LLMCallMeta = { category: 'identity-guard', attribute: 'guard', function: 'identity-coherence', demand: BACKGROUND_DEMAND }
+const COHERENCE_META: LLMCallMeta = { category: 'identity-guard', attribute: 'guard', process: 'cog', function: 'identity-coherence', demand: BACKGROUND_DEMAND }
 
 const VALID_KINDS = new Set<CoherenceIssue['kind']>( [ 'contradiction', 'false-capability', 'injection', 'incoherence', 'other' ] )
 

package/src/stem/index.ts

@@ -23,7 +23,7 @@ import type { ExecutiveOutputFull } from '#faculties/executive.engine'
 import type { Cognition, OutboxMessage, effectorInvocation, WorldInterface } from '#types'
 import type { TextMessage, SensoryInput } from '#senses/index'
 import type { ActivityEvent, ActivityEventHandler } from '#cognition/faculties/planning.engine/engine'
-import { assembleMind, type WillConfig } from '#stem/mind'
+import { assembleMind, backfillEngineConfigs, resolveExecutiveInterval, type WillConfig } from '#stem/mind'
 import { reviewIdentityCoherence as runCoherenceReview, type CoherenceInput, type CoherenceResult } from '#stem/guards/identity.coherence'
 import { SessionLogger } from '#stem/tracts/session.logger'
 import { fileLoggingEnabled } from '#stem/tracts/transport/stream.transport'
@@ -39,10 +39,13 @@ import { InboundQueue } from '#stem/tracts/inbound.queue'
 import type { ExternalTransport } from '#stem/tracts/transport'
 import { effectorController } from '#stem/tracts/effector.controller'
 import { externalSchemas } from '#agency/schemas/external'
+import { inFlightOnRestore } from '#agency/restart'
+import { buildEngineConfigEntities } from '#cognition/config.mirror.entities'
 import type { EffectorDeclaration } from '#agency/types'
 import { SensoryController } from '#stem/tracts/sensory.controller'
 import { BiographyWriter } from '#stem/tracts/biography.writer'
 import { HealthReporter } from '#stem/tracts/health.reporter'
+import { mergeIdentity } from '#cognition/identity.entity'
 
 // ── Types ─────────────────────────────────────────────────────
 
@@ -224,8 +227,66 @@ export class WillStem {
       try {
         const previousState = await simulation.snapshotManager.loadLatestFromStorage()
         if( previousState ){
+          // Work that was in flight when the mind slept does not resume — see
+          // agency/restart.ts. Dropped BEFORE restore so it never enters live
+          // state at all, rather than being swept on some later tick.
+          const inFlight = inFlightOnRestore( previousState.entities )
+          for( const id of inFlight ) previousState.entities.delete( id )
+
           simulation.stateManager.restore( previousState, { entities: true, metrics: false } )
-          logger.info(`[WillStem] Restored snapshot for ${config.id} — ${previousState.entities.size} entities loaded`)
+
+          // TIME MUST NOT GO BACKWARDS.
+          //
+          // Entities come back stamped with the tick they were written at, and
+          // the orchestrator overwrites the StateManager's tick from the CLOCK
+          // every tick (`_clock.tick()` → `updateClock`) — so restoring the
+          // manager's tick alone is undone immediately. The clock is the source
+          // of truth and has to resume too.
+          //
+          // Without this, every `tick - stampedTick` in the codebase computed a
+          // negative age. Measured: an awaiting intent read `-589 ticks`, so it
+          // could never time out, and the selector's staleness decay inverted
+          // into amplification (`1 - (-39 × 0.5)` = 20.6×) — a 0.47 incumbent
+          // scoring 9.74, unpreemptable, holding the channel against every other
+          // contact indefinitely and across restarts. It also means tick-stamped
+          // entity ids (`affordance-${tick}-…`, `agency-outcome-${tick}-…`) stop
+          // colliding with a previous session's.
+          simulation.clock.setTick( previousState.tick )
+
+          // The restore above replaced the entity map wholesale, including the
+          // engine-config mirror `assembleMind` had just seeded — so a Will woke
+          // with whatever config it FIRST hibernated under, and every tunable
+          // added since was unreachable to it. Restored values win; only params it
+          // has never seen are added.
+          backfillEngineConfigs( simulation, buildEngineConfigEntities( config, resolveExecutiveInterval( config ) ) )
+
+          // The same wholesale replacement takes `identity-self` — so the name
+          // `_seedIdentity` wrote moments ago is replaced by whatever the snapshot
+          // carries, which for any mind hibernated before the merging writer
+          // existed is NO NAME AT ALL.
+          //
+          // Caught only by booting: making every writer merge is necessary and was
+          // not sufficient, because restore is not a writer — it is the whole map
+          // arriving at once, and it lands between `_seedIdentity` and `loadPMA`.
+          // A live Will woke from a repaired build and still told her operator "my
+          // self-model says I'm Will".
+          //
+          // ONLY the name is re-asserted. Everything else on this entity — prompt,
+          // values, traits, traitStats, style — is the mind's own accumulated
+          // self-knowledge and must come from the snapshot, not from boot config.
+          // The name is the one field the container supplies and the tenant never
+          // learns, which is exactly why it is the one field a restore may not eat.
+          if( config.name ){
+            const restored = mergeIdentity( simulation.stateManager, { name: config.name } )
+            if( restored.length )
+              logger.info(`[WillStem] identity-self: re-asserted name '${config.name}' after restore`)
+          }
+
+          logger.info(
+            `[WillStem] Restored snapshot for ${config.id} — ${previousState.entities.size} entities loaded, ` +
+            `resuming at tick ${previousState.tick}` +
+            ( inFlight.length ? ` (dropped ${inFlight.length} in-flight)` : '')
+          )
         }
       }
       catch( err ){ logger.warn(`[WillStem] Snapshot restore failed for ${config.id} — starting fresh:`, err ) }
@@ -459,6 +520,12 @@ export class WillStem {
     instance.simulation.snapshotManager.persistNow( pauseState )
       .catch( err => logger.error(`[WillStem] snapshot persist failed on pause (${id}):`, err ))
 
+    // The vector index lives outside the snapshot and only ever persisted itself from
+    // a debounce timer nothing awaited — so it died with the process, and every
+    // restart cold-started with an EMPTY index no matter how much was consolidated.
+    instance.cognition.vectorMemory?.persist()
+      .catch( ( err: unknown ) => logger.error(`[WillStem] vector index persist failed on pause (${id}):`, err ))
+
     this._biography.writeSessionSummary( instance )
     this._biography.writeEmotionalBiographySummary( instance )
     instance.sessionLogger?.close()
@@ -574,6 +641,16 @@ export class WillStem {
       instance.simulation.stateManager.applyCommands( flushCmds )
     const archiveState = instance.simulation.stateManager.snapshot()
     await instance.simulation.snapshotManager.persistNow( archiveState )
+
+    // …and the vector index, which is NOT part of that snapshot. Awaited here (unlike
+    // the pause path) because the process usually exits straight after this: a
+    // fire-and-forget write would simply be lost, which is exactly how a mind ended a
+    // session having consolidated episodes and left a 198-byte index on disk.
+    // Indexing runs in the background (it must not stall the tick loop), so drain it
+    // first — otherwise the last episodes consolidated are still mid-embed when the
+    // index is written and are absent from the file this session leaves behind.
+    await instance.cognition.episodicConsolidator.flushIndexing()
+    await instance.cognition.vectorMemory?.persist()
   }
 
   // Session-biography writers (behavioral + emotional) extracted to