@mindot/will 0.2.0 → 0.4.0

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@mindot/will",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "author": "Fabrice <fabrice8@github.com>",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/mindot-ai/will.git"
   },
   "bin": {
-    "will": "dist/mcp/cli.js"
+    "will": "dist/cli.js"
   },
   "main": "./dist/index.js",
   "devDependencies": {
@@ -21,6 +21,7 @@
     "zod": "^4.0.0"
   },
   "optionalDependencies": {
+    "discord.js": "^14.16.3",
     "socket.io-client": "^4.8.1"
   },
   "exports": {
@@ -31,6 +32,10 @@
     "./mcp": {
       "import": "./dist/mcp/effectors.js",
       "types": "./dist/mcp/effectors.d.ts"
+    },
+    "./discord": {
+      "import": "./dist/channels/discord.js",
+      "types": "./dist/channels/discord.d.ts"
     }
   },
   "bugs": {

package/src/channels/discord.ts

@@ -0,0 +1,214 @@
+// ─────────────────────────────────────────────────────────────
+// src/channels/discord.ts — a Will present in a Discord server
+// ─────────────────────────────────────────────────────────────
+//
+// The bridge relays both directions of the paradigm and nothing else:
+//
+//   inbound   guild/DM message → will.perceive({ from, speaker, text, thread })
+//             — every author is `discord:<userId>` (stable across guilds), the
+//             display name is *learned* by the mind, and each Discord channel
+//             is its own conversation thread.
+//   outbound  will.on('message') → the addressee's last shared channel, else
+//             their DM, else the home channel. Proactive utterances (the mind
+//             speaking first) route the same way — that is the point.
+//
+// The Will decides when to speak. There is no command prefix and no forced
+// reply: unaddressed chatter is perceived (salience-scored by audition) and
+// silence is a valid outcome. `mentionOnly` narrows perception for busy
+// servers; it does not turn the bridge into an ask() surface.
+//
+// discord.js is imported lazily inside `createDiscordClient` — tests (and any
+// host that brings its own client) inject `client`, and the structural
+// `DiscordLikeClient` 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'
+
+const DISCORD_MESSAGE_LIMIT = 2000
+
+// ── The slice of discord.js the bridge actually uses (structural) ───────────
+
+export interface DiscordLikeChannel {
+  send( content: string ): Promise<unknown>
+  sendTyping?(): Promise<unknown>
+}
+
+export interface DiscordLikeMessage {
+  content: string
+  cleanContent?: string
+  channelId: string
+  guildId?: string | null
+  author: { id: string; bot?: boolean; username?: string; displayName?: string }
+  member?: { displayName?: string } | null
+  mentions?: { has( userId: string ): boolean }
+  channel: DiscordLikeChannel
+}
+
+export interface DiscordLikeClient {
+  user: { id: string; setPresence?( p: unknown ): void } | null
+  /** discord.js ≥14.22; polled so we needn't subscribe to the deprecated `ready`. */
+  isReady?(): boolean
+  on( event: 'messageCreate', fn: ( m: DiscordLikeMessage ) => void ): unknown
+  once( event: string, fn: () => void ): unknown
+  login( token: string ): Promise<unknown>
+  destroy(): Promise<unknown> | void
+  channels: { fetch( id: string ): Promise<unknown> }
+  users: { fetch( id: string ): Promise<{ send( content: string ): Promise<unknown> }> }
+}
+
+// ── Options ──────────────────────────────────────────────────────────────────
+
+export interface DiscordBridgeOptions {
+  /** Bot token (Discord developer portal). Unused when `client` is injected pre-logged-in. */
+  token?: string
+  /** Channel ids the Will inhabits. Unset = every channel it can see. */
+  channels?: string[]
+  /** Perceive guild messages only when the Will is @mentioned (DMs always perceived). */
+  mentionOnly?: boolean
+  /** Fallback channel for utterances with no reachable addressee. */
+  homeChannelId?: string
+  /** Roster path (default: ./.will/<willId>.discord.json). */
+  rosterPath?: string
+  /** Test / power-user seam: bring your own client; discord.js is never imported. */
+  client?: DiscordLikeClient
+  log?: ( msg: string ) => void
+}
+
+// ── The bridge ───────────────────────────────────────────────────────────────
+
+/**
+ * Connect a Will to Discord. Resolves once the bridge is live (logged in and
+ * relaying). Close it via the returned `ChannelBridge.close()` — the Will
+ * itself is not stopped; it simply loses this surface.
+ */
+export async function connectDiscord( will: Will, opts: DiscordBridgeOptions ): Promise<ChannelBridge> {
+  const log     = opts.log ?? ( ( m: string ) => console.error( `[will:discord] ${ m }` ) )
+  const roster  = new ChannelRoster( opts.rosterPath ?? `.will/${ will.id }.discord.json` )
+  const allowed = opts.channels?.length ? new Set( opts.channels ) : null
+
+  const client = opts.client ?? await createDiscordClient()
+
+  /** The most recently active allowed channel — last-resort proactive target. */
+  let lastActiveChannelId: string | null = opts.homeChannelId ?? null
+
+  // ── inbound: platform message → stimulus ──────────────────────────────────
+  client.on( 'messageCreate', message => { void onMessage( message ) } )
+
+  async function onMessage( message: DiscordLikeMessage ): Promise<void> {
+    const self = client.user
+    if( !self || message.author.id === self.id || message.author.bot ) return
+
+    const isDM = !message.guildId
+    if( !isDM && allowed && !allowed.has( message.channelId ) ) return
+
+    const addressed = isDM || ( message.mentions?.has( self.id ) ?? false )
+    if( opts.mentionOnly && !addressed ) return
+
+    const entityId = `discord:${ message.author.id }`
+    const speaker  = message.member?.displayName ?? message.author.displayName ?? message.author.username
+
+    roster.record( {
+      entityId,
+      userId: message.author.id,
+      ...( speaker ? { displayName: speaker } : {} ),
+      ...( isDM ? { dmChannelId: message.channelId } : { lastChannelId: message.channelId } ),
+    } )
+    if( !isDM ) lastActiveChannelId = message.channelId
+
+    // Being addressed is the one moment a presence cue is honest — the mind
+    // may still choose silence, and typing expires on its own.
+    if( addressed ) await message.channel.sendTyping?.().catch( () => {} )
+
+    const text = message.cleanContent || message.content
+    if( !text.trim() ) return
+
+    await will.perceive( {
+      text,
+      from:   entityId,
+      thread: `discord:${ message.channelId }`,
+      ...( speaker ? { speaker } : {} ),
+    } )
+  }
+
+  // ── outbound: projected utterance → the addressee ─────────────────────────
+  // The facade has no off(); the bridge gates its handler on `closed` instead.
+  let closed = false
+  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, DISCORD_MESSAGE_LIMIT )
+
+    // Preference order: where we last shared a room → their DM → home channel.
+    const channelIds = [ peer?.lastChannelId, peer?.dmChannelId, opts.homeChannelId ?? undefined, lastActiveChannelId ?? undefined ]
+    for( const id of channelIds ){
+      if( !id ) continue
+      try {
+        const channel = await client.channels.fetch( id ) as DiscordLikeChannel | null
+        if( !channel?.send ) continue
+        for( const chunk of chunks ) await channel.send( chunk )
+        return
+      }
+      catch { /* try the next route */ }
+    }
+    if( peer ){
+      try {
+        const user = await client.users.fetch( peer.userId )
+        for( const chunk of chunks ) await user.send( chunk )
+        return
+      }
+      catch { /* fall through */ }
+    }
+    log( `no route for utterance to '${ m.to }' — dropped (${ m.content.length } chars)` )
+  }
+
+  // ── lifecycle ──────────────────────────────────────────────────────────────
+  const bridge: ChannelBridge = {
+    kind: 'discord',
+    async start(): Promise<void> {
+      if( !client.user ){
+        // discord.js ≥14.22 renamed `ready` → `clientReady`. Subscribing to the
+        // old name is what triggers its DeprecationWarning, so we take the new
+        // name and poll `isReady()` for older builds rather than listening.
+        const ready = new Promise<void>( resolve => {
+          let poll: ReturnType<typeof setInterval> | null = null
+          const done = (): void => { if( poll ) clearInterval( poll ); resolve() }
+          client.once( 'clientReady', done )
+          poll = setInterval( () => { if( client.isReady?.() ) done() }, 100 )
+          poll.unref?.()
+        } )
+        await client.login( opts.token ?? '' )
+        await ready
+      }
+      log( `${ will.name } is present on Discord as user ${ client.user?.id }` )
+    },
+    async close(): Promise<void> {
+      if( closed ) return
+      closed = true
+      roster.flush()
+      await Promise.resolve( client.destroy() ).catch( () => {} )
+    },
+  }
+  return bridge
+}
+
+/** Build a real discord.js client (lazy import keeps it out of non-Discord hosts). */
+async function createDiscordClient(): Promise<DiscordLikeClient> {
+  let mod: typeof import( 'discord.js' )
+  try { mod = await import( 'discord.js' ) }
+  catch {
+    throw new Error( 'discord.js is not installed (it is an optionalDependency) — run `bun add discord.js` / `npm i discord.js` and retry.' )
+  }
+  const { Client, GatewayIntentBits, Partials } = mod
+  return new Client( {
+    intents: [
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
+      GatewayIntentBits.MessageContent,
+      GatewayIntentBits.DirectMessages,
+    ],
+    partials: [ Partials.Channel ],   // DMs arrive on uncached channels
+  } ) as unknown as DiscordLikeClient
+}

