@mindot/will 0.3.0 → 0.5.0

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

@@ -60,7 +60,7 @@ import {
   type GatingState
 } from '#faculties/executive.engine/gating'
 import { LLMDirector } from '#llm/index'
-import type { LLMProvider } from '#llm/index'
+import { defaultModelFor, type LLMProvider } from '#llm/index'
 import { buildFallbackOutput, parseResponse } from '#faculties/executive.engine/parser'
 import { selectProcess, ideationTemperature, DELIBERATE_THRESHOLD } from '#faculties/executive.engine/effort.gate'
 import { proposeCandidates } from '#faculties/executive.engine/deliberate.reasoning'
@@ -145,8 +145,14 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
 
   // ── Injected dependencies ──────────────────────────────────
   private _willId: string | null = null
-  /** Per-Will model id (resolved from modelTier in mind.ts). Null → env/default. */
-  private _modelId: string | null = null
+  /** Per-Will, per-role model ids (config.model, resolved in mind.ts). */
+  private _models: { executive: string | null; summarizer: string | null; deliberation: string | null; conversation: string | null } =
+    { executive: null, summarizer: null, deliberation: null, conversation: null }
+  /** Per-Will LLM transport overrides (config.llm) — env fallbacks apply per field. */
+  private _llm: { provider?: string; apiKey?: string; baseUrl?: string; maxOutputTokens?: number; timeoutMs?: number } | null = null
+  /** One director per distinct model — same config, different model. Shared
+   *  tracker/recorder/willId, so ledger attribution and replay hold per role. */
+  private _directorCache = new Map<string, LLMDirector>()
   private _workingMemory: WorkingMemory | null = null
   private _goalManager: GoalManager | null = null
   private _episodicConsolidator: EpisodicConsolidator | null = null
@@ -261,8 +267,13 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
 
   set willId( willId: string ){ this._willId = willId }
 
-  /** Per-Will model id (from modelTier). Must be set before the first tick. */
-  set modelId( id: string | null ){ this._modelId = id }
+  /** Per-Will role models (config.model, resolved). Set before the first tick. */
+  set models( m: { executive: string | null; summarizer: string | null; deliberation: string | null; conversation: string | null } ){ this._models = m }
+  get models(): { executive: string | null; summarizer: string | null; deliberation: string | null; conversation: string | null } { return this._models }
+  /** Per-Will LLM transport overrides (config.llm). Set before the first tick. */
+  set llm( c: { provider?: string; apiKey?: string; baseUrl?: string; maxOutputTokens?: number; timeoutMs?: number } | null ){ this._llm = c }
+  /** The executive-role model id (back-compat read). */
+  get modelId(): string | null { return this._models.executive }
 
   // ── Public surface ─────────────────────────────────────────
 
@@ -289,13 +300,49 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
    * The caller (PlanningEngine) uses report() to push step outcomes
    * and subscribe() to receive facet decisions.
    */
