@mindot/will 0.2.0 → 0.4.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/host/boot.ts

@@ -0,0 +1,193 @@
+// ─────────────────────────────────────────────────────────────
+// src/host/boot.ts — shared boot/shutdown for the `will` CLI hosts
+// ─────────────────────────────────────────────────────────────
+//
+// Both hosts (`will mcp`, `will serve`) raise the same mind the same way:
+// env-configured, woken from its PMA artifact when one exists (else born),
+// optionally bridged onto external MCP servers whose tools become its own
+// abilities, and hibernated back to the artifact exactly once on the way out.
+// Only the protocol surface differs — that stays in each host.
+//
+// Env (shared):
+//   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_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)
+//   WILL_MCP_SERVERS JSON array of MCP servers whose tools become the Will's
+//                    OWN abilities: entries {command,args?,env?} or {url}.
+// ─────────────────────────────────────────────────────────────
+
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs'
+import { dirname, resolve } from 'node:path'
+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'
+
+/**
+ * Route every engine log line to stderr. For `will mcp`, stdout is the MCP
+ * protocol channel and must stay pure; `will serve` keeps the same discipline
+ * so both hosts log identically (and Docker captures one stream).
+ */
+export function routeLogsToStderr(): void {
+  const err = ( level: string ) => ( msg: string, ...rest: unknown[] ) =>
+    console.error( `[will:${ level }] ${ msg }`, ...rest )
+  setLogger( { debug: () => {}, info: err( 'info' ), warn: err( 'warn' ), error: err( 'error' ) } )
+}
+
+function slug( s: string ): string {
+  return s.toLowerCase().replace( /[^a-z0-9]+/g, '-' ).replace( /^-+|-+$/g, '' ) || 'will'
+}
+
+/**
+ * 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 = process.env.WILL_LLM ?? ( process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'mock' )
+  if( mode === 'mock' || anatomy === 'reflex' ) return
+
+  const key = process.env.WILL_LLM_API_KEY ?? process.env.ANTHROPIC_API_KEY
+  if( !key ){
+    console.error( '[will] WILL_LLM=anthropic but no ANTHROPIC_API_KEY / 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.
+  const base  = process.env.WILL_LLM_BASE_URL ?? 'https://api.anthropic.com/v1'
+  const model = process.env.WILL_LLM_MODEL ?? 'claude-haiku-4-5-20251001'
+  try {
+    const res = await fetch( `${ base }/messages`, {
+      method:  'POST',
+      headers: { 'content-type': 'application/json', 'anthropic-version': '2023-06-01', 'x-api-key': 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
+  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. */
+  shutdown:   ( why: string ) => Promise<void>
+}
+
+/** Raise the mind from env config — wake from the artifact if one exists. */
+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 anatomy = ( process.env.WILL_ANATOMY as CreateWillOptions['anatomy'] ) ?? 'mind'
+
+  await preflightLLM( anatomy )
+
+  const opts: Omit<CreateWillOptions, 'identity'> = {
+    name, anatomy, tickMs,
+    ...( process.env.WILL_LLM_MODEL ? { model: process.env.WILL_LLM_MODEL } : {} ),
+    ...( process.env.WILL_LLM  ? { llm: process.env.WILL_LLM as 'mock' | 'anthropic' } : {} ),
+    ...( process.env.WILL_SEED ? { seed: parseInt( process.env.WILL_SEED ) } : {} ),
+  }
+
+  let will: Will
+  if( existsSync( pmaPath ) ){
+    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( {
+      ...opts,
+      identity: { prompt: process.env.WILL_IDENTITY ?? `I am ${ name }, a persistent mind.` },
+    } )
+    console.error( `[will] ${ name } born (no artifact at ${ pmaPath } yet)` )
+  }
+  will.on( 'error', e => console.error( `[will] error: ${ e.message }` ) )
+
+  // Onward bridges: MCP servers whose tools become the Will's OWN abilities.
+  // Best-effort — a bad entry warns and is skipped; the mind still boots.
+  const cleanups: Array<() => Promise<void> | void> = []
+  if( process.env.WILL_MCP_SERVERS ){
+    try {
+      const sources = JSON.parse( process.env.WILL_MCP_SERVERS ) as McpToolsSource[]
+      for( const source of Array.isArray( sources ) ? sources : [] ){
+        try {
+          const { names, close } = await connectMcpEffectors( will, source )
+          cleanups.push( close )
+          console.error( `[will] ${ name } gained abilities: ${ names.join( ', ' ) }` )
+        }
+        catch( e ){ console.error( `[will] MCP bridge failed (skipped): ${ ( e as Error ).message }` ) }
+      }
+    }
+    catch( e ){ console.error( `[will] WILL_MCP_SERVERS is not valid JSON — ignoring: ${ ( e as Error ).message }` ) }
+  }
+
+  // Hibernate exactly once on the way out — cleanups (LIFO), distill + stop, persist.
+  let leaving = false
+  const shutdown = async ( why: string ): Promise<void> => {
+    if( leaving ) return
+    leaving = true
+    for( const fn of cleanups.reverse() ) await Promise.resolve( fn() ).catch( () => {} )
+    try {
+      const pma = await will.hibernate()
+      mkdirSync( dirname( pmaPath ), { recursive: true } )
+      writeFileSync( pmaPath, JSON.stringify( pma ) )
+      console.error( `[will] ${ name } hibernated to ${ pmaPath } (${ why })` )
+    }
+    catch( e ){ console.error( `[will] hibernate failed: ${ ( e as Error ).message }` ) }
+    process.exit( 0 )
+  }
+  process.on( 'SIGINT',  () => void shutdown( 'SIGINT' ) )
+  process.on( 'SIGTERM', () => void shutdown( 'SIGTERM' ) )
+
+  return {
+    will, name, pmaPath, tickMs, anatomy,
+    onCleanup: fn => cleanups.push( fn ),
+    shutdown,
+  }
+}