package/src/channels/roster.ts

@@ -0,0 +1,87 @@
+// ─────────────────────────────────────────────────────────────
+// src/channels/roster.ts — who the Will knows on a platform, and where
+// ─────────────────────────────────────────────────────────────
+//
+// The mind knows *entities*; a platform knows user ids and channels. The roster
+// is the durable seam between them: for each entity the Will has met on a
+// channel it records how to reach them again — so a *proactive* utterance
+// (`message.to` from the mind's own initiative) can find its person after a
+// restart, not just within one session.
+//
+// It persists as a small JSON file next to the PMA artifact. Writes are
+// throttled (the file is advisory routing state, not cognition — losing the
+// last few seconds costs a fallback delivery, never memory).
+// ─────────────────────────────────────────────────────────────
+
+import { existsSync, readFileSync, mkdirSync, writeFileSync } from 'node:fs'
+import { dirname } from 'node:path'
+
+/** How to reach one entity on the platform. */
+export interface RosterEntry {
+  /** The mind-side entity id, e.g. 'discord:80351110224678912'. */
+  entityId: string
+  /** The platform-side user id. */
+  userId: string
+  /** Last display name seen (advisory — the *learned* name lives in the mind). */
+  displayName?: string
+  /** DM channel id, once one is known. */
+  dmChannelId?: string
+  /** Last shared (guild) channel this entity spoke in. */
+  lastChannelId?: string
+  /** Epoch ms of the last message seen from them. */
+  lastSeenAt: number
+}
+
+const FLUSH_MS = 2_000
+
+export class ChannelRoster {
+  private entries = new Map<string, RosterEntry>()
+  private dirty = false
+  private timer: ReturnType<typeof setTimeout> | null = null
+
+  constructor( private readonly path: string ) {
+    if( existsSync( path ) ){
+      try {
+        const raw = JSON.parse( readFileSync( path, 'utf8' ) ) as RosterEntry[]
+        for( const e of Array.isArray( raw ) ? raw : [] ) this.entries.set( e.entityId, e )
+      }
+      catch { /* a corrupt roster is not worth failing a boot over — start fresh */ }
+    }
+  }
+
+  /** Upsert what we just learned about an entity; schedules a throttled flush. */
+  record( update: { entityId: string; userId: string } & Partial<Omit<RosterEntry, 'entityId' | 'userId'>> ): RosterEntry {
+    const prev = this.entries.get( update.entityId )
+    const next: RosterEntry = {
+      lastSeenAt: Date.now(),
+      ...prev,
+      ...Object.fromEntries( Object.entries( update ).filter( ( [ , v ] ) => v !== undefined ) ) as typeof update,
+    }
+    this.entries.set( next.entityId, next )
+    this.dirty = true
+    if( !this.timer ){
+      this.timer = setTimeout( () => { this.timer = null; this.flush() }, FLUSH_MS )
+      this.timer.unref?.()
+    }
+    return next
+  }
+
+  resolve( entityId: string ): RosterEntry | undefined {
+    return this.entries.get( entityId )
+  }
+
+  all(): RosterEntry[] {
+    return [ ...this.entries.values() ]
+  }
+
+  /** Write to disk now (no-op when clean). Called by bridges on close. */
+  flush(): void {
+    if( !this.dirty ) return
+    try {
+      mkdirSync( dirname( this.path ), { recursive: true } )
+      writeFileSync( this.path, JSON.stringify( this.all(), null, 2 ) )
+      this.dirty = false
+    }
+    catch { /* advisory state — never take the mind down over it */ }
+  }
+}

