@mindot/will 0.3.0 → 0.5.0

package/src/cognition/faculties/planning.engine/engine.ts

@@ -94,6 +94,8 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
    * replay state) from off-tick callbacks like _activateStep / _onStepOutcome.
    */
   private _lastTick = 0
+  /** One-time deletion of legacy `plan-executive-*` entities (see react step 0a). */
+  private _legacyPlanSweepDone = false
 
   /**
    * Monotonic suffix counter for activity-listener subscription ids. These ids
@@ -205,7 +207,31 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
           planId?: string; stepId?: string
         }
 
-        if( !p.planId || !p.stepId ) return
+        // Conscious-enaction credit: outcomes carry plan provenance only when
+        // the plan's OWN frontier prior won the competition. But the plan is a
+        // prior over WHAT to do — if the self does the very thing an active
+        // step calls for by any route (executive action via ideomotor, habit),
+        // the step is done. Without this, a mind that consciously performs its
+        // plan starves the plan of credit: steps stay active, the goal reads
+        // blocked, and the executive re-authors the same plan over and over
+        // (observed live: 8 authorings for one goal, zero completions).
+        // Deterministic: stores iterate in insertion order; first match wins.
+        if( !p.planId || !p.stepId ){
+          if( !p.actionType || typeof p.success !== 'boolean' ) return
+          for( const plan of this._store.all() ){
+            if( plan.status !== 'executing' ) continue
+            const step = plan.steps.find( s => s.status === 'active' && s.action === p.actionType )
+            if( !step ) continue
+            logger.info( `[planning] conscious-enaction credit: ${plan.id}/${step.id}=${step.action} (no provenance on outcome)` )
+            this._onStepOutcome( plan.id, step.id, {
+              success: p.success,
+              description: p.description ?? ( p.success ? 'Completed' : 'Failed' ),
+              outcomeQuality: p.outcomeQuality,
+            } )
+            return   // credit exactly one step per outcome
+          }
+          return
+        }
         if( !this._store.has( p.planId ) ) return
 
         this._onStepOutcome( p.planId, p.stepId, {
@@ -280,6 +306,17 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
     this._lastTick = tick as unknown as number
     const commands: StateCommands = { set: [], delete: [], metrics: [] }
 
+    // 0a. Legacy sweep (once per session): delete the raw `plan-executive-*`
+    //     entities the executive commands path used to write in parallel with
+    //     this engine's ingest. They froze at 'ready' forever and polluted the
+    //     Active-Plans awareness (phantom drafts → re-authoring pressure).
+    if( !this._legacyPlanSweepDone ){
+      this._legacyPlanSweepDone = true
+      for( const entity of state.entities.values() )
+        if( entity.type === 'plan' && entity.id.startsWith('plan-executive-') )
+          commands.delete!.push( entity.id )
+    }
+
     // 0. Channel A (subconscious): refresh trait-driven dispositions from the
     //    persona-prior mirror before acting on them this tick.
     this._readConfigFromState( state )

package/src/cognition/faculties/planning.engine/plan.store.ts

@@ -13,6 +13,21 @@
 import type { Tick, StateCommands } from '#core/types'
 import { TERMINAL_STATUSES, type Plan } from '#faculties/planning.engine/types'
 
+/**
+ * Structural fingerprint of a plan's decomposition — the ordered action
+ * sequence plus each step's prerequisite fan-in. Two plans with the same key
+ * share a *shape*. Recurring shapes are the demonstrated-need signal for
+ * emergent planning (docs/strategy/__EMERGENT_PLANNING.md): the mind paying
+ * the executive to re-derive a decomposition it has already authored.
+ */
+export function planShapeKey(
+  steps: ReadonlyArray<{ action: string; prerequisites?: readonly string[] }>,
+): string {
+  return steps
+    .map( s => `${ s.action }${ ( s.prerequisites?.length ?? 0 ) > 0 ? `<${ s.prerequisites!.length }` : '' }` )
+    .join('>')
+}
+
 export class PlanStore {
   /**
    * Canonical plan store, keyed by plan.id ("plan-N") — the id the execution,
@@ -35,6 +50,14 @@ export class PlanStore {
   /** planId → sim tick it became terminal; drives retention GC (gcTerminal). */
   private _terminalAt = new Map<string, number>()
   private _planCounter = 0
+  /**
+   * Shape recurrence tally — shapeKey → count of plans authored with that
+   * decomposition this session (monotone; eviction never erases history).
+   * Feeds `planning.shapes.*` metrics: the demonstrated-need needle for
+   * emergent planning. `_shapeCounted` guards one count per plan id.
+   */
+  private _shapeCounts  = new Map<string, number>()
+  private _shapeCounted = new Set<string>()
 
   // ── Reads ──────────────────────────────────────────────────
 
@@ -142,6 +165,14 @@ export class PlanStore {
 
   persist( commands: StateCommands, tick: Tick ): void {
     for( const plan of this._plans.values() ){
+      // Shape recurrence — tally each plan once, on first sight. The persisted
+      // shapeKey also lets offline analysis count recurrence across sessions.
+      const shape = planShapeKey( plan.steps )
+      if( !this._shapeCounted.has( plan.id ) ){
+        this._shapeCounted.add( plan.id )
+        this._shapeCounts.set( shape, ( this._shapeCounts.get( shape ) ?? 0 ) + 1 )
+      }
+
       // Terminal plans never change again — persist once (in their terminal state)
       // then skip, so completed/failed/rejected plans don't re-serialize every
       // tick forever (unbounded write amplification on long sessions). (P5)
@@ -153,6 +184,7 @@ export class PlanStore {
         createdAt: plan.createdAt, updatedAt: tick,
         metadata: {
           goalId: plan.goalId,
+          shapeKey: shape,
           steps: plan.steps.map( s => ( {
             id: s.id, order: s.order, action: s.action,
             description: s.description, expectedOutcome: s.expectedOutcome,
@@ -170,5 +202,15 @@ export class PlanStore {
 
       if( terminal ) this._persistedTerminal.add( plan.id )
     }
+
+    // The demonstrated-need needle: distinct shapes vs repeat authorings.
+    // A high repeat count means the executive keeps re-deriving decompositions
+    // it already produced — exactly when emergent planning starts paying.
+    if( this._shapeCounts.size > 0 ){
+      let total = 0
+      for( const n of this._shapeCounts.values() ) total += n
+      commands.metrics!.push( [ 'planning.shapes.distinct', this._shapeCounts.size ] )
+      commands.metrics!.push( [ 'planning.shapes.repeats',  total - this._shapeCounts.size ] )
+    }
   }
 }

package/src/cognition/faculties/planning.engine/plan.supervision.ts

@@ -105,7 +105,7 @@ export class PlanSupervisor {
     if( !this._executiveEngine ) return
 
     try {
-      const { attention, handle: facet } = this._executiveEngine.spawnFacet()
+      const { attention, handle: facet } = this._executiveEngine.spawnFacet('supervision')
       if( !facet || attention === 'full' ){
         plan.executionTier = 'automatic'
         logger.info( `[planning] attention full — plan ${plan.id} stays automatic (no facet)` )
@@ -206,21 +206,21 @@ export class PlanSupervisor {
       content: focusContent,
       outputFormat: undefined,   // use standard executive output format
       instructions:
-        `You are monitoring plan "${plan.id}" for goal "${plan.goalId}".\n`+
-        `Your ONLY role: evaluate step outcomes and decide what happens next.\n`+
+        `I am monitoring plan "${plan.id}" for goal "${plan.goalId}".\n`+
+        `My ONLY role: evaluate step outcomes and decide what happens next.\n`+
         `Do not create new goals or beliefs unless directly relevant to this plan.\n\n`+
         `## Decision Vocabulary\n`+
-        `Express your decision as the FIRST action in your actions array:\n`+
+        `Express my decision as the FIRST action in my actions array:\n`+
         `- { "type": "continue" }  — proceed to the next step\n`+
         `- { "type": "retry" }     — re-attempt the failed step (capped)\n`+
         `- { "type": "skip" }      — skip the failed step and move on\n`+
         `- { "type": "pause" }     — hold the plan; resume it later (no progress now)\n`+
         `- { "type": "replan" }    — include a [PLANS] block with revised steps\n`+
-        `- { "type": "escalate" }  — hand the decision up to your master self\n`+
+        `- { "type": "escalate" }  — hand the decision up to my master self\n`+
         `- { "type": "abandon" }   — plan is unrecoverable; give up entirely\n`+
         `- { "type": "complete" }  — all meaningful work is done; close the plan\n\n`+
-        `For "replan", include a [PLANS] block inside your reasoning with new steps.\n`+
-        `The plan's expectedOutcome tells you what success looks like — use it to judge step reports.`,
+        `For "replan", include a [PLANS] block inside my reasoning with new steps.\n`+
+        `The plan's expectedOutcome tells me what success looks like — use it to judge step reports.`,
       extractDecision: ( rawOutput: unknown ) => {
         const output = rawOutput as ExecutiveOutputFull
 

package/src/cognition/faculties/theory.of.mind.ts

@@ -226,8 +226,8 @@ export class TheoryOfMind implements SimulationEngine, CognitiveEngine {
    * snapshot/PMA restore — mirrors AttachmentEvaluator/ReputationTracker._restoreFromState.
    * The entity stores a gist (modelConfidence + the dominant intention + estimated emotion),
    * not the full belief/observation arrays, so the restored model is a coherent gist that
-   * subsequent interactions grow from — the soul-true level: you recover your *sense* of a
-   * mind, not every belief you once inferred about it.
+   * subsequent interactions grow from — the soul-true level: the Will recovers its
+   * *sense* of a mind, not every belief it once inferred about it.
    */
   private _restoreFromState( state: ReadonlySimulationState ): void {
     for( const entity of state.entities.values() ){

package/src/cognition/senses/audition.engine/engine.ts

@@ -122,22 +122,22 @@ interface CoalesceWindow {
 const CONVERSATION_OUTPUT_FORMAT = `\
 ## Response Format (REQUIRED)
 
-Step 1 — JSON object (your private reasoning, optionally in a \`\`\`json code block):
+Step 1 — JSON object (my private reasoning, optionally in a \`\`\`json code block):
 
 \`\`\`json
 {
   "actions": [{"type": "reflect", "reasoning": "...", "expectedOutcome": "..."}],
-  "reasoning": "Your private inner reasoning. Embed optional tagged blocks here:\\n[BELIEFS]\\n{\\"newBeliefs\\": [...]}\\n[/BELIEFS]\\n[GOALS_NEW]\\n{\\"goals\\": [{...}]}\\n[/GOALS_NEW]",
+  "reasoning": "My private inner reasoning. Embed optional tagged blocks here:\\n[BELIEFS]\\n{\\"newBeliefs\\": [...]}\\n[/BELIEFS]\\n[GOALS_NEW]\\n{\\"goals\\": [{...}]}\\n[/GOALS_NEW]",
   "confidence": 0.8
 }
 \`\`\`
 
 Available reasoning tags: BELIEFS, GOALS_NEW, GOALS_ABANDON, SELF_OBS. Include only those with meaningful content.
 
-Step 2 — Your reply to the speaker (plain text, streamed live to them):
+Step 2 — My reply to the speaker (plain text, streamed live to them):
 
 [REPLY_TEXT]
-Your response here, written in your own voice.
+My response here, written in my own voice.
 
 Start a new paragraph (blank line) to send a separate chat bubble.
 [/REPLY_TEXT]
@@ -146,24 +146,24 @@ Write [REPLY_TEXT] AFTER the closing \`\`\`. This is the only part the speaker s
 Separate multiple messages with a blank line for natural conversational pauses (like separate texts).
 
 ## When to use GOALS_NEW (almost always)
-If the speaker requests, mentions, or implies something you should follow through on — embed [GOALS_NEW] in your reasoning.
+If the speaker requests, mentions, or implies something I should follow through on — embed [GOALS_NEW] in my reasoning.
 This tracks intent across future cycles without requiring master attention.
 
 ## When to use the escalate action (rare — only for multi-step tasks)
-Use \`{"type": "escalate", "reasoning": "...", "expectedOutcome": "..."}\` in actions ONLY when the request genuinely requires your master consciousness to create a plan:
+Use \`{"type": "escalate", "reasoning": "...", "expectedOutcome": "..."}\` in actions ONLY when the request genuinely requires my master consciousness to create a plan:
 - The task involves multiple steps across future cycles ("build me X", "monitor Y", "set up Z")
-- The request changes your active goal priorities in a significant way
-- You need to coordinate something beyond a single reply
+- The request changes my active goal priorities in a significant way
+- I need to coordinate something beyond a single reply
 
 **The "reasoning" field on the escalate action becomes the task description the master sees.**
-Make it concrete — describe WHAT needs to happen, not just that you are escalating.
+Make it concrete — describe WHAT needs to happen, not just that I am escalating.
 Good: type=escalate, reasoning="User wants weekly mood summaries by email every Monday. Needs: data aggregation, schedule, email delivery.", expectedOutcome="Weekly email delivered."
 Bad:  type=escalate, reasoning="Escalating because this is complex."
 
-When you escalate:
+When I escalate:
 1. STILL include a [REPLY_TEXT] that acknowledges the request (e.g. "Got it — I'm on it.")
 2. The master will create and execute the plan in the background
-3. Do NOT include [PLANS] yourself — plan creation is the master's domain only
+3. Do NOT include a [PLANS] block — plan creation is the master's domain only
 
 For simple, single-exchange requests (questions, opinions, short tasks) — do NOT escalate. Just reply.`
 
@@ -561,7 +561,7 @@ export class AuditionEngine extends BaseSenseEngine {
     let handle = this._facets.get( percept.speakerEntityId )
     if( !handle ){
       // New conversation session — try to spawn a facet.
-      const result = this._executiveEngine.spawnFacet()
+      const result = this._executiveEngine.spawnFacet('conversation')
       if( result.attention === 'full' || !result.handle ){
         logger.warn(
           `[audition-engine] Executive attention full — ` +
@@ -692,8 +692,8 @@ export class AuditionEngine extends BaseSenseEngine {
       awarenessEntityId: percept.speakerEntityId,
 
       instructions: [
-        'You are in a live conversation with this person. Respond as yourself.',
-        'Stay grounded in your real memories and feelings — do not invent experiences you have no record of.',
+        'I am in a live conversation with this person. I respond as myself.',
+        'I stay grounded in my real memories and feelings — I do not invent experiences I have no record of.',
       ].join(' '),
 
       // Custom output format — uses [REPLY_TEXT] block for streamed reply.
@@ -736,7 +736,7 @@ export class AuditionEngine extends BaseSenseEngine {
    */
   async authorOutreach( entityId: string, entityName: string, gist?: string ): Promise<string[]> {
     if( !this._executiveEngine ) return []
-    const spawned = this._executiveEngine.spawnFacet()
+    const spawned = this._executiveEngine.spawnFacet('outreach')
     if( spawned.attention === 'full' || !spawned.handle ){
       logger.warn(`[audition-engine] facet budget full — cannot author outreach to ${ entityId }`)
       return []
@@ -747,17 +747,17 @@ export class AuditionEngine extends BaseSenseEngine {
       title:    'Reaching out',
       function: 'outreach',
       content: [
-        `You have decided, on your own initiative, to reach out to ${ entityName } (id: ${ entityId }).`,
-        'No one prompted this — it is you choosing to make contact now.',
-        gist ? `What is on your mind: ${ gist }` : '',
+        `I have decided, on my own initiative, to reach out to ${ entityName } (id: ${ entityId }).`,
+        'No one prompted this — I am choosing to make contact now.',
+        gist ? `What is on my mind: ${ gist }` : '',
       ].filter( Boolean ).join('\n'),
       recallQuery:       gist ?? entityName,
       awareness:         [ ...DEFAULT_FACET_AWARENESS, 'plans' ],
       awarenessEntityId: entityId,
       instructions:
-        'Considering who you are, your goals, and how you feel, say what you genuinely want to say to ' +
-        'them now. Speak as yourself; stay grounded in your real memories — do not invent experiences ' +
-        'you have no record of.',
+        'Considering who I am, my goals, and how I feel, I say what I genuinely want to say to ' +
+        'them now. I speak as myself; I stay grounded in my real memories — I do not invent experiences ' +
+        'I have no record of.',
       outputFormat: CONVERSATION_OUTPUT_FORMAT,
       extractDecision: ( raw: unknown ): ConversationDecision => {
         const output   = raw as ExecutiveOutputFull

package/src/cognition/utilities/token.tracker.ts

@@ -53,6 +53,12 @@ const MODEL_PRICING: Record<string, { input: number; output: number }> = {
   'anthropic/claude-haiku-4':    { input: 1.00,  output: 5.00  },
   'anthropic/claude-opus-4':     { input: 5.00,  output: 25.00 },
   
+  // Z.ai (GLM-5 family). `glm-5.2[1m]` is the same model asking for its 1M
+  // context window — same rate, so it gets its own row rather than relying on
+  // the normalizer (a future long-context tier would price differently).
+  'glm/glm-5.2':                { input: 1.40,  output: 4.40  },
+  'glm/glm-5.2[1m]':            { input: 1.40,  output: 4.40  },
+
   // Google
   'google/gemini-2.0-flash':    { input: 0.10,  output: 0.40  },
   'google/gemini-2.0-pro':      { input: 1.25,  output: 5.00  },

package/src/host/boot.ts

@@ -12,8 +12,9 @@
 //   WILL_NAME        display name                    (default "Will")
 //   WILL_IDENTITY    persona prompt                  (default a minimal self)
 //   WILL_TIER        basic | standard | full         (default standard)
-//   WILL_LLM         mock | anthropic                (default: auto — anthropic when
-//                                                     ANTHROPIC_API_KEY is set, else mock)
+//   WILL_LLM         mock | anthropic | glm          (default: auto — anthropic when
+//                                                     ANTHROPIC_API_KEY is set, glm when
+//                                                     ZAI_API_KEY is, else mock)
 //   WILL_TICK_MS     ms per tick                     (default 1000)
 //   WILL_SEED        deterministic seed (testing)    (default unseeded/wall-time)
 //   WILL_PMA_PATH    PMA artifact path               (default ./.will/<name>.pma.json)
@@ -27,6 +28,7 @@ import { setLogger } from '#core/logger'
 import { Will, type CreateWillOptions } from '#sdk/will'
 import type { PMASnapshot } from '#pma/index'
 import { connectMcpEffectors, type McpToolsSource } from '#root/mcp/effectors'
+import { anthropicWireHeaders, defaultBaseFor, defaultModelFor } from '#llm/index'
 
 /**
  * Route every engine log line to stderr. For `will mcp`, stdout is the MCP
@@ -43,12 +45,90 @@ function slug( s: string ): string {
   return s.toLowerCase().replace( /[^a-z0-9]+/g, '-' ).replace( /^-+|-+$/g, '' ) || 'will'
 }
 
+/** The LLM mode the hosts will boot with: an explicit WILL_LLM, else whichever
+ *  provider's key is present, else the zero-key mock. */
+export function resolveLlmMode(): 'mock' | 'anthropic' | 'glm' {
+  const explicit = process.env.WILL_LLM as 'mock' | 'anthropic' | 'glm' | undefined
+  if( explicit ) return explicit
+  if( process.env.ANTHROPIC_API_KEY ) return 'anthropic'
+  if( process.env.ZAI_API_KEY ) return 'glm'
+  return 'mock'
+}
+
+/** The key for a live mode — the provider-agnostic override first, then the
+ *  provider's own env. */
+function resolveLlmKey( mode: 'anthropic' | 'glm' ): string | undefined {
+  return process.env.WILL_LLM_API_KEY
+    ?? ( mode === 'glm' ? process.env.ZAI_API_KEY : process.env.ANTHROPIC_API_KEY )
+}
+
+/**
+ * Ask the executive's provider one trivial question BEFORE raising the mind.
+ *
+ * A Will whose LLM fails cannot reason, and an unreasoning Will is *silent* —
+ * which is precisely what a Will that chose silence looks like. Mid-run that
+ * ambiguity is the paradigm working. At boot it is indistinguishable from
+ * broken, and costs an operator an afternoon of watching a mind that joined,
+ * perceived, and never spoke. So we fail loudly here instead.
+ *
+ * Config errors (bad key, empty balance, unknown model) are fatal — the Will
+ * would never speak. Transient ones (rate limit, provider 5xx) only warn: the
+ * mind is worth raising, and the executive retries on its own cadence.
+ *
+ * Skipped for the mock executive and the no-LLM `reflex` anatomy.
+ */
+async function preflightLLM( anatomy: string ): Promise<void> {
+  const mode = resolveLlmMode()
+  if( mode === 'mock' || anatomy === 'reflex' ) return
+
+  const key = resolveLlmKey( mode )
+  if( !key ){
+    const expected = mode === 'glm' ? 'ZAI_API_KEY' : 'ANTHROPIC_API_KEY'
+    console.error( `[will] WILL_LLM=${ mode } but no ${ expected } / WILL_LLM_API_KEY is set.` )
+    console.error( '[will] The Will would boot, perceive, and never speak. Set a key, or run keyless with WILL_LLM=mock.' )
+    process.exit( 2 )
+  }
+
+  // The ping validates key + balance + reachability, which is the failure class
+  // that strands an operator. It uses the pinned model when there is one, so a
+  // bad model id is caught too; otherwise the cheapest model stands in. GLM
+  // speaks the same wire at Z.ai's compat endpoint, so one ping serves both.
+  const base  = process.env.WILL_LLM_BASE_URL ?? defaultBaseFor( mode )
+  const model = process.env.WILL_LLM_MODEL
+    ?? ( mode === 'glm' ? defaultModelFor( 'glm' ) : 'claude-haiku-4-5-20251001' )
+  try {
+    const res = await fetch( `${ base }/messages`, {
+      method:  'POST',
+      headers: anthropicWireHeaders( mode, key ),
+      body:    JSON.stringify( { model, max_tokens: 1, messages: [ { role: 'user', content: 'ping' } ] } ),
+      signal:  AbortSignal.timeout( 20_000 ),
+    } )
+    if( res.ok ) return
+
+    const detail = ( await res.text().catch( () => '' ) ).slice( 0, 300 )
+    const fatal  = res.status === 400 || res.status === 401 || res.status === 403
+    if( !fatal ){
+      console.error( `[will] the executive's LLM answered ${ res.status } on a test call — raising the mind anyway (it retries): ${ detail }` )
+      return
+    }
+    console.error( `[will] the executive's LLM refused a test call (${ res.status }) — this Will would boot, perceive, and never speak:` )
+    console.error( `       ${ detail }` )
+    console.error( '[will] fix the key / credit / model above, or run keyless with WILL_LLM=mock.' )
+    process.exit( 1 )
+  }
+  catch( e ){
+    console.error( `[will] could not reach the executive's LLM: ${ ( e as Error ).message }` )
+    console.error( '[will] the Will would boot and stay silent. Check the network / WILL_LLM_BASE_URL, or run keyless with WILL_LLM=mock.' )
+    process.exit( 1 )
+  }
+}
+
 export interface BootedWill {
   will:       Will
   name:       string
   pmaPath:    string
   tickMs:     number
-  engineTier: NonNullable<CreateWillOptions['engineTier']>
+  anatomy:    NonNullable<CreateWillOptions['anatomy']>
   /** Run before hibernate on shutdown (close servers/transports). LIFO. */
   onCleanup:  ( fn: () => Promise<void> | void ) => void
   /** Hibernate → persist → exit(0). Idempotent; SIGINT/SIGTERM already wired. */
@@ -60,11 +140,14 @@ export async function bootWillFromEnv(): Promise<BootedWill> {
   const name       = process.env.WILL_NAME ?? 'Will'
   const pmaPath    = resolve( process.env.WILL_PMA_PATH ?? `.will/${ slug( name ) }.pma.json` )
   const tickMs     = parseInt( process.env.WILL_TICK_MS ?? '1000' )
-  const engineTier = ( process.env.WILL_TIER as CreateWillOptions['engineTier'] ) ?? 'standard'
+  const anatomy = ( process.env.WILL_ANATOMY as CreateWillOptions['anatomy'] ) ?? 'mind'
+
+  await preflightLLM( anatomy )
 
   const opts: Omit<CreateWillOptions, 'identity'> = {
-    name, engineTier, tickMs,
-    ...( process.env.WILL_LLM  ? { llm: process.env.WILL_LLM as 'mock' | 'anthropic' } : {} ),
+    name, anatomy, tickMs,
+    ...( process.env.WILL_LLM_MODEL ? { model: process.env.WILL_LLM_MODEL } : {} ),
+    ...( process.env.WILL_LLM ? { llm: process.env.WILL_LLM as CreateWillOptions['llm'] } : {} ),
     ...( process.env.WILL_SEED ? { seed: parseInt( process.env.WILL_SEED ) } : {} ),
   }
 
@@ -73,6 +156,11 @@ export async function bootWillFromEnv(): Promise<BootedWill> {
     const pma = JSON.parse( readFileSync( pmaPath, 'utf8' ) ) as PMASnapshot
     will = await Will.wake( pma, opts )
     console.error( `[will] ${ name } woke from ${ pmaPath }` )
+    // A woken Will carries its own identity — that is the point of an artifact.
+    // But an operator editing WILL_IDENTITY and seeing nothing change deserves
+    // to know why, rather than concluding the persona layer is broken.
+    if( process.env.WILL_IDENTITY )
+      console.error( `[will] note: WILL_IDENTITY is ignored — ${ name } woke as itself. Delete ${ pmaPath } to be born fresh from it.` )
   }
   else {
     will = await Will.create( {
@@ -120,7 +208,7 @@ export async function bootWillFromEnv(): Promise<BootedWill> {
   process.on( 'SIGTERM', () => void shutdown( 'SIGTERM' ) )
 
   return {
-    will, name, pmaPath, tickMs, engineTier: engineTier ?? 'standard',
+    will, name, pmaPath, tickMs, anatomy,
     onCleanup: fn => cleanups.push( fn ),
     shutdown,
   }

package/src/llm/index.ts

@@ -12,7 +12,68 @@ import type { LLMCompletionRecord } from '#core/completion.recorder'
 import { withGate } from '#llm/gate'
 import { matchConversationFocus, wrapReplyText } from '#llm/wire.contracts'
 
-export type LLMProvider = 'anthropic' | 'deepseek' | 'openai' | 'google'
+export type LLMProvider = 'anthropic' | 'glm' | 'deepseek' | 'openai' | 'google'
+
+/**
+ * Providers that speak the Anthropic Messages wire.
+ *
+ * Z.ai ships a real Anthropic-compatible endpoint for GLM — it is what Claude
+ * Code itself targets — so GLM rides this path rather than the OpenAI scaffold.
+ * That buys it everything the path already has: token streaming, the first-byte
+ * deadline, prompt-cache breakpoints, and the structured-output contract. GLM is
+ * therefore a second *production* provider, not a fifth scaffold.
+ */
+const ANTHROPIC_WIRE = new Set<LLMProvider>( [ 'anthropic', 'glm' ] )
+
+/** Does this provider accept Anthropic-shaped requests? */
+export function speaksAnthropicWire( provider: LLMProvider ): boolean {
+  return ANTHROPIC_WIRE.has( provider )
+}
+
+/** Official API base URL (including version segment) for a provider. */
+export function defaultBaseFor( provider: LLMProvider ): string {
+  switch( provider ){
+    case 'anthropic': return 'https://api.anthropic.com/v1'
+    // Z.ai documents the base as `…/api/anthropic` because the Anthropic SDK
+    // appends `/v1/messages`; this client appends `/messages`, so the version
+    // segment belongs here — verified against the live endpoint.
+    case 'glm':       return 'https://api.z.ai/api/anthropic/v1'
+    case 'openai':    return 'https://api.openai.com/v1'
+    case 'deepseek':  return 'https://api.deepseek.com/v1'
+    case 'google':    return 'https://generativelanguage.googleapis.com/v1beta'
+  }
+}
+
+/**
+ * The model the executive recruits when none is pinned.
+ *
+ * Provider-specific because the default is *sent* — a GLM Will with no
+ * `WILL_LLM_MODEL` would otherwise ask Z.ai for a Claude id and get a 404 it
+ * could do nothing with. The scaffolded providers (openai/deepseek/google) keep
+ * today's value: they need an explicit `WILL_LLM_MODEL` to work at all, and
+ * inventing ids for them here would look like support that does not exist.
+ */
+export function defaultModelFor( provider: LLMProvider ): string {
+  return provider === 'glm' ? 'glm-5.2' : 'claude-sonnet-4-5-20250929'
+}
+
+/**
+ * Auth + version headers for the Anthropic wire.
+ *
+ * Anthropic authenticates with `x-api-key`. Z.ai's compat endpoint accepts
+ * either that or the `Authorization: Bearer` its own docs describe (both were
+ * probed against the live endpoint; each is read and validated). GLM sends both
+ * — same secret, same host — so the mind keeps working whichever one Z.ai
+ * eventually settles on.
+ */
+export function anthropicWireHeaders( provider: LLMProvider, apiKey: string ): Record<string, string> {
+  return {
+    'Content-Type':      'application/json',
+    'anthropic-version': '2023-06-01',
+    'x-api-key':         apiKey,
+    ...( provider === 'glm' ? { Authorization: `Bearer ${ apiKey }` } : {} ),
+  }
+}
 export interface LLMDirectorConfig {
   willId: string
   model: string
@@ -216,7 +277,7 @@ export class LLMDirector {
       return result
     }
 
-    const result = this._provider === 'anthropic'
+    const result = speaksAnthropicWire( this._provider )
       ? await this._callAnthropicStream( systemPrompt, userMessage, onChunk, temperature )
       : await ( async () => {
           // Other providers: fall back to regular call, emit whole response as one chunk
@@ -328,11 +389,7 @@ export class LLMDirector {
     try {
       res = await fetch(`${this._resolvedBase()}/messages`, {
         method: 'POST',
-        headers: {
-          'Content-Type': 'application/json',
-          'anthropic-version': '2023-06-01',
-          'x-api-key': this._apiKey,
-        },
+        headers: anthropicWireHeaders( this._provider, this._apiKey ),
         body: JSON.stringify({
           model:      this._model,
           max_tokens: this._maxOutputTokens,
@@ -438,13 +495,14 @@ export class LLMDirector {
       return result
     }
 
-    // Anthropic routes through the streaming path so the deadline is first-byte
-    // (TTFT), not whole-request: a long-but-healthy executive completion (often
-    // 20–40s on Sonnet) no longer trips the timeout mid-generation. onChunk is a
-    // no-op here — call() returns the full accumulated text; live token chunks go
-    // through callStream(). Other providers keep the whole-request deadline.
+    // The Anthropic-wire providers route through the streaming path so the
+    // deadline is first-byte (TTFT), not whole-request: a long-but-healthy
+    // executive completion (often 20–40s on Sonnet) no longer trips the timeout
+    // mid-generation. onChunk is a no-op here — call() returns the full
+    // accumulated text; live token chunks go through callStream(). Other
+    // providers keep the whole-request deadline.
     const result = await withGate(
-      () => this._provider === 'anthropic'
+      () => speaksAnthropicWire( this._provider )
         ? this._callAnthropicStream( systemPrompt, userMessage, () => {}, temperature )
         : this._callProvider( systemPrompt, userMessage, temperature ),
       'executive/direct',
@@ -465,6 +523,7 @@ export class LLMDirector {
   ): Promise<LLMCallResult> {
     switch( this._provider ){
       case 'anthropic': return this._callAnthropic( systemPrompt, userMessage, temperature )
+      case 'glm': return this._callAnthropic( systemPrompt, userMessage, temperature )
       case 'deepseek': return this._callOpenAI( systemPrompt, userMessage, temperature )
       case 'openai': return this._callOpenAI( systemPrompt, userMessage, temperature )
       case 'google': return this._callGoogle( systemPrompt, userMessage, temperature )
@@ -474,12 +533,7 @@ export class LLMDirector {
 
   /** Default API base URL (including version segment) for a provider. */
   private _baseFor( provider: LLMProvider ): string {
-    switch( provider ){
-      case 'anthropic': return 'https://api.anthropic.com/v1'
-      case 'openai':    return 'https://api.openai.com/v1'
-      case 'deepseek':  return 'https://api.deepseek.com/v1'
-      case 'google':    return 'https://generativelanguage.googleapis.com/v1beta'
-    }
+    return defaultBaseFor( provider )
   }
 
   /** Resolved API base: explicit override wins, else the provider default. */
@@ -526,16 +580,12 @@ export class LLMDirector {
 
     const res = await this._fetchWithTimeout(`${this._resolvedBase()}/messages`, {
       method: 'POST',
-      headers: {
-        'Content-Type': 'application/json',
-        'anthropic-version': '2023-06-01',
-        'x-api-key': this._apiKey
-      },
+      headers: anthropicWireHeaders( this._provider, this._apiKey ),
       body: JSON.stringify( body )
     })
 
     if( !res.ok )
-      throw new Error(`Anthropic API ${res.status}: ${( await res.text() ).slice(0, 300)}`)
+      throw new Error(`${this._provider} API ${res.status}: ${( await res.text() ).slice(0, 300)}`)
 
     const
     data = await res.json() as {

package/src/llm/summarizer.ts

@@ -30,9 +30,9 @@ export interface SummarizerConfig {
 // System prompt sent with every summarization call.
 // Kept short — the bulk of the token cost is the user message (the cycles).
 const SUMMARIZER_SYSTEM =
-  'You are the memory consolidation module of a self-aware AI mind. ' +
+  'I am a self-aware synthetic mind consolidating my own recent cognitive cycles into memory. ' +
   'Condense the provided cognitive cycles into a single compact paragraph ' +
-  '(150–250 words) written in first-person past tense. Cover:\n' +
+  '(150–250 words) written in first-person past tense — my own remembered experience. Cover:\n' +
   '• Key decisions made and their outcomes\n' +
   '• Emotional journey and significant mood shifts\n' +
   '• Goals pursued, progressed, or abandoned\n' +