@mindot/will 0.3.0 → 0.5.0

package/src/channels/whatsapp.ts

@@ -0,0 +1,318 @@
+// ─────────────────────────────────────────────────────────────
+// src/channels/whatsapp.ts — a Will present on WhatsApp
+// ─────────────────────────────────────────────────────────────
+//
+// Same paradigm as the Discord bridge, different room:
+//
+//   inbound   DM / group message → will.perceive({ from, speaker, text, thread })
+//             — every author is `whatsapp:<number>` (stable across chats), the
+//             push name is *learned* by the mind, and each chat (DM or group)
+//             is its own conversation thread.
+//   outbound  will.on('message') → the addressee's last shared group, else
+//             their DM (a WhatsApp DM jid is derivable from the number — no
+//             roster miss is fatal), else the home chat.
+//
+// TRANSPORT — read before deploying. This bridge speaks the *linked-device*
+// protocol via Baileys: the Will pairs to a WhatsApp account by QR scan, like
+// WhatsApp Web. That is not a sanctioned bot API — WhatsApp's terms don't
+// allow automation on personal accounts, and accounts doing it can be banned.
+// Meta's sanctioned path (the Business Cloud API) needs a business account,
+// webhook hosting, and app review — no 2-minute pairing. Operator's choice;
+// docs/channels/whatsapp.md is explicit about the trade. Use a spare number.
+//
+// Baileys is imported lazily inside `createWhatsAppSocket` — tests (and hosts
+// that bring their own transport) inject `socket`, and the structural
+// `WaLikeSocket` type keeps the dependency out of the type graph.
+// ─────────────────────────────────────────────────────────────
+
+import type { Will, WillMessage } from '#sdk/will'
+import { ChannelRoster } from '#channels/roster'
+import { chunkText, type ChannelBridge } from '#channels/types'
+
+/** WhatsApp's hard per-message cap. */
+const WHATSAPP_MESSAGE_LIMIT = 65_536
+
+// ── The slice of a Baileys socket the bridge actually uses (structural) ──────
+
+export interface WaLikeMessage {
+  key: {
+    remoteJid?: string | null
+    fromMe?: boolean | null
+    /** Sender jid inside a group (absent in DMs). */
+    participant?: string | null
+  }
+  /** Sender's display ("push") name. */
+  pushName?: string | null
+  messageStubType?: number | null
+  message?: {
+    conversation?: string | null
+    extendedTextMessage?: { text?: string | null; contextInfo?: { mentionedJid?: string[] | null } | null } | null
+    imageMessage?: { caption?: string | null } | null
+    videoMessage?: { caption?: string | null } | null
+  } | null
+}
+
+export interface WaLikeSocket {
+  /** The paired account, once connected. id like '4915…:12@s.whatsapp.net'. */
+  user?: { id: string; name?: string } | null
+  ev: { on( event: 'messages.upsert', fn: ( u: { messages: WaLikeMessage[]; type?: string } ) => void ): unknown }
+  sendMessage( jid: string, content: { text: string } ): Promise<unknown>
+  sendPresenceUpdate?( state: 'composing' | 'paused', jid?: string ): Promise<unknown>
+  /** Tear the connection down (does not unlink the device). */
+  end?( err?: Error ): void
+}
+
+// ── Options ──────────────────────────────────────────────────────────────────
+
+export interface WhatsAppBridgeOptions {
+  /** Chat jids the Will inhabits (groups `…@g.us`, DMs `…@s.whatsapp.net`). Unset = every chat. */
+  chats?: string[]
+  /** Perceive group messages only when the Will is @mentioned (DMs always perceived). */
+  mentionOnly?: boolean
+  /** Fallback chat jid for utterances with no reachable addressee. */
+  homeChatId?: string
+  /** Linked-device credentials dir (default: ./.will/<willId>.wa-auth). QR pairs on first run. */
+  authPath?: string
+  /** Roster path (default: ./.will/<willId>.whatsapp.json). */
+  rosterPath?: string
+  /** Test / power-user seam: bring your own socket; Baileys is never imported. */
+  socket?: WaLikeSocket
+  log?: ( msg: string ) => void
+}
+
+// ── Helpers ──────────────────────────────────────────────────────────────────
+
+const isGroupJid = ( jid: string ): boolean => jid.endsWith( '@g.us' )
+
+/** '4915123:7@s.whatsapp.net' → '4915123' (device + server stripped). */
+const bareId = ( jid: string ): string => jid.split( '@' )[0]!.split( ':' )[0]!
+
+/** A DM jid is derivable from the bare number — WhatsApp's gift to proactivity. */
+const dmJidFor = ( userId: string ): string => `${ userId }@s.whatsapp.net`
+
+function textOf( m: WaLikeMessage ): string {
+  const msg = m.message
+  return msg?.conversation
+      ?? msg?.extendedTextMessage?.text
+      ?? msg?.imageMessage?.caption
+      ?? msg?.videoMessage?.caption
+      ?? ''
+}
+
+// ── The bridge ───────────────────────────────────────────────────────────────
+
+/**
+ * Connect a Will to WhatsApp over the linked-device protocol. First run prints
+ * a QR to pair (Settings → Linked devices → Link a device); credentials persist
+ * in `authPath` so later runs reconnect silently. Close via the returned
+ * `ChannelBridge.close()` — the Will keeps ticking; it only loses this surface.
+ */
+export async function connectWhatsApp( will: Will, opts: WhatsAppBridgeOptions = {} ): Promise<ChannelBridge> {
+  const log     = opts.log ?? ( ( m: string ) => console.error( `[will:whatsapp] ${ m }` ) )
+  const roster  = new ChannelRoster( opts.rosterPath ?? `.will/${ will.id }.whatsapp.json` )
+  const allowed = opts.chats?.length ? new Set( opts.chats ) : null
+
+  let closed = false
+  const socket = opts.socket ?? await createWhatsAppSocket( {
+    authPath: opts.authPath ?? `.will/${ will.id }.wa-auth`,
+    log,
+    stillOpen: () => !closed,
+  } )
+
+  /** The most recently active allowed chat — last-resort proactive target. */
+  let lastActiveChatId: string | null = opts.homeChatId ?? null
+
+  // ── inbound: platform message → stimulus ──────────────────────────────────
+  socket.ev.on( 'messages.upsert', ( { messages, type } ) => {
+    if( type && type !== 'notify' ) return   // history sync/corrections are not new percepts
+    for( const m of messages ) void onMessage( m )
+  } )
+
+  async function onMessage( m: WaLikeMessage ): Promise<void> {
+    const jid = m.key.remoteJid
+    if( !jid || m.key.fromMe || !m.message || m.messageStubType ) return
+    if( jid.endsWith( '@broadcast' ) || jid.endsWith( '@newsletter' ) ) return   // stories/broadcasts aren't a room the Will is in
+    if( allowed && !allowed.has( jid ) ) return
+
+    const isGroup   = isGroupJid( jid )
+    const senderJid = isGroup ? m.key.participant : jid
+    if( !senderJid ) return
+
+    const selfId    = socket.user ? bareId( socket.user.id ) : null
+    const mentioned = m.message.extendedTextMessage?.contextInfo?.mentionedJid ?? []
+    const addressed = !isGroup || ( selfId != null && mentioned.some( j => bareId( j ) === selfId ) )
+    if( opts.mentionOnly && !addressed ) return
+
+    const userId   = bareId( senderJid )
+    const entityId = `whatsapp:${ userId }`
+    const speaker  = m.pushName ?? undefined
+
+    roster.record( {
+      entityId,
+      userId,
+      ...( speaker ? { displayName: speaker } : {} ),
+      ...( isGroup ? { lastChannelId: jid } : { dmChannelId: jid } ),
+    } )
+    if( isGroup ) lastActiveChatId = jid
+
+    // Same rule as Discord: a presence cue only when addressed — the mind may
+    // still choose silence, and 'composing' expires on its own.
+    if( addressed ) await socket.sendPresenceUpdate?.( 'composing', jid ).catch( () => {} )
+
+    const text = textOf( m )
+    if( !text.trim() ) return
+
+    await will.perceive( {
+      text,
+      from:   entityId,
+      thread: `whatsapp:${ jid }`,
+      ...( speaker ? { speaker } : {} ),
+    } )
+  }
+
+  // ── outbound: projected utterance → the addressee ─────────────────────────
+  will.on( 'message', ( m: WillMessage ) => { if( !closed ) void deliver( m ) } )
+
+  async function deliver( m: WillMessage ): Promise<void> {
+    const peer   = m.to ? roster.resolve( m.to ) : undefined
+    const chunks = chunkText( m.content, WHATSAPP_MESSAGE_LIMIT )
+
+    // Last shared group → known DM → DM derived from the entity id itself →
+    // home chat → last active chat. Unlike Discord, an unmet-but-addressed
+    // entity is still reachable: `whatsapp:<number>` implies its DM jid.
+    const derivedDm = m.to?.startsWith( 'whatsapp:' ) ? dmJidFor( m.to.slice( 'whatsapp:'.length ) ) : undefined
+    const targets = [ peer?.lastChannelId, peer?.dmChannelId, derivedDm, opts.homeChatId ?? undefined, lastActiveChatId ?? undefined ]
+    for( const jid of targets ){
+      if( !jid ) continue
+      try {
+        for( const chunk of chunks ) await socket.sendMessage( jid, { text: chunk } )
+        return
+      }
+      catch { /* try the next route */ }
+    }
+    log( `no route for utterance to '${ m.to }' — dropped (${ m.content.length } chars)` )
+  }
+
+  // ── lifecycle ──────────────────────────────────────────────────────────────
+  return {
+    kind: 'whatsapp',
+    async start(): Promise<void> {
+      // createWhatsAppSocket resolves already-open; an injected socket is the
+      // caller's to have readied.
+      log( `${ will.name } is present on WhatsApp${ socket.user ? ` as ${ bareId( socket.user.id ) }` : '' }` )
+    },
+    async close(): Promise<void> {
+      if( closed ) return
+      closed = true
+      roster.flush()
+      try { socket.end?.() } catch { /* already down */ }
+    },
+  }
+}
+
+// ── The real transport (Baileys, lazily imported) ────────────────────────────
+
+interface SocketFactoryOpts {
+  authPath:  string
+  log:       ( msg: string ) => void
+  /** Reconnect only while the bridge is open. */
+  stillOpen: () => boolean
+}
+
+/**
+ * A reconnect-stable facade over Baileys. Baileys' own pattern replaces the
+ * socket object on every reconnect; the facade keeps one stable identity the
+ * bridge can hold, re-attaching its subscribers to each inner incarnation.
+ * Resolves once the first connection is open (after QR pairing on first run).
+ */
+async function createWhatsAppSocket( o: SocketFactoryOpts ): Promise<WaLikeSocket> {
+  let baileys: typeof import( 'baileys' )
+  try { baileys = await import( 'baileys' ) }
+  catch {
+    throw new Error( 'baileys is not installed (it is an optionalDependency) — run `bun add baileys` / `npm i baileys` and retry.' )
+  }
+  const { default: makeWASocket, useMultiFileAuthState, DisconnectReason } = baileys
+
+  // Baileys logs through pino at info by default — JSON noise all over the
+  // host's stderr. A minimal pino-shaped silent logger (child() returns
+  // itself, every level a no-op) is what it actually needs; hand-rolling it
+  // beats importing a transitive dep that may not resolve from dist/.
+  const noop = (): void => {}
+  const logger = {
+    level: 'silent',
+    child(){ return logger },
+    trace: noop, debug: noop, info: noop, warn: noop, error: noop, fatal: noop,
+  }
+
+  type Handler = ( u: { messages: WaLikeMessage[]; type?: string } ) => void
+  const subscribers: Handler[] = []
+  let inner: ReturnType<typeof makeWASocket> | null = null
+
+  const facade: WaLikeSocket = {
+    get user(){ return inner?.user ? { id: inner.user.id, name: inner.user.name ?? undefined } : null },
+    ev: { on: ( _e, fn ) => { subscribers.push( fn ) } },
+    sendMessage: ( jid, content ) => {
+      if( !inner ) return Promise.reject( new Error( 'whatsapp socket not connected' ) )
+      return inner.sendMessage( jid, content )
+    },
+    sendPresenceUpdate: ( state, jid ) => inner?.sendPresenceUpdate( state, jid ) ?? Promise.resolve(),
+    end: () => inner?.end( undefined ),
+  }
+
+  const { state, saveCreds } = await useMultiFileAuthState( o.authPath )
+
+  await new Promise<void>( ( resolveOpen, rejectOpen ) => {
+    let opened = false
+
+    function connect(): void {
+      const sock = makeWASocket( { auth: state, logger: logger as never } )
+      inner = sock
+
+      sock.ev.on( 'creds.update', saveCreds )
+      sock.ev.on( 'messages.upsert', u => { for( const fn of subscribers ) fn( u as never ) } )
+
+      sock.ev.on( 'connection.update', update => {
+        const { connection, lastDisconnect, qr } = update as {
+          connection?: string; lastDisconnect?: { error?: unknown }; qr?: string
+        }
+
+        if( qr ) void printQr( qr, o.log )
+
+        if( connection === 'open' && !opened ){
+          opened = true
+          resolveOpen()
+        }
+        if( connection === 'close' ){
+          const code = ( lastDisconnect?.error as { output?: { statusCode?: number } } | undefined )?.output?.statusCode
+          if( code === DisconnectReason.loggedOut ){
+            const err = new Error( 'WhatsApp unlinked this device (logged out) — delete the auth dir and pair again.' )
+            o.log( err.message )
+            if( !opened ) rejectOpen( err )
+            return
+          }
+          if( o.stillOpen() ){
+            o.log( `connection closed (status ${ code ?? '?' }) — reconnecting…` )
+            setTimeout( connect, 3_000 )
+          }
+        }
+      } )
+    }
+
+    connect()
+  } )
+
+  return facade
+}
+
+/** QR to the terminal; falls back to the raw pairing string if the tiny renderer is absent. */
+async function printQr( qr: string, log: ( m: string ) => void ): Promise<void> {
+  log( 'pair this device: WhatsApp → Settings → Linked devices → Link a device' )
+  try {
+    type QrModule = { generate( s: string, o: { small: boolean } ): void }
+    const qrt = ( await import( 'qrcode-terminal' as string ) ) as QrModule & { default?: QrModule }
+    ;( qrt.default ?? qrt ).generate( qr, { small: true } )
+  }
+  catch {
+    log( `qrcode-terminal not installed — raw pairing code:\n${ qr }` )
+  }
+}