package/src/channels/types.ts

@@ -0,0 +1,46 @@
+// ─────────────────────────────────────────────────────────────
+// src/channels/types.ts — the channel-bridge contract
+// ─────────────────────────────────────────────────────────────
+//
+// A channel bridge puts a Will *in a place where people already are* (Discord,
+// Telegram, Slack, …). It is a host surface, not a cognition surface: it turns
+// platform messages into `perceive` stimuli and delivers the Will's projected
+// utterances back — nothing more. The paradigm survives the crossing:
+//
+//   • every platform user is an entity the Will comes to know (`from`),
+//     with a *learned* name (`speaker`) — never a placeholder;
+//   • every platform channel/DM is a conversation thread (`thread`);
+//   • the Will decides when to speak. Silence is a valid outcome, so a
+//     bridge never fabricates a reply and never times a message out into
+//     an error.
+//
+// Bridges live at the same altitude as the MCP/HTTP hosts (src/mcp, src/serve):
+// they wrap the SDK facade, not the stem.
+// ─────────────────────────────────────────────────────────────
+
+/** A running connection between one Will and one platform. */
+export interface ChannelBridge {
+  /** Platform kind, e.g. 'discord'. */
+  readonly kind: string
+  /** Connect and start relaying. Resolves once the bridge is live. */
+  start(): Promise<void>
+  /** Disconnect and release resources. Idempotent. */
+  close(): Promise<void>
+}
+
+/** Split a message into platform-sized chunks on natural boundaries. */
+export function chunkText( text: string, max: number ): string[] {
+  if( text.length <= max ) return [ text ]
+  const chunks: string[] = []
+  let rest = text
+  while( rest.length > max ){
+    // Prefer a paragraph break, then a line break, then a space — else hard-cut.
+    const window = rest.slice( 0, max )
+    const cut = Math.max( window.lastIndexOf( '\n\n' ), window.lastIndexOf( '\n' ), window.lastIndexOf( ' ' ) )
+    const at = cut > max * 0.5 ? cut : max
+    chunks.push( rest.slice( 0, at ).trimEnd() )
+    rest = rest.slice( at ).trimStart()
+  }
+  if( rest ) chunks.push( rest )
+  return chunks
+}