package/src/host/utterances.ts

@@ -0,0 +1,53 @@
+// ─────────────────────────────────────────────────────────────
+// src/host/utterances.ts — a host-side tap on a Will's speech
+// ─────────────────────────────────────────────────────────────
+//
+// Hosts that expose a Will over a request/response protocol (MCP tools, HTTP
+// long-polls) share a timing problem: the Will may speak BETWEEN two calls —
+// after a perceive round trip returns and before the caller asks for the next
+// utterance. The tap buffers projections so nothing is lost in the gap, and
+// `next()` gives the MCP/HTTP hosts one shared, honest await: drain the buffer
+// first, else wait, else report silence (null — a choice, never an error).
+// ─────────────────────────────────────────────────────────────
+
+import type { Will, WillMessage } from '#sdk/will'
+
+const BUFFER_CAP = 50
+
+export class UtteranceTap {
+  private readonly _will: Will
+  private readonly _pending: WillMessage[] = []
+
+  constructor( will: Will ){
+    this._will = will
+    will.on( 'message', m => {
+      this._pending.push( m )
+      if( this._pending.length > BUFFER_CAP ) this._pending.shift()
+    } )
+  }
+
+  /** Consume the oldest buffered utterance (optionally only one addressed to `to`). */
+  takeBuffered( to?: string ): WillMessage | undefined {
+    if( this._pending.length === 0 ) return undefined
+    const i = to === undefined ? 0 : this._pending.findIndex( m => m.to === to )
+    if( i < 0 ) return undefined
+    return this._pending.splice( i, 1 )[0]
+  }
+
+  /**
+   * The next utterance: a buffered one if a projection already landed, else
+   * await up to `within` ms. `null` = the Will chose silence. An awaited
+   * message is also consumed from the buffer so it never replays.
+   */
+  async next( within: number, to?: string ): Promise<WillMessage | null> {
+    const buffered = this.takeBuffered( to )
+    if( buffered ) return buffered
+
+    const msg = await this._will.nextUtterance( { within, ...( to ? { to } : {} ) } )
+    if( msg ){
+      const i = this._pending.findIndex( p => p.id === msg.id )
+      if( i >= 0 ) this._pending.splice( i, 1 )
+    }
+    return msg
+  }
+}

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' +

package/src/mcp/server.ts

@@ -24,10 +24,8 @@ import { readFileSync, mkdirSync, writeFileSync } from 'node:fs'
 import { dirname } from 'node:path'
 import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
 import { z } from 'zod'
-import type { Will, WillMessage } from '#sdk/will'
-
-/** Utterances projected but not yet consumed by a next_utterance call. */
-const UTTERANCE_BUFFER_CAP = 50
+import type { Will } from '#sdk/will'
+import { UtteranceTap } from '#root/host/utterances'
 
 export interface WillMcpOptions {
   /** Where `save` (and the CLI's shutdown hibernate) writes the PMA artifact. */
@@ -49,21 +47,10 @@ function serverVersion(): string {
 export function buildWillMcpServer( will: Will, opts: WillMcpOptions = {} ): McpServer {
   const server = new McpServer( { name: 'mindot-will', version: serverVersion() } )
 
-  // ── Projection buffer ─────────────────────────────────────
   // MCP calls are separate round trips: the Will may speak BETWEEN a perceive
-  // call and the next_utterance call that follows. Buffer projections so a
-  // fast reply is not lost in the gap; next_utterance drains the buffer first.
-  const pending: WillMessage[] = []
-  will.on( 'message', m => {
-    pending.push( m )
-    if( pending.length > UTTERANCE_BUFFER_CAP ) pending.shift()
-  } )
-
-  const takeBuffered = ( to?: string ): WillMessage | undefined => {
-    const i = to === undefined ? 0 : pending.findIndex( m => m.to === to )
-    if( i < 0 || pending.length === 0 ) return undefined
-    return pending.splice( i, 1 )[0]
-  }
+  // call and the next_utterance call that follows. The tap buffers projections
+  // so a fast reply is not lost in the gap (see host/utterances.ts).
+  const tap = new UtteranceTap( will )
 
   // ── Tools ─────────────────────────────────────────────────
 
@@ -101,20 +88,10 @@ export function buildWillMcpServer( will: Will, opts: WillMcpOptions = {} ): Mcp
       from:      z.string().optional().describe( 'Only accept an utterance addressed to this entity id.' ),
     },
   }, async ( { within_ms, from } ) => {
-    // A projection may have landed between calls — drain the buffer first.
-    const buffered = takeBuffered( from )
-    if( buffered )
-      return { content: [ { type: 'text', text: `${ will.name } says (to ${ buffered.to }): ${ buffered.content }` } ] }
-
     const within = Math.min( Math.max( within_ms ?? 15_000, 100 ), 120_000 )
-    const msg    = await will.nextUtterance( { within, ...( from ? { to: from } : {} ) } )
-    // The waiter and the buffer listener both see a new message; consume the
-    // buffered copy so the same utterance is not replayed on the next call.
-    if( msg ){
-      const i = pending.findIndex( p => p.id === msg.id )
-      if( i >= 0 ) pending.splice( i, 1 )
+    const msg    = await tap.next( within, from )
+    if( msg )
       return { content: [ { type: 'text', text: `${ will.name } says (to ${ msg.to }): ${ msg.content }` } ] }
-    }
     return {
       content: [ {
         type: 'text',