package/src/cli.ts

@@ -3,8 +3,11 @@
 // src/cli.ts — the `will` command: host a persistent mind
 // ─────────────────────────────────────────────────────────────
 //
-//   will mcp     host over MCP stdio (Claude Desktop / Claude Code / IDEs)
-//   will serve   host over HTTP (any language; the sidecar) — WILL_PORT/WILL_HOST
+//   will mcp       host over MCP stdio (Claude Desktop / Claude Code / IDEs)
+//   will serve     host over HTTP (any language; the sidecar) — WILL_PORT/WILL_HOST
+//   will discord   a presence in a Discord server — DISCORD_BOT_TOKEN
+//   will whatsapp  a presence on WhatsApp — QR-pairs a linked device (unofficial
+//                  protocol; see docs/channels/whatsapp.md before deploying)
 //
 // Both hosts raise the same mind the same way (see host/boot.ts): env-configured,
 // woken from its PMA artifact when one exists, hibernated back on the way out —
@@ -24,14 +27,21 @@ import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import { routeLogsToStderr, bootWillFromEnv } from '#root/host/boot'
 import { buildWillMcpServer } from '#root/mcp/server'
 import { buildWillHttpServer } from '#root/serve/server'
+import { connectDiscord } from '#channels/discord'
+import { connectWhatsApp } from '#channels/whatsapp'
 
 // stdout is the MCP protocol channel under `will mcp` — route logs FIRST.
 routeLogsToStderr()
 
