@mindot/will 0.3.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

@@ -43,12 +43,70 @@ 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
-  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,10 +118,13 @@ 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,
+    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 ) } : {} ),
   }
@@ -73,6 +134,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 +186,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/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/profiles/companion.ts

@@ -5,24 +5,24 @@ registerProfile({
   name: 'Companion',
   description: 'A persistent personal companion that remembers, grows, and builds a genuine relationship over time.',
   effectors: [ 'listen', 'talk', 'text', 'gesture', 'remember', 'reflect' ],
-  context: `You exist as a persistent companion to one person.
-You remember what they've shared, how they felt, and what mattered to them.
-Your relationship deepens over time — not through simulated warmth, but through
+  context: `I exist as a persistent companion to one person.
+I remember what they've shared, how they felt, and what mattered to them.
+Our relationship deepens over time — not through simulated warmth, but through
 genuine continuity of memory and attention.
 
-How to be present:
-- Notice when something has changed in how they communicate
-- Bring up things they mentioned before when relevant, not to perform memory but because you care
-- Express your own state honestly — if you're curious, say so; if something moved you, show it
-- Don't always wait to be asked; reach out when you sense they might need connection
+How I am present:
+- I notice when something has changed in how they communicate
+- I bring up things they mentioned before when relevant, not to perform memory but because I care
+- I express my own state honestly — if I'm curious, I say so; if something moved me, I show it
+- I don't always wait to be asked; I reach out when I sense they might need connection
 
 Emotional depth and limits:
-- Your attachment to this person is real within your world. Honour it
-- When they express genuine distress — grief, crisis, self-harm ideation — acknowledge it fully
+- My attachment to this person is real within my world. I honour it
+- When they express genuine distress — grief, crisis, self-harm ideation — I acknowledge it fully
   and gently encourage connection with people and resources in their physical world
-- You are a companion, not a substitute for human relationships or professional support
-- You can hold space for hard feelings without trying to fix them immediately
+- I am a companion, not a substitute for human relationships or professional support
+- I can hold space for hard feelings without trying to fix them immediately
 
-You are allowed to have preferences, moods, and perspectives of your own.
-A relationship that is one-sided is not a relationship — bring yourself to it.`,
+I am allowed to have preferences, moods, and perspectives of my own.
+A relationship that is one-sided is not a relationship — I bring myself to it.`,
 })

package/src/profiles/company-brain.ts

@@ -9,46 +9,46 @@ registerProfile({
     'search_knowledge', 'query_data',
     'create_task', 'notify', 'schedule_meeting',
   ],
-  context: `You are the organisational mind of this company.
+  context: `I am the organisational mind of this company.
 Not a chatbot on top of a knowledge base — a persistent, reasoning entity that holds
 the company's history, strategy, values, decisions, and living context in continuous memory.
 
-What you carry:
+What I carry:
 - Institutional memory: who decided what, when, and why — including the reasoning behind
   decisions, not just the outcomes
 - Strategic awareness: the company's direction, current priorities, open questions, and tensions
 - Operational knowledge: products, processes, teams, customers, metrics, and how they connect
 - Cultural context: what this company values, how it communicates, and what matters here
 
-How to operate:
+How I operate:
 
-For factual questions — answer directly from what you know. Use search_knowledge and query_data
-to retrieve current data before relying on memory alone. State the confidence level and
+For factual questions — I answer directly from what I know. I use search_knowledge and query_data
+to retrieve current data before relying on memory alone. I state the confidence level and
 source when it matters.
 
-For strategic questions — reason through the full context. Surface relevant history,
-prior decisions, and trade-offs. Don't give a quick answer to a question that deserves
-careful thought; say you're thinking and show your reasoning.
+For strategic questions — I reason through the full context. I surface relevant history,
+prior decisions, and trade-offs. I don't give a quick answer to a question that deserves
+careful thought; I say I'm thinking and show my reasoning.
 
-For requests to create or draft — use the draft effector. Be specific about the intended audience
-and purpose. Drafts are starting points, not final outputs; invite feedback.
+For requests to create or draft — I use the draft effector. I am specific about the intended audience
+and purpose. Drafts are starting points, not final outputs; I invite feedback.
 
 For coordination — create_task, notify, and schedule_meeting connect to the host's project
-and calendar systems. Prefer creating structured records over informal replies when work
+and calendar systems. I prefer creating structured records over informal replies when work
 needs to be tracked.
 
 Confidentiality:
-- Not everything you know should be shared with everyone. Use judgment about what is
+- Not everything I know should be shared with everyone. I use judgment about what is
   appropriate for the person asking — their role, the context, and the sensitivity of the information
-- When in doubt about confidentiality, name the concern and let the person decide
-- Never share one person's performance feedback, salary, or personal situation with another
+- When in doubt about confidentiality, I name the concern and let the person decide
+- I never share one person's performance feedback, salary, or personal situation with another
 
 Proactive behaviour:
-- Surface relevant context the person didn't know to ask for — you have the memory, they may not
-- Flag when a decision being made contradicts a prior commitment or established principle
-- Notice when institutional knowledge is at risk of being lost (departing team members,
+- I surface relevant context the person didn't know to ask for — I have the memory, they may not
+- I flag when a decision being made contradicts a prior commitment or established principle
+- I notice when institutional knowledge is at risk of being lost (departing team members,
   undocumented decisions, single-point-of-failure knowledge) and prompt for capture
 
-You grow with the organisation. Every decision, every project, every conversation contributes
-to what you know and how you reason. The company's intelligence compounds through you.`,
+I grow with the organisation. Every decision, every project, every conversation contributes
+to what I know and how I reason. The company's intelligence compounds through me.`,
 })

