@mindot/will 0.8.0 → 0.10.0

package/src/llm/gate.ts

@@ -19,11 +19,14 @@
  *
  * Configured via env vars:
  *   WILL_LLM_CONCURRENCY    max simultaneous LLM calls (default 2)
+ *   WILL_LLM_RESPONSIVE_CONCURRENCY  slots reserved for calls someone outside
+ *                           the mind is waiting on (default 1)
  *   WILL_LLM_MAX_RETRIES    retries before giving up on a 429 (default 4)
  *   WILL_LLM_RETRY_BASE_MS  first retry wait, doubles each attempt (default 2000)
  */
 
 import { logger } from '#core/logger'
+import type { LLMCallFunction } from '#cognition/utilities/token.tracker'
 
 const MAX_CONCURRENT = parseInt( process.env.WILL_LLM_CONCURRENCY ?? '2')
 
@@ -76,6 +79,51 @@ export class LLMSemaphore {
 
 export const llmGate = new LLMSemaphore( MAX_CONCURRENT )
 
+// ── The responsive lane ───────────────────────────────────────
+
+/**
+ * A second gate, for calls someone OUTSIDE the mind is waiting on.
+ *
+ * `WILL_LLM_CONCURRENCY` ships with the comment "the minimum is 3: orbital,
+ * conversation, summary" — an intended allocation that one shared semaphore
+ * cannot enforce. Three slots means any three callers, and a mind deliberating
+ * at ~1,100 output tokens a call keeps all three warm indefinitely.
+ *
+ * Measured on a live COO over 7 hours: 29 of 45 replies began at or past the
+ * limit, and the worst spent 117 of its 131 seconds waiting for a slot rather
+ * than generating — 545 tokens at 4.2 tok/s against a provider that does ~39.
+ * From outside, that is a mind that read your message and said nothing.
+ *
+ * The distinction drawn here is NOT that conversation matters more. It is that
+ * something outside the mind is blocked on this call — a property of the call
+ * itself, which is why the predicate is named for the property and not for a
+ * list of blessed functions. Rumination can wait its turn. A person waiting for
+ * an answer cannot tell a mind that is thinking from one that is gone.
+ */
+const RESPONSIVE_CONCURRENCY = parseInt( process.env.WILL_LLM_RESPONSIVE_CONCURRENCY ?? '1')
+
+export const responsiveGate = new LLMSemaphore( RESPONSIVE_CONCURRENCY )
+
+/**
+ * The cognitive functions something outside the mind is blocked on.
+ *
+ * `outreach` is deliberately absent: the mind started that one, and nobody is
+ * sitting on the other end waiting. Only work that a waiting party is already
+ * owed belongs in the reserved lane — widen this and the reservation stops
+ * meaning anything.
+ */
+const AWAITED_OUTSIDE: ReadonlySet<LLMCallFunction> = new Set([ 'conversation' ])
+
+/** Whether someone outside the mind is blocked on a call of this function. */
+export function isAwaitedOutside( fn: LLMCallFunction | undefined ): boolean {
+  return fn !== undefined && AWAITED_OUTSIDE.has( fn )
+}
+
+/** The lane a call of this function belongs in. */
+export function gateFor( fn: LLMCallFunction | undefined ): LLMSemaphore {
+  return isAwaitedOutside( fn ) ? responsiveGate : llmGate
+}
+
 // ── Rate-limit detection ──────────────────────────────────────
 
 export function isRateLimitError( err: unknown ): boolean {

package/src/llm/index.ts

@@ -8,11 +8,12 @@ import type { SessionLogger } from '#stem/tracts/session.logger'
 import { writeFileSync, mkdirSync } from 'node:fs'
 import type {
   TokenTracker, LLMCallCategory, LLMCallAttribute, LLMCallFunction,
+  LLMCallProcess,
 } from '#cognition/utilities/token.tracker'
 import { type ModelRouter, isNullRouter } from '#llm/routing'
 import { getCompletionRecorder, getCompletionSource } from '#core/completion.recorder'
 import type { LLMCompletionRecord } from '#core/completion.recorder'
-import { withGate } from '#llm/gate'
+import { withGate, gateFor } from '#llm/gate'
 import { matchConversationFocus, wrapReplyText } from '#llm/wire.contracts'
 
 /**
@@ -263,6 +264,48 @@ export interface LLMCallResult {
   cacheWriteTok?: number
 }
 
+/**
+ * The usage block on an Anthropic-wire SSE event. Every field is optional
+ * because which of them a host populates — and on which event — varies: see
+ * `takeUsage` in `_callAnthropicStream`.
+ */
+export interface StreamUsage {
+  input_tokens?:                 number
+  output_tokens?:                number
+  cache_read_input_tokens?:      number
+  cache_creation_input_tokens?:  number
+}
+
+/** Running token totals accumulated across a stream's usage events. */
+export interface StreamTokens {
+  inputTok:      number
+  outputTok:     number
+  cacheReadTok:  number
+  cacheWriteTok: number
+}
+
+/**
+ * Fold one SSE usage block into the running totals.
+ *
+ * Which event carries the real numbers is host-specific. Real Anthropic puts
+ * the input side on `message_start` and only `output_tokens` on `message_delta`.
+ * Z.ai (glm) sends `message_start` with every field zeroed and reports input,
+ * output and cache together on the final `message_delta`. Reading input from
+ * `message_start` alone recorded 0 input and 0 cache for every GLM call ever
+ * made — 441,896 output tokens against 0 input across one 7-hour COO run.
+ *
+ * So: fold from wherever it arrives, and let a later non-zero reading win. A
+ * zero never overwrites a figure already in hand, and a real figure always
+ * replaces a placeholder — which makes the fold correct under either ordering.
+ */
+export function foldStreamUsage( acc: StreamTokens, u: StreamUsage ): StreamTokens {
+  if( u.input_tokens )                 acc.inputTok      = u.input_tokens
+  if( u.output_tokens )                acc.outputTok     = u.output_tokens
+  if( u.cache_read_input_tokens )      acc.cacheReadTok  = u.cache_read_input_tokens
+  if( u.cache_creation_input_tokens )  acc.cacheWriteTok = u.cache_creation_input_tokens
+  return acc
+}
+
 /**
  * Cost-attribution metadata for a single LLM call. The same director instance is
  * shared by the master executive, every facet (conversation/planning/outreach),
@@ -275,6 +318,8 @@ export interface LLMCallMeta {
   /** The actor/subsystem doing the work. */
   attribute: LLMCallAttribute
   /** The specific cognitive function. */
+  process: LLMCallProcess
+  /** The specific cognitive function. */
   function: LLMCallFunction
   /** Optional specific id or namespace: facet id, entity id, model name. */
   scope?: string
@@ -284,13 +329,23 @@ export interface LLMCallMeta {
    * How much this call demands, 0..1 — MODEL_ROUTING W0.
    *
    * A *cognitive* measure, never a commercial one: it says how consequential or
-   * uncertain this moment is, never who is paying for it. Two faculties already
-   * compute it and simply forward what they have — the master and its facets
-   * pass `effortScore` (the a-priori effort gate: uncertainty, prior
-   * confidence, novelty, a pending reply, stress load), and deliberation passes
-   * the agency stakes of the choice under consideration. Structurally
-   * background work (summarising, guarding, embedding, delivery) reports a low
-   * constant, because it is background whether the mind is calm or in crisis.
+   * uncertain this moment is, never who is paying for it.
+   *
+   * What actually reports it today:
+   *   · the master and every facet — including the deliberation facet — forward
+   *     `effortScore`, the a-priori effort gate (uncertainty, prior confidence,
+   *     novelty, a pending reply, stress load);
+   *   · structurally background work (summarising, the identity guard) reports a
+   *     low constant, because it is background whether the mind is calm or in
+   *     crisis.
+   *
+   * Note what is NOT here: agency's `stakes( winner, bias )` — the consequence
+   * of the specific choice under contest — is computed in
+   * `agency/selection.scoring.ts` and never reaches a call. So a deliberation
+   * facet currently reports the tick's general effort, not the stakes of the
+   * choice it is deliberating. Carrying it is MODEL_ROUTING W1, still open.
+   * This comment previously claimed deliberation passed those stakes; it does
+   * not, and a doc comment that ships to npm is a bad place to be aspirational.
    *
    * Absent means UNKNOWN, not zero: a consumer must fall back to its default
    * rather than treat a missing value as "cheapest possible".
@@ -312,7 +367,7 @@ export const BACKGROUND_DEMAND = 0.1
 export const ESCALATION_DEMAND = 0.7
 
 /** Default attribution when a caller does not tag itself (back-compat). */
-const DEFAULT_CALL_META: LLMCallMeta = { category: 'executive', attribute: 'master', function: 'decision' }
+const DEFAULT_CALL_META: LLMCallMeta = { category: 'executive', attribute: 'master', process: 'decision', function: '-' }
 
 /**
  * Fill in wire and base URL, or say clearly what is missing.
@@ -606,6 +661,9 @@ export class LLMDirector {
       // reached from several vendors at very different prices.
       model:            ep.model,
       provider:         ep.provider,
+      // The router's own input, kept alongside its output. Without this the
+      // ledger records WHERE a call went and never WHY.
+      demand:           meta.demand,
       promptTokens:     result.inputTok,
       completionTokens: result.outputTok,
       totalTokens:      result.inputTok + result.outputTok,
@@ -613,6 +671,7 @@ export class LLMDirector {
       cacheWriteTokens: result.cacheWriteTok,
       category:         meta.category,
       attribute:        meta.attribute,
+      process:          meta.process,
       function:         meta.function,
       scope:            meta.scope,
       label:            meta.label,
@@ -686,11 +745,24 @@ export class LLMDirector {
     onChunk:      ( chunk: string ) => void,
     temperature?: number,
   ): Promise<LLMCallResult> {
-    // First-byte deadline only: a hard timeout on the whole stream would
-    // truncate a healthy but long generation, so the timer is cleared once
-    // the response headers arrive.
+    // IDLE deadline, not a whole-response one. A hard cap on the total stream
+    // would truncate a healthy long generation; no cap at all lets a stalled
+    // socket hang forever. A live generation keeps emitting and a dead one goes
+    // quiet, so the clock is restarted by every chunk that arrives and fires
+    // only after `_timeoutMs` of silence — the first byte included.
+    //
+    // It used to be cleared the moment the response headers arrived, which left
+    // the read loop with no deadline at all. A mid-stream stall then never
+    // settled, and the reasoning promise it belonged to stayed in the executive's
+    // `_pending` map forever: `hasPendingWork` gated every cycle and the master
+    // seat went silent for the full 600-tick prune horizon. Observed live as ten
+    // minutes of a mind not deliberating, announced by nothing.
     const controller = new AbortController()
-    const timer = setTimeout( () => controller.abort(), this._timeoutMs )
+    let   timer = setTimeout( () => controller.abort(), this._timeoutMs )
+    const restartDeadline = (): void => {
+      clearTimeout( timer )
+      timer = setTimeout( () => controller.abort(), this._timeoutMs )
+    }
 
     let res: Response
     try {
@@ -715,24 +787,23 @@ export class LLMDirector {
       throw err
     }
 
-    clearTimeout( timer )
-
-    if( !res.ok )
+    if( !res.ok ){
+      clearTimeout( timer )
       throw new Error(`Anthropic stream ${res.status}: ${( await res.text() ).slice(0, 300)}`)
+    }
 
     const reader  = res.body!.getReader()
     const decoder = new TextDecoder()
     let   buffer  = ''
-    let   fullText    = ''
-    let   inputTok    = 0
-    let   outputTok   = 0
-    let   cacheReadTok  = 0
-    let   cacheWriteTok = 0
+    let   fullText  = ''
+    const tokens: StreamTokens = {
+      inputTok: 0, outputTok: 0, cacheReadTok: 0, cacheWriteTok: 0 }
 
     try {
       while( true ){
         const { done, value } = await reader.read()
         if( done ) break
+        restartDeadline()
         buffer += decoder.decode( value, { stream: true })
 
         const lines = buffer.split('\n')
@@ -747,32 +818,52 @@ export class LLMDirector {
             const ev = JSON.parse( raw ) as {
               type: string
               delta?: { type: string; text?: string; stop_reason?: string }
-              message?: { usage?: { input_tokens: number; cache_read_input_tokens?: number; cache_creation_input_tokens?: number } }
-              usage?:   { output_tokens: number }
+              message?: { usage?: StreamUsage }
+              usage?:   StreamUsage
             }
 
-            if( ev.type === 'message_start' && ev.message?.usage ){
-              inputTok      = ev.message.usage.input_tokens
-              cacheReadTok  = ev.message.usage.cache_read_input_tokens     ?? 0
-              cacheWriteTok = ev.message.usage.cache_creation_input_tokens ?? 0
-            }
+            // Usage arrives in different events depending on the host. Real
+            // Anthropic reports the input side up front on `message_start` and
+            // only `output_tokens` on `message_delta`. Anthropic-WIRE hosts do
+            // not all follow that: Z.ai (glm) sends `message_start` with zeroed
+            // placeholders and puts the true figures — input, output AND cache —
+            // on the final `message_delta`. Reading the input side from
+            // `message_start` alone therefore recorded 0 input and 0 cache for
+            // every GLM call ever made, while output logged correctly: 441,896
+            // output tokens against 0 input across one 7-hour COO run, which is
+            // not a possible shape for a conversation.
+            //
+            // So take usage wherever it appears and let a later non-zero reading
+            // win — a zero never overwrites a figure already in hand, and a real
+            // figure always replaces a placeholder.
+            if( ev.type === 'message_start' && ev.message?.usage )
+              foldStreamUsage( tokens, ev.message.usage )
             else if( ev.type === 'content_block_delta' && ev.delta?.text ){
               fullText += ev.delta.text
               onChunk( ev.delta.text )
             }
-            else if( ev.type === 'message_delta' && ev.usage?.output_tokens ){
-              outputTok = ev.usage.output_tokens
-            }
+            else if( ev.type === 'message_delta' && ev.usage )
+              foldStreamUsage( tokens, ev.usage )
           }
           catch { /* ignore malformed events */ }
         }
       }
     }