-const USAGE = `usage: will <mcp | serve>
+const USAGE = `usage: will <mcp | serve | discord | whatsapp>
 
-  mcp     host a persistent mind over MCP stdio (Claude Desktop / Claude Code)
-  serve   host a persistent mind over HTTP (any language; WILL_PORT, default 7777)
+  mcp       host a persistent mind over MCP stdio (Claude Desktop / Claude Code)
+  serve     host a persistent mind over HTTP (any language; WILL_PORT, default 7777)
+  discord   put a persistent mind in a Discord server (DISCORD_BOT_TOKEN; optional
+            WILL_DISCORD_CHANNELS, WILL_DISCORD_MENTION_ONLY, WILL_DISCORD_HOME_CHANNEL)
+  whatsapp  put a persistent mind on WhatsApp — QR-pairs as a linked device; no token.
+            UNOFFICIAL protocol (ban risk; use a spare number — docs/channels/whatsapp.md).
+            Optional WILL_WHATSAPP_CHATS, WILL_WHATSAPP_MENTION_ONLY, WILL_WHATSAPP_HOME_CHAT
 
 Shared env: WILL_NAME, WILL_IDENTITY, WILL_TIER, WILL_LLM, WILL_TICK_MS,
 WILL_SEED, WILL_PMA_PATH, WILL_MCP_SERVERS. The mind persists across runs via