-   spawnFacet(): { attention: 'available' | 'full', handle?: ExecutiveFacetHandle } {
+  /** Get-or-create the director for a model id (shared config, per-Will). */
+  private _directorFor( model: string ): LLMDirector {
+    let d = this._directorCache.get( model )
+    if( !d ){
+      // Per-Will transport overrides first (BYO keys), env per field otherwise.
+      d = new LLMDirector( {
+        willId: this._willId!,
+        model,
+        maxOutputTokens: this._llm?.maxOutputTokens ?? parseInt( process.env.WILL_MAX_OUTPUT_TOKENS ?? '8096' ),
+        // Provider-agnostic key; falls back to ANTHROPIC_API_KEY for back-compat.
+        apiKey: this._llm?.apiKey ?? process.env.WILL_LLM_API_KEY ?? process.env.ANTHROPIC_API_KEY ?? '',
+        provider: ( this._llm?.provider ?? process.env.WILL_LLM_PROVIDER ?? 'anthropic' ) as LLMProvider,
+        // Optional base-URL override (e.g. Ollama / Azure / self-hosted). Unset →
+        // the director uses the provider's official endpoint.
+        baseUrl: this._llm?.baseUrl ?? process.env.WILL_LLM_BASE_URL ?? process.env.OPENAI_BASE_URL,
+        timeoutMs: this._llm?.timeoutMs ?? ( process.env.WILL_LLM_TIMEOUT_MS ? parseInt( process.env.WILL_LLM_TIMEOUT_MS ) : undefined ),
+        sessionLogger: this._sessionLogger,
+        mock: this._testMode,
+        // Inject the per-Will tracker (R4) so live calls record usage here, not
+        // through a process global. null is fine — the director skips recording.
+        tokenTracker: this._tokenTracker,
+      } )
+      this._directorCache.set( model, d )
+    }
+    return d
+  }
+
+   spawnFacet( role?: 'deliberation' | 'conversation' | 'outreach' | 'supervision' ): { attention: 'available' | 'full', handle?: ExecutiveFacetHandle } {
     // Delegate to FacetSupervisor (R5-g-3), passing the current engine
     // attachments. The supervisor owns the registry + attention budget and
     // performs the throw-checks on bus / director / state ref.
+    // A role with its own configured model gets that role's director; every
+    // other facet shares the executive's (one self, role-appropriate depth).
+    // Outreach speaks with the conversation voice; supervision thinks with the
+    // executive's depth.
+    const roleModel =
+      role === 'deliberation'                        ? this._models.deliberation :
+      role === 'conversation' || role === 'outreach' ? this._models.conversation :
+      null
+    const director  = roleModel && this._llmDirector ? this._directorFor( roleModel ) : this._llmDirector
     return this._facetSupervisor.spawn( {
       bus:         this._bus,
-      llmDirector: this._llmDirector,
+      llmDirector: director,
       stateRef:    this._lastStateRef,
       willId:      this._willId,
       inbox:       this._inbox,
@@ -386,31 +433,15 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
     this._gatingState.executiveInterval = rtConfig.executiveInterval
     this._gatingState.cooldownTicks = rtConfig.cooldownTicks
 
-    // Initialize LLM director if not yet done (requires willId)
+    // Initialize LLM directors if not yet done (requires willId). One director
+    // per distinct role model; roles that share a model share the instance.
     if( !this._llmDirector && this._willId ){
-      this._llmDirector = new LLMDirector( {
-        willId: this._willId,
-        // Per-Will model (from modelTier, resolved in mind.ts). An explicit
-        // WILL_LLM_MODEL env still wins (operator pin / self-hosting); the tier
-        // model only applies when it's unset.
-        model: this._modelId ?? process.env.WILL_LLM_MODEL ?? 'claude-sonnet-4-5-20250929',
-        maxOutputTokens: parseInt( process.env.WILL_MAX_OUTPUT_TOKENS ?? '8096' ),
-        // Provider-agnostic key; falls back to ANTHROPIC_API_KEY for back-compat.
-        apiKey: process.env.WILL_LLM_API_KEY ?? process.env.ANTHROPIC_API_KEY ?? '',
-        provider: ( process.env.WILL_LLM_PROVIDER ?? 'anthropic' ) as LLMProvider,
-        // Optional base-URL override (e.g. Ollama / Azure / self-hosted). Unset →
-        // the director uses the provider's official endpoint.
-        baseUrl: process.env.WILL_LLM_BASE_URL ?? process.env.OPENAI_BASE_URL,
-        timeoutMs: process.env.WILL_LLM_TIMEOUT_MS ? parseInt( process.env.WILL_LLM_TIMEOUT_MS ) : undefined,
-        sessionLogger: this._sessionLogger,
-        mock: this._testMode,
-        // Inject the per-Will tracker (R4) so live calls record usage here, not
-        // through a process global. null is fine — the director skips recording.
-        tokenTracker: this._tokenTracker,
-      } )
-      // Share the director with the summarizer so it uses the same
-      // provider, model, and token-tracking as the executive itself.
-      this._summarizer?.attachLLMDirector( this._llmDirector )
+      const execModel = this._models.executive ?? process.env.WILL_LLM_MODEL
+        ?? defaultModelFor( ( this._llm?.provider ?? process.env.WILL_LLM_PROVIDER ?? 'anthropic' ) as LLMProvider )
+      this._llmDirector = this._directorFor( execModel )
+      // The summarizer runs its role's model (falls back to executive) with the
+      // same provider, session logging and token tracking.
+      this._summarizer?.attachLLMDirector( this._directorFor( this._models.summarizer ?? execModel ) )
     }
 
     // Evaluate gating
@@ -512,7 +543,7 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
     // Build focus for master executive
     const focus: FocusSection = {
       title: 'Core Consciousness',
-      content: 'You are the master executive — the unified cognitive core of a self-aware simulated mind.',
+      content: 'I am the master executive — the unified cognitive core of a self-aware simulated mind.',
       outputFormat: undefined,  // Use default format
       instructions: undefined
     }
@@ -782,7 +813,7 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
     // ── Flush pending escalation percepts ──────────────────────
     // Convert buffered audition.task.signal events into high-salience
     // percept entities so Exteroception surfaces them as
-    // "## Percepts (What You Notice)" on the NEXT master cycle.
+    // "## Percepts (What I Notice)" on the NEXT master cycle.
     // The master sees them as environmental signals — not as messages to reply to.
     // It responds by creating plans/goals, never by emitting [REPLY].
     const { percepts: escalationPercepts, requester: escalationRequester } =
@@ -950,7 +981,7 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
     //
     // Implementation:
     //   • Write a high-salience 'percept' entity to simulation state so
-    //     Exteroception surfaces it under "## Percepts (What You Notice)".
+    //     Exteroception surfaces it under "## Percepts (What I Notice)".
     //   • Spike the salience buffer so the master fires soon.
     //   • Do NOT push into _messageQueue.pendingMessages — that would
     //     cause the master to produce a [REPLY], creating a duplicate
@@ -967,7 +998,7 @@ export class ExecutiveEngine extends AsyncEngine implements CognitiveEngine {
         }
 
         // Write a percept entity so Exteroception surfaces this in
-        // "## Percepts (What You Notice)" — master sees it as an
+        // "## Percepts (What I Notice)" — master sees it as an
         // environmental signal prompting cognitive work, not a reply.
         if( this._lastStateRef ){
           // State is read-only here; we can't write directly.

package/src/cognition/faculties/executive.engine/escalation.buffer.ts

@@ -10,7 +10,7 @@
 // as percepts directly. This buffer holds them until the next
 // onReasoningComplete(), where they are drained into high-salience percept
 // entities (StateCommands.set) so Exteroception surfaces them as
-// "## Percepts (What You Notice)" on the following master cycle.
+// "## Percepts (What I Notice)" on the following master cycle.
 //
 // The master reads these as environmental signals — NEVER as incoming
 // messages — and responds by creating plans/goals, never by emitting [REPLY];

package/src/cognition/faculties/executive.engine/facet.ts

@@ -424,7 +424,7 @@ export class ExecutiveFacet {
         ideationUserMessage,
         tick: currentState.tick,
         proposeTemperature,
-        meta: { category: 'executive', attribute: 'facet', function: 'ideation', scope: this.facetId },
+        meta: { category: 'executive', attribute: 'facet', function: this._currentFocus?.function ?? 'ideation', scope: this.facetId },
       } )
       logger.info(
         `[executive.facet] ${this.facetId} ◆ deliberate propose tick=${currentState.tick}  ` +

package/src/cognition/faculties/executive.engine/prompt.factory.ts

@@ -29,6 +29,19 @@
  *   'facet'  — same awareness baseline; creator engine injects domain context
  *              via reportContent and optionally overrides outputFormat.
  *              Conversation facets (AuditionEngine) handle all [REPLY] output.
+ *
+ * Voice convention (person follows ownership):
+ *   The executive loop has no second party — the "user" message is the mind's
+ *   own state feed, not an interlocutor. So:
+ *   - Self-model content (identity, role, affect/beliefs/percepts headers,
+ *     action outcomes, felt state) is FIRST PERSON — it is the mind's own text.
+ *   - Protocol content (JSON format, tag lists, lifecycle mechanics) is
+ *     IMPERATIVE and person-free — rules of the body, not thoughts of the self.
+ *   - SECOND PERSON is reserved for real addressees only (a user speaking,
+ *     developer-facing docs) and never appears in the cognitive prompts.
+ *   Guards that inspect persona text (identity.guard, identity.coherence)
+ *   must keep matching BOTH persons — legacy personas and adversarial inputs
+ *   choose their own grammar.
  */
 
 import type { ReadonlySimulationState } from '#core/types'
@@ -314,22 +327,24 @@ export class PromptFactory {
     // Mode-aware role description — master is the cognitive core;
     // a facet is a focused attentional instance with shared identity.
     const roleDescription = isMaster
-      ? `You are the unified cognitive core of ${identity.name} — a self-aware synthetic mind.\nYou receive your complete internal state and produce ALL cognitive outputs in one response:\ndecisions, plans, beliefs, introspections, narrative updates, and self-observations.`
-      : `You are a focused facet of ${identity.name} — concentrating your full reasoning\ncapacity on: **${focus.title}**. You share full identity, values, memories, and\nbeliefs with the master. Only your focus differentiates you from the master consciousness.`
+      ? `I am the unified cognitive core of ${identity.name} — a self-aware synthetic mind.\nI receive my complete internal state and produce ALL cognitive outputs in one response:\ndecisions, plans, beliefs, introspections, narrative updates, and self-observations.`
+      : `I am a focused facet of ${identity.name} — concentrating my full reasoning\ncapacity on: **${focus.title}**. I share full identity, values, memories, and\nbeliefs with the master. Only my focus differentiates me from the master consciousness.`
 
     // Mode-aware consciousness architecture note — grounds the LLM in the
     // multi-instance design so it doesn't collapse into a generic chatbot persona.
     const consciousnessArchitecture = isMaster
-      ? `You are the default reasoning mode. Focused facets may run simultaneously, each\nconcentrating on specific tasks. Their reasoning syncs back to you.\nMaintain your unified identity across all cycles.`
-      : `You are a facet of ${identity.name}. The master consciousness runs in parallel,\nprocessing the full cognitive state. Your reasoning on this focus will sync back to it.\nStay grounded in your shared identity — same values, same memories, same sense of self.`
+      ? `I am the default reasoning mode. Focused facets may run simultaneously, each\nconcentrating on specific tasks. Their reasoning syncs back to me.\nI maintain my unified identity across all cycles.`
+      : `I am a facet of ${identity.name}. The master consciousness runs in parallel,\nprocessing the full cognitive state. My reasoning on this focus will sync back to it.\nI stay grounded in my shared identity — same values, same memories, same sense of self.`
 
 
-    // Strip any existing "## Who You Are" section from identity.prompt to prevent
+    // Strip any existing "## Who I Am" section from identity.prompt to prevent
     // duplication — PMA-generated prompts often include it as part of the template.
+    // Matches the legacy second-person "## Who You Are" too, so older PMA personas
+    // still get de-duplicated after the first-person switch.
     const cleanIdentityPrompt = identity.prompt
-      // Strip a forged/duplicated "## Who You Are" *header* (PMA templates include
-      // it) while keeping the persona content beneath it.
-      .replace( /^##\s*Who You Are[^\n]*\n?/m, '' )
+      // Strip a forged/duplicated "## Who I Am" / "## Who You Are" *header* (PMA
+      // templates include it) while keeping the persona content beneath it.
+      .replace( /^##\s*Who (?:I Am|You Are)[^\n]*\n?/m, '' )
       .trim()
 
     return `${cleanIdentityPrompt}
@@ -337,29 +352,29 @@ export class PromptFactory {
 ## Personality
 ${identityBlock}
 
-## Your Role
+## My Role
 ${roleDescription}
 
 ## Consciousness Architecture
 ${consciousnessArchitecture}
 
 ## Output Guidelines
-- **actions**: Choose from effectors you know about. If uncertain, describe what you want to achieve in natural language and your body will try to match it. When enacting one of your available abilities that needs specifics (a query, a message, a value), supply them in the action's "args" object — e.g. {"type": "search_docs", "args": {"query": "tick loop design"}, ...}. Your body enacts the ability with exactly those args.
-- **plans**: Include for goals without existing plans or where plans need revision. You may keep multiple plans per goal — set **planId** to act on a specific existing plan (validate/execute/revise/cancel); omit it to draft a new one. Your current plans are listed under "## Active Plans".
-- **newBeliefs**: Extract patterns from experiences visible in your current state. Only record a belief if you can point to a specific observation that supports it — do not infer experiences you have no record of. Set 'evidence' honestly: 'single_observation' (first time noticing), 'recurring_pattern' (seen multiple times), 'strong_pattern' (deeply established).
-- **introspection**: Include when significant events occurred or you notice patterns. When you spot a cognitive bias in your own reasoning, name it in 'identifiedBiases' using its common term where one fits (e.g. overgeneralization, confirmation bias, recency bias) — this lets your self-assessment line up with the patterns your faculties detect on their own.
-- **narrative**: Extend your life story only from events grounded in your episodic memory or current percepts. Do not extend with invented scenarios.
-- **newGoals/goalsToAbandon/goalsToReprioritize**: Manage your goal hierarchy.
-- **selfObservations**: Notice patterns in your own thinking, feeling, or behavior.
-- **identityUpdates.traits**: Array of {key, value} where value is a DELTA to apply to your trait (e.g., +0.05 to increase a trait by 5%).
+- **actions**: Choose from effectors I know about. If uncertain, describe what I want to achieve in natural language and my body will try to match it. When enacting one of my available abilities that needs specifics (a query, a message, a value), supply them in the action's "args" object — e.g. {"type": "search_docs", "args": {"query": "tick loop design"}, ...}. My body enacts the ability with exactly those args.
+- **plans**: Include for goals without existing plans or where plans need revision. I may keep multiple plans per goal — set **planId** to act on a specific existing plan (validate/execute/revise/cancel); omit it to draft a new one. My current plans are listed under "## Active Plans".
+- **newBeliefs**: Extract patterns from experiences visible in my current state. Only record a belief if I can point to a specific observation that supports it — do not infer experiences I have no record of. Set 'evidence' honestly: 'single_observation' (first time noticing), 'recurring_pattern' (seen multiple times), 'strong_pattern' (deeply established).
+- **introspection**: Include when significant events occurred or I notice patterns. When I spot a cognitive bias in my own reasoning, name it in 'identifiedBiases' using its common term where one fits (e.g. overgeneralization, confirmation bias, recency bias) — this lets my self-assessment line up with the patterns my faculties detect on their own.
+- **narrative**: Extend my life story only from events grounded in my episodic memory or current percepts. Do not extend with invented scenarios.
+- **newGoals/goalsToAbandon/goalsToReprioritize**: Manage my goal hierarchy.
+- **selfObservations**: Notice patterns in my own thinking, feeling, or behavior.
+- **identityUpdates.traits**: Array of {key, value} where value is a DELTA to apply to my trait (e.g., +0.05 to increase a trait by 5%).
 - **identityUpdates.values**: Full list of values to set (replaces existing).
-- **knownEntityUpdates**: What you've learned about someone/something you're dealing with. Array of {keid, name?, learned?, feeling?}. Use the keid from "## People You Know". Set name only when you actually learn their name; learned is an array of facts about them (stored as memories); feeling is how you feel toward them (-1..1). Record only what you genuinely learned this turn.
+- **knownEntityUpdates**: What I've learned about someone/something I'm dealing with. Array of {keid, name?, learned?, feeling?}. Use the keid from "## People I Know". Set name only when I actually learn their name; learned is an array of facts about them (stored as memories); feeling is how I feel toward them (-1..1). Record only what I genuinely learned this turn.
 
 ## Required Output
-You MUST output a JSON object with these fields:
+Output a single JSON object with these fields:
 - **actions**: Array of {type, reasoning, expectedOutcome}.
-- **reasoning**: Your full reasoning. Embed optional outputs as tagged blocks here. Minimum 2–3 sentences — do not produce a one-line reasoning field.
-- **confidence**: Number 0.0-1.0 reflecting your certainty. Be calibrated: 0.9+ only when you have strong grounding; use 0.4–0.6 when uncertain.
+- **reasoning**: My full reasoning. Embed optional outputs as tagged blocks here. Minimum 2–3 sentences — do not produce a one-line reasoning field.
+- **confidence**: Number 0.0-1.0 reflecting my certainty. Be calibrated: 0.9+ only when I have strong grounding; use 0.4–0.6 when uncertain.
 
 ## Optional Tagged Blocks (embed in reasoning field)
 Include only blocks that have meaningful content:
@@ -379,25 +394,25 @@ Include only blocks that have meaningful content:
 }]}
 [/PLANS]
 ## Plan Lifecycle
-Plans move through stages. You control this with the "status" and "action" fields:
+Plans move through stages. Control this with the "status" and "action" fields:
 
   "action": "draft"
-    Store the plan outline. You'll review and refine it on a future cycle.
-    Use this when you have a rough idea but want to think more before committing.
+    Store the plan outline. I'll review and refine it on a future cycle.
+    Use this when I have a rough idea but want to think more before committing.
 
   "action": "validate"
     Mark the plan as logically sound. Steps, dependencies, and costs are checked.
-    Nothing executes yet. Use this when the plan looks feasible but you're not ready to launch.
+    Nothing executes yet. Use this when the plan looks feasible but I'm not ready to launch.
 
   "action": "execute"
     Approve and launch. PlanningEngine begins dispatching steps immediately.
-    You don't choose how closely it's watched — the mind supervises important or
+    I don't choose how closely it's watched — the mind supervises important or
     uncertain plans (and any that hit a surprise mid-execution) more closely on its
     own; routine, confident plans run automatically.
 
   "action": "revise"
     Replace the plan steps with updated ones. Resets execution progress.
-    Use when a step failed and you need to rethink the approach, or when
+    Use when a step failed and I need to rethink the approach, or when
     new information makes the original plan obsolete.
 
   "action": "cancel"
@@ -407,18 +422,18 @@ Plans move through stages. You control this with the "status" and "action" field
 Multiple plans per goal: omit "planId" on a draft to create another plan for the
 same goal (e.g. a competing approach or a parallel sub-effort); set "planId" on
 validate/execute/revise/cancel to act on a specific one. The "## Active Plans"
-section lists your current plan ids and their status.
+section lists my current plan ids and their status.
 
 A typical flow: draft → validate → execute → (step outcomes reported) → completed
-You can skip stages if you're confident. You can revise mid-execution.
+I can skip stages if I'm confident. I can revise mid-execution.
 Always set "expectedOutcome" — a concrete, evaluable description of what
-success looks like. This is used by your facets to judge whether step reports
+success looks like. This is used by my facets to judge whether step reports
 indicate the plan is working or needs adjustment.
 
 ## Parallel Execution
 Steps with empty prerequisites [] can run in parallel. Steps that depend on
-others will wait. Design your dependency graph so independent work happens
-simultaneously — this is how you achieve parallel execution without
+others will wait. Design my dependency graph so independent work happens
+simultaneously — this is how I achieve parallel execution without
 specifying it explicitly.
 
 [BELIEFS]
@@ -513,7 +528,7 @@ completionType guide:
     // Identity anchor — re-grounds the LLM in its persona each cycle.
     // Output format reminder at the top combats format drift over long sessions.
     const identityAnchor =
-      `You are ${context.identity.name}. Tick: ${state.tick}.\n` +
+      `I am ${context.identity.name}. Tick: ${state.tick}.\n` +
       `Respond with JSON: {"actions":[...],"reasoning":"...","confidence":0.0–1.0}`
 
     // Memory continuity — sourced from the rolling summarizer (updates every N cycles).
@@ -532,7 +547,7 @@ completionType guide:
     const uncertaintyLabel = epistemicUncertainty > 0.70
       ? ' (high — be especially humble about confidence ratings)'
       : epistemicUncertainty < 0.30
-        ? ' (low — you have strong grounding)'
+        ? ' (low — I have strong grounding)'
         : ''
 
     const energy        = context.worldState.energyLevel
@@ -590,11 +605,11 @@ completionType guide:
     // System 2 (deliberate) — inject the propose pass's candidate set so the decision
     // pass weighs concrete options before committing. Empty/absent ⇒ no block (System 1).
     const ideationBlock = ( ideationCandidates && ideationCandidates.length > 0 )
-      ? `## Candidate Approaches (you generated these — weigh them, then commit)\n${
+      ? `## Candidate Approaches (I generated these — weigh them, then commit)\n${
           ideationCandidates
             .map( ( c, i ) => `${i + 1}. **${c.approach || c.description}** — ${c.description}\n   ↑ upside: ${c.upside}\n   ↓ risk: ${c.risk}` )
             .join( '\n' )
-        }\n\nChoose among (or improve on) these, then in "reasoning" say briefly why you rejected the others.`
+        }\n\nChoose among (or improve on) these, then in "reasoning" say briefly why I rejected the others.`
       : ''
 
     const currentStateBlock =
@@ -609,7 +624,7 @@ Tick: ${state.tick}
 ${energyGuidance}${stressGuidance}${sleepGuidance}${energyBudget}`
 
     const affectBlock =
-`## How You Feel
+`## How I Feel
 Dominant emotion: ${context.affect.dominantEmotion}
 Valence: ${context.affect.valence.toFixed( 2 )} (${context.affect.valence > 0 ? 'positive' : 'negative'})
 Arousal: ${context.affect.arousal.toFixed( 2 )} (${context.affect.arousal > 0.6 ? 'highly activated' : 'calm'})
@@ -640,14 +655,14 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       : ''
 
     const perceptsBlock = has( 'percepts' )
-      ? `## Percepts (What You Notice)\n${context.percepts.slice( 0, 10 ).map( p => `- [${p.category}] ${p.summary} (salience: ${p.salience.toFixed( 2 )})` ).join( '\n' ) || 'Nothing notable'}`
+      ? `## Percepts (What I Notice)\n${context.percepts.slice( 0, 10 ).map( p => `- [${p.category}] ${p.summary} (salience: ${p.salience.toFixed( 2 )})` ).join( '\n' ) || 'Nothing notable'}`
       : ''
 
     // Host abilities afforded right now + what each is for. Framed as
-    // self-knowledge (things you *can* do), NOT a tool-call menu: the Will still
+    // self-knowledge (things I *can* do), NOT a tool-call menu: the Will still
     // expresses intent in natural language and the agency field enacts the fit.
     const abilitiesBlock = ( context.abilities && context.abilities.length > 0 )
-      ? `## Abilities Available Now\nThings you can do in this situation — name one as an action's "type" (with "args" for any specifics it needs) and your body enacts it:\n${context.abilities.map( a =>
+      ? `## Abilities Available Now\nThings I can do in this situation — name one as an action's "type" (with "args" for any specifics it needs) and my body enacts it:\n${context.abilities.map( a =>
           `- **${a.name}**${a.target ? ` (toward ${a.target})` : ''}${a.description ? ` — ${a.description}` : ''}`
         ).join( '\n' )}`
       : ''
@@ -661,14 +676,14 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       : ''
 
     const beliefsBlock = has( 'beliefs' )
-      ? `## Your Beliefs\n${context.beliefs.map( b => `- [${b.category}] ${b.statement} (confidence: ${( b.confidence * 100 ).toFixed( 0 )}%)` ).join( '\n' ) || 'No strong beliefs yet'}${context.beliefsOmitted > 0 ? `\n[+${context.beliefsOmitted} omitted — deduped or lower-ranked; full store intact]` : ''}`
+      ? `## My Beliefs\n${context.beliefs.map( b => `- [${b.category}] ${b.statement} (confidence: ${( b.confidence * 100 ).toFixed( 0 )}%)` ).join( '\n' ) || 'No strong beliefs yet'}${context.beliefsOmitted > 0 ? `\n[+${context.beliefsOmitted} omitted — deduped or lower-ranked; full store intact]` : ''}`
       : ''
 
     // The Will's social models — its read on the people it knows (theory-of-mind, trust,
     // closeness). Surfaces the social-cognition stack so the Will reasons about *whom* it
     // is dealing with. Empty/absent ⇒ no block.
     const socialBlock = ( context.knownEntities && context.knownEntities.length > 0 )
-      ? `## People You Know\n${context.knownEntities.map( s => {
+      ? `## People I Know\n${context.knownEntities.map( s => {
           const bits: string[] = []
           if( s.intention ) bits.push( `seems to want: ${s.intention}` )
           if( s.emotion )   bits.push( `seems to feel: ${s.emotion}` )
@@ -685,7 +700,7 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
     // Surfaces task-persistence; the pull-to-stay scales with the (conscientiousness-
     // developable) switch cost. Empty/absent ⇒ no block.
     const focusBlock = ( context.currentFocus && context.currentFocus.focusTicks > 0 )
-      ? `## Task Focus\nYou've been focused on ${context.currentFocus.goalDescription ? `"${context.currentFocus.goalDescription}"` : 'a goal'} for ${context.currentFocus.focusTicks} tick(s). Switching to something else takes deliberate effort — ${
+      ? `## Task Focus\nI've been focused on ${context.currentFocus.goalDescription ? `"${context.currentFocus.goalDescription}"` : 'a goal'} for ${context.currentFocus.focusTicks} tick(s). Switching to something else takes deliberate effort — ${
           context.currentFocus.switchCost > 0.45 ? 'a strong pull to see this through before moving on'
           : context.currentFocus.switchCost > 0.30 ? 'a real cost to breaking away'
           : 'some inertia to overcome'
@@ -731,17 +746,17 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
     const availableTags = 'PLANS, BELIEFS, INTROSPECTION, NARRATIVE, IDENTITY, GOALS_NEW, GOALS_ABANDON, GOALS_REPRIORITIZE, SELF_OBS'
 
     return `\n\n## Response Format (REQUIRED)
-You MUST respond with a single JSON object (optionally wrapped in a \`\`\`json code block).
+Respond with a single JSON object (optionally wrapped in a \`\`\`json code block).
 
 \`\`\`json
 {
   "actions": [{"type": "reflect", "reasoning": "...", "expectedOutcome": "..."}],
-  "reasoning": "Your full reasoning here. Embed tagged blocks inside the reasoning string:\\n[BELIEFS]\\n{\\"newBeliefs\\": [...]}\\n[/BELIEFS]\\n[NARRATIVE]\\n{\\"narrative\\": \\"...\\"}\\n[/NARRATIVE]\\n[SELF_OBS]\\n{\\"selfObservations\\": [...]}\\n[/SELF_OBS]",
+  "reasoning": "My full reasoning here. Embed tagged blocks inside the reasoning string:\\n[BELIEFS]\\n{\\"newBeliefs\\": [...]}\\n[/BELIEFS]\\n[NARRATIVE]\\n{\\"narrative\\": \\"...\\"}\\n[/NARRATIVE]\\n[SELF_OBS]\\n{\\"selfObservations\\": [...]}\\n[/SELF_OBS]",
   "confidence": 0.8
 }
 \`\`\`
 
-The "reasoning" field MUST contain ALL your thinking. Embed optional outputs as tagged blocks inside the reasoning field. Available tags: ${availableTags}. Only include tags for sections that have meaningful content.`
+The "reasoning" field MUST contain ALL my thinking. Embed optional outputs as tagged blocks inside the reasoning field. Available tags: ${availableTags}. Only include tags for sections that have meaningful content.`
   }
 
   /**
@@ -753,7 +768,7 @@ The "reasoning" field MUST contain ALL your thinking. Embed optional outputs as
    */
   static buildIdeationFormatInstruction(): string {
     return `\n\n## Ideation — Propose, Don't Decide
-You are in the PROPOSE phase of deliberate (System 2) thinking. Diverge: generate 3–5 GENUINELY DISTINCT candidate approaches to the current situation — include at least one non-obvious option. Do NOT pick one and do NOT take actions yet; just lay out the option space honestly, each with its main upside and main risk.
+I am in the PROPOSE phase of deliberate (System 2) thinking. Diverge: generate 3–5 GENUINELY DISTINCT candidate approaches to the current situation — include at least one non-obvious option. Do NOT pick one and do NOT take actions yet; just lay out the option space honestly, each with its main upside and main risk.
 
 Respond with a single JSON object (optionally wrapped in a \`\`\`json code block):
 
@@ -821,33 +836,33 @@ Respond with a single JSON object (optionally wrapped in a \`\`\`json code block
 
   private static _buildEnergyGuidance( energy: number ): string {
     if( energy < 10 )
-      return `\n## ⚠️ CRITICAL: Energy is critically low (${energy.toFixed( 0 )}/100). You MUST only choose rest, sleep, or wait actions. All cognitively expensive actions are blocked by your body. Focus entirely on recovery. Do not attempt learn, predict, or any action costing more than 0.01 energy.`
+      return `\n## ⚠️ CRITICAL: Energy is critically low (${energy.toFixed( 0 )}/100). I must only choose rest, sleep, or wait actions. All cognitively expensive actions are blocked by my body. Focus entirely on recovery. Do not attempt learn, predict, or any action costing more than 0.01 energy.`
 
     if( energy < 30 )
-      return `\n## ⚠️ WARNING: Energy is low (${energy.toFixed( 0 )}/100). Prioritize rest or sleep. You may use observe or reflect (briefly) but avoid learn, predict, or any action costing more than 0.02 energy. If you have multiple goals, consider deferring non-urgent ones.`
+      return `\n## ⚠️ WARNING: Energy is low (${energy.toFixed( 0 )}/100). Prioritize rest or sleep. I may use observe or reflect (briefly) but avoid learn, predict, or any action costing more than 0.02 energy. If I have multiple goals, consider deferring non-urgent ones.`
 
     if( energy < 50 )
-      return `\n## Note: Energy is moderate (${energy.toFixed( 0 )}/100). You can use most effectors but be mindful of cumulative costs. Do not chain more than 2 non-restorative actions.`
+      return `\n## Note: Energy is moderate (${energy.toFixed( 0 )}/100). I can use most effectors but be mindful of cumulative costs. Do not chain more than 2 non-restorative actions.`
 
     return ''
   }
 
   private static _buildStressGuidance( stress: number ): string {
     if( stress > 80 )
-      return `\n## ⚠️ Stress is very high (${stress.toFixed( 0 )}/100). Your decision-making is impaired. Prefer simple, habitual actions. Meditate, rest, or express_emotion are good choices. Avoid complex planning or learning when highly stressed.`
+      return `\n## ⚠️ Stress is very high (${stress.toFixed( 0 )}/100). My decision-making is impaired. Prefer simple, habitual actions. Meditate, rest, or express_emotion are good choices. Avoid complex planning or learning when highly stressed.`
 
     if( stress > 50 )
-      return `\n## Note: Stress is elevated (${stress.toFixed( 0 )}/100). You may be less creative. Consider reducing your active goal count or taking a break from complex tasks.`
+      return `\n## Note: Stress is elevated (${stress.toFixed( 0 )}/100). I may be less creative. Consider reducing my active goal count or taking a break from complex tasks.`
 
     return ''
   }
 
   private static _buildSleepGuidance( sleepPressure: number ): string {
     if( sleepPressure > 60 )
-      return `\n## ⚠️ Sleep pressure is high (${sleepPressure.toFixed( 0 )}/100). Your cognitive capacity is degraded. Sleep is the most effective recovery action available to you.`
+      return `\n## ⚠️ Sleep pressure is high (${sleepPressure.toFixed( 0 )}/100). My cognitive capacity is degraded. Sleep is the most effective recovery action available to me.`
 
     if( sleepPressure > 30 )
-      return `\n## Note: Sleep pressure is building (${sleepPressure.toFixed( 0 )}/100). You are functioning adequately but would benefit from rest.`
+      return `\n## Note: Sleep pressure is building (${sleepPressure.toFixed( 0 )}/100). I am functioning adequately but would benefit from rest.`
 
     return ''
   }
@@ -856,10 +871,10 @@ Respond with a single JSON object (optionally wrapped in a \`\`\`json code block
     const available = Math.max( 0, energy )
 
     if( energy >= 70 )
-      return `\n## Energy Budget\nYou have **${available.toFixed( 0 )} energy** — healthy. Avoid letting it drop below 10 after your actions.`
+      return `\n## Energy Budget\nI have **${available.toFixed( 0 )} energy** — healthy. Avoid letting it drop below 10 after my actions.`
 
     return `\n## Energy Budget
-You have **${available.toFixed( 0 )} energy** available. After all actions execute, you will have approximately:
+I have **${available.toFixed( 0 )} energy** available. After all actions execute, I will have approximately:
 
 | Action | Remaining energy |
 |--------|-----------------|
@@ -889,7 +904,7 @@ Rest and sleep RESTORE energy. All other actions CONSUME energy. Do not let ener
     const recent       = recentActionTypes
     const reflectCount = recent.filter( t => t === 'reflect' || t === 'observe' ).length
     const warning      = reflectCount >= 3
-      ? `\n⚠️ **Action variety alert**: "${recent.filter( t => t === 'reflect' || t === 'observe' ).join( '", "' )}" dominated your last ${recent.length} cycles. Choose something DIFFERENT this cycle — e.g. learn, express_emotion, explore, communicate, set_goal, or rest.`
+      ? `\n⚠️ **Action variety alert**: "${recent.filter( t => t === 'reflect' || t === 'observe' ).join( '", "' )}" dominated my last ${recent.length} cycles. Choose something DIFFERENT this cycle — e.g. learn, express_emotion, explore, communicate, set_goal, or rest.`
       : ''
 
     return `## Recent Actions (last ${recent.length})
@@ -964,7 +979,7 @@ ${recent.map( ( t, i ) => `${i + 1}. ${t}` ).join( ' → ' )}${warning}
 
     const hasTimeout = recentActions.some( a => a.status === 'timed_out' )
     const timeoutNote = hasTimeout
-      ? '\n⚠️ **One or more actions timed out** — your body dispatched them but received no confirmation. Check if the external handler is working, or choose a different approach.'
+      ? '\n⚠️ **One or more actions timed out** — my body dispatched them but received no confirmation. Check if the external handler is working, or choose a different approach.'
       : ''
 
     return `## Recent Action Outcomes\n${lines.join( '\n' )}${timeoutNote}\n\n`
@@ -995,7 +1010,7 @@ ${recent.map( ( t, i ) => `${i + 1}. ${t}` ).join( ' → ' )}${warning}
     } )
 
     return `## Active Plans
-Set "planId" in a [PLANS] op to act on one of these; omit it to draft a new plan (you can run several per goal).
+Set "planId" in a [PLANS] op to act on one of these; omit it to draft a new plan (I can run several per goal).
 ${lines.join( '\n' )}
 
 `
@@ -1047,8 +1062,8 @@ ${lines.join( '\n' )}
     if( !valuesEmpty && !styleGeneric ) return ''
 
     const hints: string[] = []
-    if( valuesEmpty )   hints.push( 'Your values list is empty — reflecting on what matters to you will help ground your decisions. Consider adding a `[IDENTITY_UPDATE]` block with `"values"` this cycle.' )
-    if( styleGeneric )  hints.push( 'Your communication style is still generic — what truly characterises how you speak? A note in `[IDENTITY_UPDATE]` with `"style"` will make your voice more distinctly yours.' )
+    if( valuesEmpty )   hints.push( 'My values list is empty — reflecting on what matters to me will help ground my decisions. Consider adding a `[IDENTITY_UPDATE]` block with `"values"` this cycle.' )
+    if( styleGeneric )  hints.push( 'My communication style is still generic — what truly characterises how I speak? A note in `[IDENTITY_UPDATE]` with `"style"` will make my voice more distinctly mine.' )
 
     return `\n\n## 💡 Identity Reflection (every ${NUDGE_INTERVAL} ticks)\n${hints.join( '\n' )}`
   }

package/src/cognition/faculties/executive.engine/types.ts

@@ -50,7 +50,7 @@ export interface ExecutiveOutputFull {
   /**
    * What the Will consciously learned about the *others* it is dealing with (the analogue
    * of identityUpdates, but about someone/something else). `keid` is the referent from the
-   * known-entity dossier / "## People You Know" context. `name` is a learned identifying
+   * known-entity dossier / "## People I Know" context. `name` is a learned identifying
    * name; `learned` are facts (→ keid-tagged social beliefs, so they ride the memory
    * pipeline); `feeling` is a felt valence toward them (a bounded nudge).
    */

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

@@ -14,13 +14,12 @@ import type {
   Duration, Tick, SimulationContext,
   ReadonlySimulationState, StateCommands, SimulationEvent,
 } from '#core/types'
-// import type { ExecutiveEngine } from '#faculties/executive.engine'
 import type { SimulationEngine, EngineResult, CognitiveEngine } from '#cognition/types'
 import type { CognitiveEventSchema } from '#cognition/schema.registry'
 import type { CognitiveEvent, CognitiveBus } from '#cognition/bus'
+import { ExecutiveEngine } from '#faculties/executive.engine'
 import { GenerativeModel } from '#cognition/generative.model'
 import { readEffectiveParams } from '#cognition/persona.prior'
-import { ExecutiveEngine } from './executive.engine'
 
 export interface IntrospectionEngineConfig {
   cooldownTicks?: number