package/src/cli.ts

@@ -0,0 +1,100 @@
+#!/usr/bin/env node
+// ─────────────────────────────────────────────────────────────
+// 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 discord  a presence in a Discord server — DISCORD_BOT_TOKEN
+//
+// 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 —
+// the mind PERSISTS across sessions. Shared env: WILL_NAME, WILL_IDENTITY,
+// WILL_TIER, WILL_LLM, WILL_TICK_MS, WILL_SEED, WILL_PMA_PATH, WILL_MCP_SERVERS.
+//
+// MCP client config:
+//   { "command": "npx", "args": ["-y", "@mindot/will", "mcp"],
+//     "env": { "WILL_NAME": "Aria", "WILL_IDENTITY": "I am Aria." } }
+//
+// Sidecar:
+//   WILL_NAME=Aria will serve            # http://127.0.0.1:7777
+//   curl -X POST localhost:7777/perceive -d '{"text":"Hello"}'
+// ─────────────────────────────────────────────────────────────
+
+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'
+
+// stdout is the MCP protocol channel under `will mcp` — route logs FIRST.
+routeLogsToStderr()
+
+const USAGE = `usage: will <mcp | serve | discord>
+
+  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)
+
+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
+its PMA artifact.`
+
+async function main(): Promise<void> {
+  const sub = process.argv[2]
+
+  if( sub !== 'mcp' && sub !== 'serve' && sub !== 'discord' ){
+    console.error( sub ? `unknown subcommand: ${ sub }\n\n${ USAGE }` : USAGE )
+    process.exit( sub ? 2 : 0 )
+  }
+
+  // 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, 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
+  }
+
+  // serve — the HTTP sidecar.
+  const port = parseInt( process.env.WILL_PORT ?? '7777' )
+  const host = process.env.WILL_HOST ?? '127.0.0.1'
+  const server = buildWillHttpServer( will, { pmaPath } )
+  onCleanup( () => new Promise<void>( r => server.close( () => r() ) ) )
+  await new Promise<void>( ( resolve, reject ) => {
+    server.once( 'error', reject )
+    server.listen( port, host, () => resolve() )
+  } )
+  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"}'` )
+}
+
+main().catch( e => {
+  console.error( `[will] fatal: ${ e instanceof Error ? e.stack ?? e.message : String( e ) }` )
+  process.exit( 1 )
+} )

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
       }
     },