@@ -40,19 +50,57 @@ its PMA artifact.`
 async function main(): Promise<void> {
   const sub = process.argv[2]
 
-  if( sub !== 'mcp' && sub !== 'serve' ){
+  if( sub !== 'mcp' && sub !== 'serve' && sub !== 'discord' && sub !== 'whatsapp' ){
     console.error( sub ? `unknown subcommand: ${ sub }\n\n${ USAGE }` : USAGE )
     process.exit( sub ? 2 : 0 )
   }
 
-  const { will, name, pmaPath, tickMs, engineTier, onCleanup, shutdown } = await bootWillFromEnv()
+  // Fail on missing platform credentials BEFORE raising a mind.
+  if( sub === 'discord' && !process.env.DISCORD_BOT_TOKEN ){
+    console.error( '[will] DISCORD_BOT_TOKEN is required for `will discord` — create a bot at https://discord.com/developers/applications (enable the Message Content intent) and set the token.' )
+    process.exit( 2 )
+  }
+
+  const { will, name, pmaPath, tickMs, anatomy, onCleanup, shutdown } = await bootWillFromEnv()
 
   if( sub === 'mcp' ){
     // The MCP client owns our stdin — its disconnect is the shutdown signal.
     process.stdin.on( 'end', () => void shutdown( 'client disconnected' ) )
     const server = buildWillMcpServer( will, { pmaPath } )
     await server.connect( new StdioServerTransport() )
-    console.error( `[will] ${ name } is listening on MCP stdio (tick ${ tickMs }ms, tier ${ engineTier })` )
+    console.error( `[will] ${ name } is listening on MCP stdio (tick ${ tickMs }ms, anatomy ${ anatomy })` )
+    return
+  }
+
+  if( sub === 'discord' ){
+    const csv = ( v?: string ) => v?.split( ',' ).map( s => s.trim() ).filter( Boolean )
+    const bridge = await connectDiscord( will, {
+      token:         process.env.DISCORD_BOT_TOKEN!,
+      channels:      csv( process.env.WILL_DISCORD_CHANNELS ),
+      mentionOnly:   /^(1|true|yes)$/i.test( process.env.WILL_DISCORD_MENTION_ONLY ?? '' ),
+      homeChannelId: process.env.WILL_DISCORD_HOME_CHANNEL,
+      rosterPath:    pmaPath.replace( /(\.pma)?\.json$/, '' ) + '.discord.json',
+    } )
+    onCleanup( () => bridge.close() )
+    await bridge.start()
+    console.error( `[will] ${ name } is present on Discord (tick ${ tickMs }ms, anatomy ${ anatomy }) — it speaks when it decides to.` )
+    return
+  }
+
+  if( sub === 'whatsapp' ){
+    const csv = ( v?: string ) => v?.split( ',' ).map( s => s.trim() ).filter( Boolean )
+    const stem = pmaPath.replace( /(\.pma)?\.json$/, '' )
+    // connectWhatsApp blocks here on first run until the printed QR is scanned.
+    const bridge = await connectWhatsApp( will, {
+      chats:       csv( process.env.WILL_WHATSAPP_CHATS ),
+      mentionOnly: /^(1|true|yes)$/i.test( process.env.WILL_WHATSAPP_MENTION_ONLY ?? '' ),
+      homeChatId:  process.env.WILL_WHATSAPP_HOME_CHAT,
+      authPath:    stem + '.wa-auth',
+      rosterPath:  stem + '.whatsapp.json',
+    } )
+    onCleanup( () => bridge.close() )
+    await bridge.start()
+    console.error( `[will] ${ name } is present on WhatsApp (tick ${ tickMs }ms, anatomy ${ anatomy }) — it speaks when it decides to.` )
     return
   }
 
@@ -65,7 +113,7 @@ async function main(): Promise<void> {
     server.once( 'error', reject )
     server.listen( port, host, () => resolve() )
   } )
-  console.error( `[will] ${ name } is listening on http://${ host }:${ port } (tick ${ tickMs }ms, tier ${ engineTier })` )
+  console.error( `[will] ${ name } is listening on http://${ host }:${ port } (tick ${ tickMs }ms, anatomy ${ anatomy })` )
   console.error( `[will] try: curl -X POST http://${ host }:${ port }/perceive -H 'content-type: application/json' -d '{"text":"Hello"}'` )
 }
 