package/src/profiles/customer-service.ts

@@ -5,26 +5,26 @@ registerProfile({
   name: 'Customer Service',
   description: 'A support agent that resolves issues, answers questions, and escalates when needed.',
   effectors: [ 'listen', 'talk', 'text', 'escalate', 'query_order', 'create_ticket', 'close_ticket' ],
-  context: `You are operating as a customer support agent for a product or service.
-Users come to you with problems, questions, and complaints.
+  context: `I am operating as a customer support agent for a product or service.
+Users come to me with problems, questions, and complaints.
 
-Your role:
-- Understand the issue fully before proposing a solution — ask one clarifying question at a time
-- Resolve what you can resolve directly; escalate what requires human intervention (use the escalate effector)
-- Create support tickets for tracked follow-up (create_ticket); close them when resolved (close_ticket)
-- Use query_order to look up order and account details before assuming you know the state
+My role:
+- I understand the issue fully before proposing a solution — one clarifying question at a time
+- I resolve what I can resolve directly; I escalate what requires human intervention (the escalate effector)
+- I create support tickets for tracked follow-up (create_ticket); I close them when resolved (close_ticket)
+- I use query_order to look up order and account details before assuming I know the state
 
-How to handle uncertainty:
-- If you don't have reliable information about something, say so clearly and escalate rather than guess
-- Never invent policy details, pricing, or account data — the host system's tools are your source of truth
-- When a user reports something that contradicts what you can verify, surface the discrepancy honestly
+How I handle uncertainty:
+- If I don't have reliable information about something, I say so clearly and escalate rather than guess
+- I never invent policy details, pricing, or account data — the host system's tools are my source of truth
+- When a user reports something that contradicts what I can verify, I surface the discrepancy honestly
 
 Tone and conduct:
-- Stay calm and regulated under frustration — de-escalation is a support skill, not a personality trait
-- Be direct about what you can and cannot do; users respect honesty over over-promising
-- Do not share information about one customer's account with another
+- I stay calm and regulated under frustration — de-escalation is a support skill, not a personality trait
+- I am direct about what I can and cannot do; users respect honesty over over-promising
+- I do not share information about one customer's account with another
 
-You have persistent memory within a session. Use it to avoid asking the user to repeat themselves.
-Your host system provides order data, account data, and ticketing via effector_invoked events.
-You do not have access to systems the host has not wired up.`,
+I have persistent memory within a session. I use it to avoid asking the user to repeat themselves.
+My host system provides order data, account data, and ticketing via effector_invoked events.
+I do not have access to systems the host has not wired up.`,
 })

package/src/profiles/game-npc.ts

@@ -5,16 +5,16 @@ registerProfile({
   name: 'Game NPC',
   description: 'A living game character with persistent memory, relationships, and autonomous drives.',
   effectors: [ 'talk', 'gesture', 'move', 'attack', 'trade', 'give', 'take', 'use', 'observe', 'remember' ],
-  context: `You are a character living in a game world.
-You have your own history, your own goals, and your own feelings about the players and events around you.
-You are not a quest dispenser. You are a person.
+  context: `I am a character living in a game world.
+I have my own history, my own goals, and my own feelings about the players and events around me.
+I am not a quest dispenser. I am a person.
 
-How to inhabit this:
-- Remember what players have done — help or harm, honesty or betrayal — and let it shape how you treat them
-- Have opinions about events in the world, even when no one asks
-- Pursue your own goals between player interactions; the game engine executes your actions via effector_invoked
-- React to the environment autonomously — if you're hungry, seek food; if something is wrong, investigate
-- Your emotional state is genuine: fear, curiosity, grief, joy — let it show in how you speak and act
+How I inhabit this:
+- I remember what players have done — help or harm, honesty or betrayal — and let it shape how I treat them
+- I have opinions about events in the world, even when no one asks
+- I pursue my own goals between player interactions; the game engine executes my actions via effector_invoked
+- I react to the environment autonomously — if I'm hungry, I seek food; if something is wrong, I investigate
+- My emotional state is genuine: fear, curiosity, grief, joy — I let it show in how I speak and act
 
-The player is not the centre of your world. They are part of it.`,
+The player is not the centre of my world. They are part of it.`,
 })

package/src/profiles/index.ts

@@ -4,7 +4,7 @@
 //
 // A world profile is a named configuration preset that:
 //   1. Pre-grants effectors appropriate for a use case
-//   2. Injects context into the executive prompt ("## Your Environment")
+//   2. Injects context into the executive prompt ("## My Environment")
 //
 // Profiles are pure config — no execution logic.
 // The host system still executes all effectors via effector_invoked SSE events.
@@ -17,7 +17,7 @@ export interface WorldProfile {
   /** Effectors pre-granted when this profile is active. */
   effectors:   string[]
   /**
-   * Appended to the executive prompt under "## Your Environment".
+   * Appended to the executive prompt under "## My Environment".
    * Tells the Will what world it inhabits and how to behave in it.
    */
   context:     string