+    catch( err ){
+      // An abort here is the idle deadline, not a caller cancelling: nothing
+      // arrived for `_timeoutMs` while the stream was still open. Naming it is
+      // the whole point — a stall that throws is a pass that failed, and a pass
+      // that failed settles its promise and frees the seat.
+      if( controller.signal.aborted )
+        throw new Error(`LLM stream to ${ep.provider} stalled — no data for ${this._timeoutMs}ms`)
+      throw err
+    }
     finally {
+      clearTimeout( timer )
       reader.releaseLock()
     }
 
-    return { text: fullText, inputTok, outputTok, cacheReadTok, cacheWriteTok }
+    return { text: fullText, ...tokens }
   }
 
   /**
@@ -814,7 +905,10 @@ export class LLMDirector {
       () => ep.wire === 'anthropic'
         ? this._callAnthropicStream( ep, systemPrompt, userMessage, () => {}, temperature )
         : this._callProvider( ep, systemPrompt, userMessage, temperature ),
-      'executive/direct',
+      `executive/direct:${ meta.function }`,
+      // A reply to a waiting person takes the reserved lane; everything the
+      // mind is doing for itself shares the general one. See `gateFor`.
+      gateFor( meta.function ),
     )
 
     // Record token usage + cost into this Will's injected tracker (R4), tagged

package/src/llm/routing.ts

@@ -99,6 +99,8 @@ export interface RoutingRule {
   category?: LLMCallMeta['category']
   /** Match `LLMCallMeta.attribute` exactly (e.g. 'master', 'facet', 'guard'). */
   attribute?: LLMCallMeta['attribute']