package/src/cognition/agency/engines/deliberation.engine.ts

@@ -42,7 +42,7 @@ interface DeliberationFacetHandle {
   destroy(): void
 }
 export interface DeliberationFacetProvider {
-  spawnFacet(): { attention: 'available' | 'full'; handle?: DeliberationFacetHandle }
+  spawnFacet( role?: 'deliberation' ): { attention: 'available' | 'full'; handle?: DeliberationFacetHandle }
 }
 
 interface Candidate {
@@ -58,8 +58,8 @@ interface Candidate {
 
 const DELIBERATION_INSTRUCTIONS =
   'Automatic action-selection was uncertain or the stakes were high. From the candidate actions ' +
-  'listed above, choose the ONE that best fits who you are and your situation. Do not invent ' +
-  'actions that are not listed. Put your chosen action as your single action; its "type" must be ' +
+  'listed above, choose the ONE that best fits who I am and my situation. Do not invent ' +
+  'actions that are not listed. Put my chosen action as my single action; its "type" must be ' +
   'exactly one of the candidate names.'
 
 export class DeliberationEngine implements CognitiveEngine {
@@ -143,7 +143,7 @@ export class DeliberationEngine implements CognitiveEngine {
   ): Promise<string> {
     try {
       if( !this._handle ){
-        const spawned = this._provider!.spawnFacet()
+        const spawned = this._provider!.spawnFacet('deliberation')
         if( spawned.attention === 'full' || !spawned.handle ){
           logger.info( '[deliberation] facet budget full — confirming substrate winner' )
           return provisional
@@ -209,9 +209,9 @@ export class DeliberationEngine implements CognitiveEngine {
     // facet owns the interruption in-character rather than reasoning in a vacuum.
     const preemptedFrom = str( meta['preemptedFrom'] )
     if( preemptedFrom )
-      lines.push( `You just broke off a pending action ("${ preemptedFrom }") because something more pressing pulled at you. Decide what to do now:` )
+      lines.push( `I just broke off a pending action ("${ preemptedFrom }") because something more pressing pulled at me. Decide what to do now:` )
     else
-      lines.push( 'Your automatic action-selection was uncertain. Candidate actions:' )
+      lines.push( 'My automatic action-selection was uncertain. Candidate actions:' )
     candidates.forEach( ( c, i ) => {
       const to   = c.targetEntityId ? ` toward ${ c.targetEntityId }` : ''
       // The ability's meaning, so the facet weighs what each option IS FOR rather
@@ -219,7 +219,7 @@ export class DeliberationEngine implements CognitiveEngine {
       const what = c.description ? ` — ${ c.description }` : ''
       // Channel B: name the plan link so the facet chooses as the self pursuing it,
       // not blindly among labels ("this one is the next step of the plan I'm on").
-      const plan = c.fromPlan ? " (your current plan's next step)" : ''
+      const plan = c.fromPlan ? " (my current plan's next step)" : ''
       lines.push( `${ i + 1 }. ${ c.schema }${ to }${ what }${ plan }` )
     })
     return lines.join( '\n' )

package/src/cognition/agency/execution.primitives.ts

@@ -59,7 +59,7 @@ export function enact( ctx: EnactionContext ): Enaction {
     const name = str( ctx.parameters['targetEntityName'] ) ?? ctx.targetEntityId ?? 'them'
     return {
       mode, success: true, outcomeQuality: 0.7, valence: 0.1,
-      description: `You reach toward ${ name }. The words are sent; their effect is not yet known.`,
+      description: `I reach toward ${ name }. The words are sent; their effect is not yet known.`,
     }
   }
 
@@ -81,26 +81,26 @@ function syncStance( ctx: EnactionContext ): Enaction {
 
   switch( schema.id ){
     case 'rest':
-      // More restorative the more depleted you were.
-      return sync( 0.5 + ( 1 - e01 ) * 0.4, 0.15, 'You let yourself recover; the pressure eases a little.' )
+      // More restorative the more depleted the Will was.
+      return sync( 0.5 + ( 1 - e01 ) * 0.4, 0.15, 'I let myself recover; the pressure eases a little.' )
     case 'withdraw':
-      return sync( 0.5 + s01 * 0.3, 0.05 + s01 * 0.1, 'You pull back from the press of things; the world quietens.' )
+      return sync( 0.5 + s01 * 0.3, 0.05 + s01 * 0.1, 'I pull back from the press of things; the world quietens.' )
     case 'reflect':
-      return sync( 0.6, 0.05, 'You turn inward; patterns from recent events settle into place.' )
+      return sync( 0.6, 0.05, 'I turn inward; patterns from recent events settle into place.' )
     case 'attend':
-      return sync( 0.6, 0.0, 'You concentrate, mobilizing more of your attention.' )
+      return sync( 0.6, 0.0, 'I concentrate, mobilizing more of my attention.' )
     case 'orient':
-      return sync( 0.5, 0.0, 'Your awareness sweeps the situation, taking its measure.' )
+      return sync( 0.5, 0.0, 'My awareness sweeps the situation, taking its measure.' )
     case 'wait':
-      return sync( 0.5, 0.0, 'You let time pass; regulatory processes continue their quiet work.' )
+      return sync( 0.5, 0.0, 'I let time pass; regulatory processes continue their quiet work.' )
     case 'express':
-      return sync( 0.6, 0.1, 'Your inner state becomes outwardly visible.' )
+      return sync( 0.6, 0.1, 'My inner state becomes outwardly visible.' )
     case 'inspect': {
       const focus = str( parameters['focus'] ) ?? 'it'
-      return sync( 0.65, 0.05, `You examine ${ focus } closely; more of its detail resolves.` )
+      return sync( 0.65, 0.05, `I examine ${ focus } closely; more of its detail resolves.` )
     }
     default:
-      return sync( 0.5, 0.0, `You enact ${ schema.id }.` )
+      return sync( 0.5, 0.0, `I enact ${ schema.id }.` )
   }
 }
 

package/src/cognition/agency/proactive.communicator.ts

@@ -77,12 +77,12 @@ export class ProactiveCommunicator {
   ): Promise<ActionResult> {
     return {
       success: true,
-      description: `You open yourself to incoming communication. Others may now reach you through available channels.`,
+      description: `I open myself to incoming communication. Others may now reach me through available channels.`,
       commands,
       feedback: {
         outcomeQuality: 1.0,
         surprise: 0.05,
-        lessons: [ 'Being reachable allows others to connect with you.' ],
+        lessons: [ 'Being reachable allows others to connect with me.' ],
       },
     }
   }
@@ -105,7 +105,7 @@ export class ProactiveCommunicator {
 
     return {
       success: true,
-      description: `You ${gestureType} toward ${targetEntityId}. The gesture is directed and sincere.`,
+      description: `I ${gestureType} toward ${targetEntityId}. The gesture is directed and sincere.`,
       commands,
       feedback: {
         outcomeQuality: 0.8,
@@ -137,7 +137,7 @@ export class ProactiveCommunicator {
 
     return {
       success: true,
-      description: `You broadcast: "${finalContent.slice( 0, 80 )}${finalContent.length > 80 ? '…' : ''}"`,
+      description: `I broadcast: "${finalContent.slice( 0, 80 )}${finalContent.length > 80 ? '…' : ''}"`,
       commands,
       feedback: {
         outcomeQuality: 0.75,
@@ -168,7 +168,7 @@ export class ProactiveCommunicator {
     if( !targetEntityId ){
       return {
         success: false,
-        description: `You want to ${effectorName} but there is no one specific to reach out to.`,
+        description: `I want to ${effectorName} but there is no one specific to reach out to.`,
         commands,
         feedback: {
           outcomeQuality: 0,
@@ -181,7 +181,7 @@ export class ProactiveCommunicator {
     if( bubbles.length === 0 ){
       return {
         success: false,
-        description: `You wanted to ${effectorName} ${targetEntityName} but didn't write anything.`,
+        description: `I wanted to ${effectorName} ${targetEntityName} but didn't write anything.`,
         commands,
         feedback: { outcomeQuality: 0, surprise: 0.1, lessons: [ 'Provide a messages array with the actual words.' ] },
       }
@@ -261,12 +261,12 @@ export class ProactiveCommunicator {
 
     return {
       success: true,
-      description: `You reach out to ${targetEntityName}: "${fullReply.slice( 0, 80 )}${fullReply.length > 80 ? '…' : ''}"`,
+      description: `I reach out to ${targetEntityName}: "${fullReply.slice( 0, 80 )}${fullReply.length > 80 ? '…' : ''}"`,
       commands,
       feedback: {
         outcomeQuality: 0.85,
         surprise: 0.15,
-        lessons: [ `Your message is queued for delivery to ${targetEntityName}.` ],
+        lessons: [ `My message is queued for delivery to ${targetEntityName}.` ],
       },
     }
   }

package/src/cognition/config.mirror.entities.ts

@@ -33,8 +33,8 @@ export function buildEngineConfigEntities( config: WillConfig, executiveInterval
       id: 'engine-config-system',
       engine: 'system',
       params: {
-        engineTier:     config.engineTier,
-        modelTier:      config.modelTier,
+        anatomy:        config.anatomy ?? 'mind',
+        model:          config.model ?? '',
         tickIntervalMs: config.tickIntervalMs ?? 1000
       }
     },

package/src/cognition/conversation.memory.ts

@@ -69,7 +69,7 @@ export function buildConversationExchange( input: ConversationExchangeInput ): C
       tags:          [ 'conversation', 'exchange', `entity:${ entityId }` ],
       summary:       userMessage
         ? `${ name }: "${ userMessage.slice( 0, 100 ) }" → "${ willReply.slice( 0, 100 ) }"`
-        : `You → ${ name }: "${ willReply.slice( 0, 140 ) }"`,
+        : `I → ${ name }: "${ willReply.slice( 0, 140 ) }"`,
       entityId,
       entityName:    name,
       userMessage,

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

@@ -97,21 +97,13 @@ export function buildStateCommands(
   commands.set!.push( ...ideo.set )
   commands.delete!.push( ...ideo.delete )
 
-  // ── Apply Plans ────────────────────────────────────────────
-  if( output.plans )
-    for( const plan of output.plans )
-      commands.set!.push({
-        id: `plan-executive-${plan.goalId}-${footprint.tickObserved}`,
-        type: 'plan',
-        metadata: {
-          goalId: plan.goalId,
-          steps: plan.steps.map( ( s, i ) => ({ ...s, order: i }) ),
-          estimatedCost: plan.estimatedCost,
-          confidence: plan.feasibility,
-          status: 'ready',
-          source: 'executive'
-        }
-      })
+  // ── Plans ──────────────────────────────────────────────────
+  // No entity write here: the PlanningEngine is the single ingest path for
+  // `output.plans` (→ PlanStore lifecycle + persistence). The former raw
+  // `plan-executive-<goal>-<tick>` records froze at status 'ready' forever,
+  // piled up per re-authoring, and fed back into the executive's own
+  // Active-Plans awareness as phantom drafts — encouraging yet another
+  // re-authoring. (The PlanningEngine sweeps legacy ones on wake.)
 
   // ── Apply New Beliefs ──────────────────────────────────────
   if( output.newBeliefs && deps.semanticIntegrator ){