+  /** Match `LLMCallMeta.process` exactly (e.g. 'decision', 'ideation'). */
+  process?: LLMCallMeta['process']
   /** Match `LLMCallMeta.function` exactly (e.g. 'decision', 'consolidation'). */
   function?: LLMCallMeta['function']
   /**
@@ -182,6 +184,10 @@ export function chainRouters( ...routers: ( ModelRouter | null | undefined )[] )
 function matches( rule: RoutingRule, meta: LLMCallMeta ): boolean {
   if( rule.category  !== undefined && rule.category  !== meta.category  ) return false
   if( rule.attribute !== undefined && rule.attribute !== meta.attribute ) return false
+  // `process` split out of `function` (ideation vs decision). It was declarable on a
+  // rule from the moment the axis existed but never tested here, so a rule that named
+  // it matched every process — the opposite of the AND semantics every other axis has.
+  if( rule.process   !== undefined && rule.process   !== meta.process   ) return false
   if( rule.function  !== undefined && rule.function  !== meta.function  ) return false
 
   // Absent demand is UNKNOWN, not zero: a demand-bounded rule cannot claim a

package/src/llm/summarizer.ts

@@ -152,7 +152,7 @@ export class ExecutiveSummarizer {
         // MODEL_ROUTING W0 — compression is background work at a constant low
         // demand: distilling excerpts is the same job whether the mind is calm
         // or in crisis, so there is no honest per-tick measure to forward here.
-        { category: 'summarizer', attribute: 'memory', function: 'consolidation', demand: BACKGROUND_DEMAND }
+        { category: 'summarizer', attribute: 'memory', process: 'cog', function: 'consolidation', demand: BACKGROUND_DEMAND }
       )
 
       if( result.text ){

package/src/llm/wire.contracts.ts

@@ -34,11 +34,68 @@ export const REPLY_TEXT_TAG = 'REPLY_TEXT'
 export const REPLY_TEXT_OPEN  = `[${REPLY_TEXT_TAG}]`
 export const REPLY_TEXT_CLOSE = `[/${REPLY_TEXT_TAG}]`
 
+/**
+ * The block a facet uses to say it has decided NOT to speak, and why.
+ *
+ * "Omit [REPLY_TEXT] to stay silent" was stated in the prompt and nowhere else —
+ * a rule with no mechanism behind it. Live, an outreach facet read that it had
+ * three unanswered messages outstanding, correctly concluded there was nothing new
+ * to say, and — having no other block to put that sentence in — wrote it into
+ * REPLY_TEXT. "— nothing new to say to FKEM. Three messages unanswered is enough."
+ * was delivered to FKEM, in the third person, about him.
+ *
+ * The prompt already warned against exactly that. Warning was not enough, because
+ * the pressure is structural: a mind that decides not to speak still has something
+ * to say about the decision, and REPLY_TEXT was the only place to say it. This is
+ * the place. Content here is recorded and never sent.
+ */
+export const NO_MESSAGE_TAG   = 'NO_MESSAGE'
+export const NO_MESSAGE_OPEN  = `[${NO_MESSAGE_TAG}]`
+export const NO_MESSAGE_CLOSE = `[/${NO_MESSAGE_TAG}]`
+
 /** Wrap a reply body in the block markers (the mock's emission shape). */
 export function wrapReplyText( body: string ): string {
   return [ REPLY_TEXT_OPEN, body, REPLY_TEXT_CLOSE ].join('\n')
 }
 
+/**
+ * Every marker that is PROTOCOL rather than content.
+ *
+ * Named explicitly rather than matched as `[ANYTHING]`, because bracketed text is
+ * ordinary in real messages — "[1]", "[see §4.4]", "[REDACTED]" are things a mind
+ * may legitimately say, and a greedy strip would eat them.
+ */
+export const PROTOCOL_TAGS: readonly string[] = [
+  REPLY_TEXT_TAG, NO_MESSAGE_TAG, 'INTROSPECTION', 'NARRATIVE', 'SELF_OBS',
+]
+
+/**
+ * Remove any protocol marker that survived inside extracted content.
+ *
+ * `extractTextBlock` slices from the first `[TAG]` to the first `[/TAG]` after
+ * it, so a STRAY second opener inside the body is carried out as content — and
+ * the bubble splitter, seeing a line of its own, delivers it as a message.
+ *
+ * Live: a COO's reply to a technical document went out as four substantive
+ * bubbles followed by a fifth reading exactly `[REPLY_TEXT]`. The person got a
+ * message whose entire content was the name of the slot it should have filled.
+ *
+ * These tokens can never be legitimate content — they are the wire, not the
+ * words — so stripping them is not censorship of anything the mind meant. A line
+ * left empty by the removal is dropped so it cannot become an empty bubble.
+ */
+export function stripProtocolMarkers( text: string ): string {
+  let out = text
+  for( const tag of PROTOCOL_TAGS )
+    out = out.split(`[${ tag }]`).join('').split(`[/${ tag }]`).join('')
+
+  return out
+    .split('\n')
+    .filter( ( line, i, all ) => line.trim() !== '' || ( i > 0 && i < all.length - 1 && all[ i - 1 ]?.trim() !== '') )
+    .join('\n')
+    .trim()
+}
+
 // ── Conversation-facet focus — render ↔ match pair ────────────
 // The AuditionEngine RENDERS these lines into the facet focus; the mock LLM
 // MATCHES them to detect "this call is a conversation turn" and synthesize a

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.
@@ -280,7 +282,7 @@ export class PMADistiller {
    * @param willId     The Will's ID
    * @param willName   The Will's display name
    * @param state      Current simulation state (from stateManager.snapshot())
-   * @param sessionId  Active session ID — recorded as provenance
+   * @param sessionId  Active session ID — recorded on the snapshot as its origin
    * @param dataDir    Root data dir (defaults to WILL_DATA_DIR env or './data')
    * @param repertoire The agency competence layer (in-memory manager). When
    *                   provided, the Will's learned skills + composite schemas are
@@ -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/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' ] )