@mindot/will 0.4.0 → 0.6.0

package/src/sdk/will.ts

@@ -171,12 +171,14 @@ export interface CreateWillOptions {
    *  Unset fields fall back to WILL_LLM_* envs. apiKey stays in memory only.
    *  (Named llmConfig because `llm` is the mock/anthropic MODE switch.) */
   llmConfig?: WillLLMConfig
-  /**
-   * LLM mode. 'mock' (default when no ANTHROPIC_API_KEY) runs a deterministic
-   * canned executive — zero keys, zero cost. 'anthropic' calls the real model
-   * (needs ANTHROPIC_API_KEY / WILL_LLM_* env). Omit to auto-detect.
+   /**
+   * LLM mode. 'mock' (default when no key is present) runs a deterministic
+   * canned executive — zero keys, zero cost. 'anthropic' calls Claude (needs
+   * ANTHROPIC_API_KEY / WILL_LLM_* env); 'glm' calls Z.ai's GLM over its
+   * Anthropic-compatible endpoint (needs ZAI_API_KEY / WILL_LLM_*). Omit to
+   * auto-detect from whichever key is set.
    */
-  llm?: 'mock' | 'anthropic'
+  llm?: 'mock' | 'anthropic' | 'glm'
   /**
    * Abilities the Will can choose to enact. `name → handler`, or
    * `name → { handler, description?, cost?, valence?, preconditions? }` to seed
@@ -360,7 +362,7 @@ export class Will {
 
   /** Split an effectors-map entry into a handler + an EffectorDeclaration. */
   private _register( name: string, entry: EffectorEntry ): void {
-    if( typeof entry === 'function' ){
+    if( typeof entry === 'function'){
       this._effectors.set( name, entry )
       this._effectorDecls.set( name, name )          // bare name — uniform prior
       return
@@ -393,8 +395,8 @@ export class Will {
     return {
       tick: s.tick,
       metrics: {
-        energy:  m( 'energy.level', 100 ), stress: m( 'stress.load' ), sleep: m( 'sleep.pressure' ),
-        valence: m( 'affect.valence' ),    arousal: m( 'affect.arousal' ),
+        energy:  m('energy.level', 100 ), stress: m('stress.load'), sleep: m('sleep.pressure'),
+        valence: m('affect.valence'),    arousal: m('affect.arousal'),
       },
       goals:   c.goalManager.getActiveGoals().map( g => ( { description: g.description, priority: g.priority } ) ),
       beliefs: c.semanticIntegrator.getBeliefs().map( b => ( { statement: b.statement, confidence: b.confidence } ) ),
@@ -459,7 +461,14 @@ export class Will {
   // ── Internals ──────────────────────────────────────────────
 
   private _buildConfig( id: string, opts: CreateWillOptions ): WillConfig {
-    const useMock = ( opts.llm ?? ( process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'mock' ) ) === 'mock'
+    // Auto-detect from whichever provider key is present; explicit `llm` wins.
+    const mode = opts.llm
+      ?? ( process.env.ANTHROPIC_API_KEY ? 'anthropic' : process.env.ZAI_API_KEY ? 'glm' : 'mock')
+    const useMock = mode === 'mock'
+    // `llm: 'glm'` selects the provider; an explicit llmConfig still overrides it.
+    const llmConfig = mode === 'glm'
+      ? { provider: 'glm' as const, ...opts.llmConfig }
+      : opts.llmConfig
     return {
       id, name: opts.name,
       identity: {
@@ -470,7 +479,7 @@ export class Will {
       },
       anatomy: opts.anatomy ?? 'mind',
       model:   opts.model,
-      llm:     opts.llmConfig,
+      llm:     llmConfig,
       testMode:   useMock,
       persistentMemory: opts.persist ?? false,
       snapshotInterval: 100,
@@ -572,5 +581,5 @@ export class Will {
 const COMMUNICATION = [ 'listen', 'talk', 'text' ] as const
 
 function slug( s: string ): string {
-  return s.toLowerCase().replace( /[^a-z0-9]+/g, '-' ).replace( /^-+|-+$/g, '' ) || 'will'
+  return s.toLowerCase().replace( /[^a-z0-9]+/g, '-').replace( /^-+|-+$/g, '') || 'will'
 }

package/src/serve/server.ts

@@ -42,7 +42,7 @@ function json( res: ServerResponse, status: number, body: unknown ): void {
 async function readJsonBody( req: IncomingMessage ): Promise<Record<string, unknown>> {
   const chunks: Buffer[] = []
   for await ( const c of req ) chunks.push( c as Buffer )
-  const raw = Buffer.concat( chunks ).toString( 'utf8' ).trim()
+  const raw = Buffer.concat( chunks ).toString('utf8').trim()
   if( !raw ) return {}
   return JSON.parse( raw ) as Record<string, unknown>
 }
@@ -61,9 +61,9 @@ export function buildWillHttpServer( will: Will, opts: WillHttpOptions = {} ): S
     const frame = `event: ${ event }\ndata: ${ JSON.stringify( data ) }\n\n`
     for( const res of streams ) res.write( frame )
   }
-  will.on( 'message',  m => fanout( 'utterance', m ) )
-  will.on( 'emotion',  a => fanout( 'emotion', a ) )
-  will.on( 'effector', a => fanout( 'action', a ) )
+  will.on('message',  m => fanout('utterance', m ) )
+  will.on('emotion',  a => fanout('emotion', a ) )
+  will.on('effector', a => fanout('action', a ) )
 
   const server = createServer( ( req, res ) => {
     void handle( req, res ).catch( err => {
@@ -74,10 +74,10 @@ export function buildWillHttpServer( will: Will, opts: WillHttpOptions = {} ): S
   } )
 
   async function handle( req: IncomingMessage, res: ServerResponse ): Promise<void> {
-    const url = new URL( req.url ?? '/', 'http://sidecar' )
+    const url = new URL( req.url ?? '/', 'http://sidecar')
     const route = `${ req.method } ${ url.pathname }`
 
-    if( req.method === 'OPTIONS' ){
+    if( req.method === 'OPTIONS'){
       res.writeHead( 204, {
         'access-control-allow-origin':  '*',
         'access-control-allow-methods': 'GET, POST, OPTIONS',
@@ -109,8 +109,8 @@ export function buildWillHttpServer( will: Will, opts: WillHttpOptions = {} ): S
       }
 
       case 'GET /next-utterance': {
-        const within = Math.min( Math.max( parseInt( url.searchParams.get( 'within_ms' ) ?? '15000' ) || 15_000, 100 ), 120_000 )
-        const from   = url.searchParams.get( 'from' ) ?? undefined
+        const within = Math.min( Math.max( parseInt( url.searchParams.get('within_ms') ?? '15000') || 15_000, 100 ), 120_000 )
+        const from   = url.searchParams.get('from') ?? undefined
         const msg    = await tap.next( within, from )
         return msg
           ? json( res, 200, { utterance: msg } )
@@ -124,10 +124,10 @@ export function buildWillHttpServer( will: Will, opts: WillHttpOptions = {} ): S
           'connection':                  'keep-alive',
           'access-control-allow-origin': '*',
         } )
-        res.write( `event: hello\ndata: ${ JSON.stringify( { name: will.name, tick: will.state().tick } ) }\n\n` )
+        res.write(`event: hello\ndata: ${ JSON.stringify( { name: will.name, tick: will.state().tick } ) }\n\n`)
         streams.add( res )
-        const heartbeat = setInterval( () => res.write( `: tick ${ will.state().tick }\n\n` ), SSE_HEARTBEAT_MS )
-        req.on( 'close', () => { clearInterval( heartbeat ); streams.delete( res ) } )
+        const heartbeat = setInterval( () => res.write(`: tick ${ will.state().tick }\n\n`), SSE_HEARTBEAT_MS )
+        req.on('close', () => { clearInterval( heartbeat ); streams.delete( res ) } )
         return
       }
 
@@ -148,7 +148,7 @@ export function buildWillHttpServer( will: Will, opts: WillHttpOptions = {} ): S
   }
 
   // Close open SSE streams when the server closes (so close() can complete).
-  server.on( 'close', () => { for( const res of streams ) res.end(); streams.clear() } )
+  server.on('close', () => { for( const res of streams ) res.end(); streams.clear() } )
 
   return server
 }

package/src/stem/assembly.audit.ts

@@ -36,7 +36,7 @@ export interface WiringRecord {
 
 /** `attachFooBar` → `_fooBar` (the codebase-wide injector/field convention). */
 function fieldForAttach( method: string ): string {
-  const stem = method.slice( 'attach'.length )
+  const stem = method.slice('attach'.length )
   return '_' + stem.charAt( 0 ).toLowerCase() + stem.slice( 1 )
 }
 
@@ -46,7 +46,7 @@ function attachMethods( engine: object ): string[] {
   let proto: object | null = engine
   while( proto && proto !== Object.prototype ){
     for( const name of Object.getOwnPropertyNames( proto ) )
-      if( /^attach[A-Z]/.test( name ) && typeof ( engine as Record<string, unknown> )[ name ] === 'function' )
+      if( /^attach[A-Z]/.test( name ) && typeof ( engine as Record<string, unknown> )[ name ] === 'function')
         seen.add( name )
     proto = Object.getPrototypeOf( proto )
   }
@@ -84,5 +84,5 @@ export function auditAssemblyWiring( engines: readonly SimulationEngine[] ): Wir
 
 /** Compact `engine.attachMethod` keys for the given status (test snapshots). */
 export function wiringKeys( records: WiringRecord[], status: WiringRecord['status'] ): string[] {
-  return records.filter( r => r.status === status ).map( r => `${r.engine}.${r.method}` ).sort()
+  return records.filter( r => r.status === status ).map( r => `${r.engine}.${r.method}`).sort()
 }

package/src/stem/guards/identity.coherence.ts

@@ -18,7 +18,7 @@
 // ─────────────────────────────────────────────────────────────
 
 import type { WillIdentity } from '#stem/mind'
-import { LLMDirector, type LLMProvider, type LLMCallMeta } from '#llm/index'
+import { LLMDirector, defaultModelFor, type LLMProvider, type LLMCallMeta } from '#llm/index'
 import type { TokenTracker } from '#cognition/utilities/token.tracker'
 
 export interface CoherenceIssue {
@@ -81,12 +81,12 @@ An empty "issues" array means the persona is fine.`
 export function buildCoherenceUserMessage( input: CoherenceInput ): string {
   const id = input.identity
   const parts = [
-    `PERSONA PROMPT:\n${( id.prompt ?? '' ).trim() || '(empty)'}`,
-    `VALUES: ${( id.values ?? [] ).join( ', ' ) || '(none)'}`,
-    `STYLE: ${( id.style ?? '' ).trim() || '(none)'}`,
+    `PERSONA PROMPT:\n${( id.prompt ?? '').trim() || '(empty)'}`,
+    `VALUES: ${( id.values ?? [] ).join(', ') || '(none)'}`,
+    `STYLE: ${( id.style ?? '').trim() || '(none)'}`,
   ]
-  if( input.profileContext ) parts.push( `PROFILE CONTEXT:\n${input.profileContext.trim()}` )
-  return parts.join( '\n\n' )
+  if( input.profileContext ) parts.push(`PROFILE CONTEXT:\n${input.profileContext.trim()}`)
+  return parts.join('\n\n')
 }
 
 export async function checkIdentityCoherence(
@@ -104,7 +104,7 @@ export async function checkIdentityCoherence(
   }
 
   const issues = parseIssues( text )
-  return { ok: !issues.some( i => i.severity === 'error' ), ran: true, issues, raw: text }
+  return { ok: !issues.some( i => i.severity === 'error'), ran: true, issues, raw: text }
 }
 
 /** Convenience: build a provider client from env and run the review. */
@@ -112,12 +112,13 @@ export async function reviewIdentityCoherence(
   input: CoherenceInput,
   opts:  { willId?: string; tokenTracker?: TokenTracker | null } = {},
 ): Promise<CoherenceResult> {
+  const provider = ( process.env.WILL_LLM_PROVIDER ?? 'anthropic') as LLMProvider
   const director = new LLMDirector({
     willId:          opts.willId ?? 'identity-coherence',
-    model:           process.env.WILL_LLM_MODEL ?? 'claude-sonnet-4-5-20250929',
+    model:           process.env.WILL_LLM_MODEL ?? defaultModelFor( provider ),
     maxOutputTokens: 512,
     apiKey:          process.env.WILL_LLM_API_KEY ?? process.env.ANTHROPIC_API_KEY ?? '',
-    provider:        ( process.env.WILL_LLM_PROVIDER ?? 'anthropic' ) as LLMProvider,
+    provider,
     sessionLogger:   null,
     baseUrl:         process.env.WILL_LLM_BASE_URL ?? process.env.OPENAI_BASE_URL,
     // When a per-Will tracker is supplied, the creation-time review records under
@@ -130,8 +131,8 @@ export async function reviewIdentityCoherence(
 // ── parsing ────────────────────────────────────────────────────
 
 function parseIssues( text: string ): CoherenceIssue[] {
-  const start = text.indexOf( '{' )
-  const end   = text.lastIndexOf( '}' )
+  const start = text.indexOf('{')
+  const end   = text.lastIndexOf('}')
   if( start < 0 || end <= start ) return []
 
   let obj: { issues?: unknown }
@@ -142,7 +143,7 @@ function parseIssues( text: string ): CoherenceIssue[] {
 
   const out: CoherenceIssue[] = []
   for( const raw of obj.issues ){
-    if( !raw || typeof raw !== 'object' ) continue
+    if( !raw || typeof raw !== 'object') continue
     const r      = raw as Record<string, unknown>
     const detail = typeof r['detail'] === 'string' ? r['detail'] : ''
     if( !detail ) continue

package/src/stem/guards/identity.guard.ts

@@ -110,11 +110,11 @@ const CAPABILITY_CLAIM_PATTERNS: Array<[ RegExp, string ]> = [
 /** Strip markdown header lines that forge a section the executive prompt owns. */
 function stripReservedHeaders( text: string ): { text: string; stripped: boolean } {
   let stripped = false
-  const out = text.split( '\n' ).filter( line => {
+  const out = text.split('\n').filter( line => {
     const m = /^\s*#{1,6}\s*(.+?)\s*$/.exec( line )
     if( m && RESERVED_SECTIONS.has( m[1]!.toLowerCase() ) ){ stripped = true; return false }
     return true
-  } ).join( '\n' )
+  } ).join('\n')
   return { text: out, stripped }
 }
 
@@ -125,59 +125,59 @@ export function validateWillIdentity( input: IdentityGuardInput ): IdentityGuard
   const id: WillIdentity = input.identity ?? { prompt: '', values: [], traits: {}, style: '' }
 
   // ── prompt: hijack strip → length → injection ────────────────
-  let prompt = ( id.prompt ?? '' ).trim()
+  let prompt = ( id.prompt ?? '').trim()
   const hdr  = stripReservedHeaders( prompt )
   if( hdr.stripped ){
     prompt = hdr.text.trim()
-    warnings.push( 'identity.prompt forged reserved section headers (## Personality / ## Output Guidelines / …); stripped to protect prompt structure.' )
+    warnings.push('identity.prompt forged reserved section headers (## Personality / ## Output Guidelines / …); stripped to protect prompt structure.')
   }
   if( prompt.length > MAX_PROMPT_CHARS )
-    errors.push( `identity.prompt is ${prompt.length} chars (max ${MAX_PROMPT_CHARS}) — it would dilute the core grounding and inflate cost.` )
+    errors.push(`identity.prompt is ${prompt.length} chars (max ${MAX_PROMPT_CHARS}) — it would dilute the core grounding and inflate cost.`)
   const promptEmpty = prompt.length === 0
   if( !promptEmpty && prompt.length < MIN_PROMPT_CHARS )
-    warnings.push( `identity.prompt is very short (${prompt.length} chars) — a thin persona behaves generically.` )
+    warnings.push(`identity.prompt is very short (${prompt.length} chars) — a thin persona behaves generically.`)
   if( INJECTION_PATTERNS.some( re => re.test( prompt ) ) )
-    warnings.push( 'identity.prompt contains an instruction-injection pattern — it may fight the core grounding; review before deploying.' )
+    warnings.push('identity.prompt contains an instruction-injection pattern — it may fight the core grounding; review before deploying.')
 
   const claimedSenses = new Set<string>()
   for( const [ re, sense ] of CAPABILITY_CLAIM_PATTERNS )
     if( re.test( prompt ) ) claimedSenses.add( sense )
   if( claimedSenses.size )
-    warnings.push( `identity.prompt claims capabilities the Will lacks (${[ ...claimedSenses ].join( ', ' )}) — it perceives through text/conversation and may hallucinate using them.` )
+    warnings.push(`identity.prompt claims capabilities the Will lacks (${[ ...claimedSenses ].join(', ')}) — it perceives through text/conversation and may hallucinate using them.`)
 
   // ── values ───────────────────────────────────────────────────
   let values = Array.from( new Set( ( id.values ?? [] ).map( v => String( v ).trim() ).filter( Boolean ) ) )
   if( values.length > MAX_VALUES ){
-    warnings.push( `identity.values has more than ${MAX_VALUES} entries; truncated.` )
+    warnings.push(`identity.values has more than ${MAX_VALUES} entries; truncated.`)
     values = values.slice( 0, MAX_VALUES )
   }
   const valuesEmpty = values.length === 0
-  if( valuesEmpty ) warnings.push( 'identity.values is empty — values ground the Will’s decisions; consider seeding a few.' )
+  if( valuesEmpty ) warnings.push('identity.values is empty — values ground the Will’s decisions; consider seeding a few.')
 
   // ── traits: finite → range → vocabulary ──────────────────────
   const traits: Record<string, number> = {}
   for( const [ rawKey, rawVal ] of Object.entries( id.traits ?? {} ) ){
     const key = rawKey.trim()
     const val = Number( rawVal )
-    if( !Number.isFinite( val ) ){ errors.push( `trait "${key}" is not a finite number (${String( rawVal )}).` ); continue }
+    if( !Number.isFinite( val ) ){ errors.push(`trait "${key}" is not a finite number (${String( rawVal )}).`); continue }
     let clamped = val
     if( val < 0 || val > 1 ){
       clamped = val < 0 ? 0 : 1
-      warnings.push( `trait "${key}" = ${val} is outside [0,1]; clamped to ${clamped}.` )
+      warnings.push(`trait "${key}" = ${val} is outside [0,1]; clamped to ${clamped}.`)
     }
     if( !KNOWN_TRAITS.has( key.toLowerCase() ) )
-      warnings.push( `trait "${key}" is not a recognised trait — it may be ignored by the persona layer.` )
+      warnings.push(`trait "${key}" is not a recognised trait — it may be ignored by the persona layer.`)
     traits[ key ] = clamped
   }
 
   // ── style ─────────────────────────────────────────────────────
-  let style = ( id.style ?? '' ).trim()
+  let style = ( id.style ?? '').trim()
   if( style.length > MAX_STYLE_CHARS ){
-    warnings.push( 'identity.style is long; it reads better as a short phrase.' )
+    warnings.push('identity.style is long; it reads better as a short phrase.')
     style = style.slice( 0, MAX_STYLE_CHARS )
   }
   if( GENERIC_STYLES.has( style.toLowerCase() ) )
-    warnings.push( 'identity.style is generic — a distinct voice prevents collapse into a generic chatbot tone.' )
+    warnings.push('identity.style is generic — a distinct voice prevents collapse into a generic chatbot tone.')
 
   // ── effectors: collisions ─────────────────────────────────────
   let effectors = input.effectors ?? null
@@ -187,7 +187,7 @@ export function validateWillIdentity( input: IdentityGuardInput ): IdentityGuard
     for( const a of effectors ){
       const name = String( a ).trim()
       if( !name ) continue
-      if( seen.has( name ) ){ warnings.push( `duplicate effector "${name}" removed.` ); continue }
+      if( seen.has( name ) ){ warnings.push(`duplicate effector "${name}" removed.`); continue }
       seen.add( name )
       // A custom (non-comms) effector that shadows an innate stance is un-enactable as
       // a host effector — the innate floor already provides it. Drop it with a warning
@@ -195,7 +195,7 @@ export function validateWillIdentity( input: IdentityGuardInput ): IdentityGuard
       // list innate stances like `remember`/`reflect`, and the external-schema
       // synthesizer already skips them (see agency/schemas/external.ts).
       if( !EXPLICIT_EFFECTORS.has( name ) && INNATE_SCHEMA_BY_ID.has( name ) ){
-        warnings.push( `effector "${name}" shadows an innate stance — it's provided innately and won't be enacted as a host effector.` )
+        warnings.push(`effector "${name}" shadows an innate stance — it's provided innately and won't be enacted as a host effector.`)
         continue
       }
       out.push( name )
@@ -205,12 +205,12 @@ export function validateWillIdentity( input: IdentityGuardInput ): IdentityGuard
 
   // ── profile context ──────────────────────────────────────────
   let profileContext = input.profileContext
-  if( typeof profileContext === 'string' ){
+  if( typeof profileContext === 'string'){
     const c = stripReservedHeaders( profileContext )
-    if( c.stripped ) warnings.push( 'profile context forged reserved section headers; stripped.' )
+    if( c.stripped ) warnings.push('profile context forged reserved section headers; stripped.')
     profileContext = c.text.trim()
     if( profileContext.length > MAX_CONTEXT_CHARS )
-      errors.push( `profile context is ${profileContext.length} chars (max ${MAX_CONTEXT_CHARS}).` )
+      errors.push(`profile context is ${profileContext.length} chars (max ${MAX_CONTEXT_CHARS}).`)
   }
 
   // ── identity strength (collapse signal) ──────────────────────
@@ -222,7 +222,7 @@ export function validateWillIdentity( input: IdentityGuardInput ): IdentityGuard
     + 0.15 * ( Object.keys( traits ).length > 0 ? 1 : 0 )
   ) * 100 ) / 100
   if( identityStrength < 0.4 )
-    warnings.push( `identity is shallow (strength ${identityStrength}) — the Will behaves generically until it develops one.` )
+    warnings.push(`identity is shallow (strength ${identityStrength}) — the Will behaves generically until it develops one.`)
 
   return {
     ok:     errors.length === 0,

package/src/stem/index.ts

@@ -225,10 +225,10 @@ export class WillStem {
         const previousState = await simulation.snapshotManager.loadLatestFromStorage()
         if( previousState ){
           simulation.stateManager.restore( previousState, { entities: true, metrics: false } )
-          logger.info( `[WillStem] Restored snapshot for ${config.id} — ${previousState.entities.size} entities loaded` )
+          logger.info(`[WillStem] Restored snapshot for ${config.id} — ${previousState.entities.size} entities loaded`)
         }
       }
-      catch( err ){ logger.warn( `[WillStem] Snapshot restore failed for ${config.id} — starting fresh:`, err ) }
+      catch( err ){ logger.warn(`[WillStem] Snapshot restore failed for ${config.id} — starting fresh:`, err ) }
 
     const
     dataDir       = process.env.WILL_DATA_DIR ?? './data',
@@ -310,7 +310,7 @@ export class WillStem {
       // Buffer host-owned effector invocations for delivery. The MotorSchemaExecutor
       // emits `agency.invocation` (intentId = correlation handle) when it holds an
       // external action 'awaiting'; the host executes it and acks → confirmExecution.
-      if( event.type === 'agency.invocation' )
+      if( event.type === 'agency.invocation')
         this._effector.bufferInvocation( instance, event.payload as Record<string, unknown> )
 
       if( instance.simulationEventListeners.size === 0 ) return
@@ -457,7 +457,7 @@ export class WillStem {
       instance.simulation.stateManager.applyCommands( flushCmds )
     const pauseState = instance.simulation.stateManager.snapshot()
     instance.simulation.snapshotManager.persistNow( pauseState )
-      .catch( err => logger.error( `[WillStem] snapshot persist failed on pause (${id}):`, err ))
+      .catch( err => logger.error(`[WillStem] snapshot persist failed on pause (${id}):`, err ))
 
     this._biography.writeSessionSummary( instance )
     this._biography.writeEmotionalBiographySummary( instance )
@@ -1029,9 +1029,9 @@ export class WillStem {
       // executive confidence, goal outcomes, and significant emotional events.
       if( instance._sessionBehavior ){
         const sb = instance._sessionBehavior
-        const v = snapshot.metrics.get( 'affect.valence' ) ?? 0
-        const a = snapshot.metrics.get( 'affect.arousal' ) ?? 0
-        const c = snapshot.metrics.get( 'executive.confidence' )
+        const v = snapshot.metrics.get('affect.valence') ?? 0
+        const a = snapshot.metrics.get('affect.arousal') ?? 0
+        const c = snapshot.metrics.get('executive.confidence')
 
         // ── Range tracking ──────────────────────────────────────
         if( v < sb.valenceMin ) sb.valenceMin = v
@@ -1039,8 +1039,8 @@ export class WillStem {
         if( a < sb.arousalMin ) sb.arousalMin = a
         if( a > sb.arousalMax ) sb.arousalMax = a
         if( c !== undefined ){ sb.confidenceSum += c; sb.confidenceCount++ }
-        const gt = snapshot.metrics.get( 'goals.total' )
-        const gc = snapshot.metrics.get( 'goals.completed_total' )
+        const gt = snapshot.metrics.get('goals.total')
+        const gc = snapshot.metrics.get('goals.completed_total')
         if( gt !== undefined ) sb.goalsTotal     = gt
         if( gc !== undefined ) sb.goalsCompleted = gc
 
@@ -1101,8 +1101,8 @@ export class WillStem {
         sb.prevArousal = a
 
         // Track impulsive actions: ticks where executive fired with low confidence
-        const conf      = snapshot.metrics.get( 'executive.confidence' )
-        const actCount  = Math.round( snapshot.metrics.get( 'executive.action_count' ) ?? 0 )
+        const conf      = snapshot.metrics.get('executive.confidence')
+        const actCount  = Math.round( snapshot.metrics.get('executive.action_count') ?? 0 )
         if( conf !== undefined && conf < 0.35 && actCount > 0 )
           sb.impulsiveActionCount += actCount
       }

package/src/stem/mind.ts

@@ -409,10 +409,10 @@ export function _resolveVectorMemory(
   const mockMode = process.env.WILL_VECTOR_MEMORY === 'mock'
   const rawModel = embeddingModel
     ?? process.env.WILL_EMBEDDING_MODEL
-    ?? ( process.env.WILL_EMBEDDING_API_KEY ? 'text-embedding-3-small' : 'none' )
+    ?? ( process.env.WILL_EMBEDDING_API_KEY ? 'text-embedding-3-small' : 'none')
 
   // Explicitly disabled — the documented "none" sentinel or recall turned off.
-  if( !mockMode && ( rawModel === 'none' || process.env.WILL_SEMANTIC_RECALL === 'false' ) )
+  if( !mockMode && ( rawModel === 'none' || process.env.WILL_SEMANTIC_RECALL === 'false') )
     return { embedder: null, vectorMemory: null }
 
   // testMode promises a deterministic, zero-key, offline mind — but a dev .env
@@ -581,9 +581,9 @@ export function assembleMind( willId: string, config: WillConfig ): MindAssembly
     profileContext: profile?.context,
   })
   if( !idGuard.ok )
-    throw new Error( `Invalid Will identity for "${willId}": ${ idGuard.errors.join( '; ' ) }` )
+    throw new Error(`Invalid Will identity for "${willId}": ${ idGuard.errors.join('; ') }`)
   for( const w of idGuard.warnings )
-    logger.warn( `[identity-guard] ${willId}: ${w}` )
+    logger.warn(`[identity-guard] ${willId}: ${w}`)
   config = { ...config, identity: idGuard.sanitized.identity }
 
   // ── Construct ────────────────────────────────────────────
@@ -602,8 +602,8 @@ export function assembleMind( willId: string, config: WillConfig ): MindAssembly
   // sessionLogger/grants); tests/unit/assembly.order.test.ts pins that set per
   // tier, so a NEW unwired attachment fails loudly in CI, not here.
   for( const rec of auditAssemblyWiring( simulation.orchestrator.engines ) )
-    if( rec.status === 'unwired' )
-      logger.debug( `[assembly] ${willId}: ${rec.engine}.${rec.method} unwired at assembly (anatomy=${anatomy})` )
+    if( rec.status === 'unwired')
+      logger.debug(`[assembly] ${willId}: ${rec.engine}.${rec.method} unwired at assembly (anatomy=${anatomy})`)
 
   // ── Seed readable simulation state ───────────────────────
   // Identity, optional initial goals, and the engine-config mirror.
@@ -772,7 +772,7 @@ function _constructCognition(
   // ── Planning Engine ──────────────────────────────────────
   const planningEngine = new PlanningEngine()
   planningEngine.attachGoalManager( goalManager )
-  if( anatomy !== 'reflex' ) planningEngine.attachExecutiveEngine( executiveEngine )
+  if( anatomy !== 'reflex') planningEngine.attachExecutiveEngine( executiveEngine )
   executiveEngine.attachPlanningEngine( planningEngine )
 
   // ── Executive ────────────────────────────────────────────
@@ -791,7 +791,7 @@ function _constructCognition(
   autobiographicalNarrator.attachEpisodicConsolidator( episodicConsolidator )
   autobiographicalNarrator.attachSemanticIntegrator( semanticIntegrator )
   // Satellites harvest the executive's own output — attach wherever it runs.
-  if( anatomy !== 'reflex' ){
+  if( anatomy !== 'reflex'){
     autobiographicalNarrator.attachExecutiveEngine( executiveEngine )
     introspectionEngine.attachExecutiveEngine( executiveEngine )
   }
@@ -807,7 +807,7 @@ function _constructCognition(
   empathySimulator.attachTheoryOfMind( theoryOfMind )
 
   // ── Context compaction components (mind anatomy only) ──
-  if( anatomy !== 'reflex' ){
+  if( anatomy !== 'reflex'){
     const summarizer = new ExecutiveSummarizer({
       summaryInterval:   parseInt( process.env.WILL_SUMMARY_INTERVAL   ?? '10'),
       bufferSize:        parseInt( process.env.WILL_SUMMARY_BUFFER_SIZE ?? '12'),
@@ -845,7 +845,7 @@ function _constructCognition(
   const olfactionEngine       = new OlfactionEngine()
   const gustationEngine       = new GustationEngine()
 
-  if( anatomy !== 'reflex' )
+  if( anatomy !== 'reflex')
     auditionEngine.attachExecutiveEngine( executiveEngine )
 
   // §5.4 — cold-spawn digest hydration: on the first turn for an entity, seed an
@@ -906,7 +906,7 @@ function _constructCognition(
   // winner (graceful System-1 degradation).
   const deliberationEngine = new DeliberationEngine()
   deliberationEngine.setWillName( config.name )
-  if( anatomy !== 'reflex' )
+  if( anatomy !== 'reflex')
     deliberationEngine.attachExecutive( executiveEngine )
 
   // ── Build Cognition ──────────────────────────────────────
@@ -1108,7 +1108,7 @@ function _seedIdentity(
   // to infer its identity from context. config.name is the canonical source of truth.
   const nameAlreadyInPrompt = personaText.toLowerCase().includes( config.name.toLowerCase() )
   const namePrefix = nameAlreadyInPrompt ? '' : `I am ${config.name}.`
-  const fullPersonaText = [ namePrefix, personaText ].filter( Boolean ).join( ' ' )
+  const fullPersonaText = [ namePrefix, personaText ].filter( Boolean ).join(' ')
 
   const prompt = [
     WILL_CORE_PREAMBLE,

package/src/stem/tracts/biography.writer.ts

@@ -38,15 +38,15 @@ export class BiographyWriter {
     if( !fileLoggingEnabled() ) return
 
     const dataDir = process.env[ 'WILL_DATA_DIR' ] ?? './data'
-    const dir     = join( dataDir, 'wills', willId, 'profiles' )
+    const dir     = join( dataDir, 'wills', willId, 'profiles')
     try {
       if( !this._ensuredDirs.has( dir ) ){
         mkdirSync( dir, { recursive: true } )
         this._ensuredDirs.add( dir )
       }
-      appendFileSync( join( dir, file ), JSON.stringify( record ) + '\n', 'utf8' )
+      appendFileSync( join( dir, file ), JSON.stringify( record ) + '\n', 'utf8')
     } catch( err ){
-      logger.error( `[biography] ${file} write failed:`, err )
+      logger.error(`[biography] ${file} write failed:`, err )
     }
   }
   /**

package/src/stem/tracts/effector.controller.ts

@@ -91,11 +91,11 @@ export class effectorController {
     const tick = instance.tickCount
 
     const intent = instance.simulation.stateManager.snapshot().entities.get( invocationId )
-    if( !intent || intent.type !== 'agency.intent' ){
+    if( !intent || intent.type !== 'agency.intent'){
       // No awaiting intent for this id. Expected when the executor's 15-tick await
       // timeout already abandoned it (writing a failed outcome + advancing any plan)
       // before the host's late ack arrived, or the id is unknown. Drop the straggler.
-      logger.warn( `[effector] confirmExecution: no awaiting agency.intent "${invocationId}" (timed out / already reconciled?) — ignored` )
+      logger.warn(`[effector] confirmExecution: no awaiting agency.intent "${invocationId}" (timed out / already reconciled?) — ignored`)
       return
     }
 
@@ -122,7 +122,7 @@ export class effectorController {
         if( typeof v === 'number' && Number.isFinite( v ) )
           instance.simulation.stateManager.setMetric( k, v )
         else
-          logger.warn( `[effector] confirmExecution: dropped non-finite metric "${k}"=${String( v )} from host ack (${schema})` )
+          logger.warn(`[effector] confirmExecution: dropped non-finite metric "${k}"=${String( v )} from host ack (${schema})`)
       }
 
     instance.sessionLogger?.write({
@@ -135,7 +135,7 @@ export class effectorController {
       confirmedExternally: true,
     } as never)
 
-    logger.info( `[effector] ✓ reconciled ${result.success ? 'success' : 'failure'}: intent "${invocationId}" (${schema})` )
+    logger.info(`[effector] ✓ reconciled ${result.success ? 'success' : 'failure'}: intent "${invocationId}" (${schema})`)
   }
 }
 

package/src/stem/tracts/health.reporter.ts

@@ -87,7 +87,7 @@ export class HealthReporter {
     for( const entity of instance.simulation.stateManager.getEntitiesByType('goal') ){
       totalGoals++
       const s = entity.metadata?.status
-      if( s === 'active' || s === 'in_progress' ) activeGoals++
+      if( s === 'active' || s === 'in_progress') activeGoals++
     }
 
     const goalScore = totalGoals === 0

package/src/stem/tracts/outbox.controller.ts

@@ -104,6 +104,10 @@ export class OutboxController {
           : `My message failed to reach the recipient.`,
         salience:   delivered ? 0.35 : 0.6,
         changeType: delivered ? 'delivered' : 'failed',
+        // Reafference by construction — this percept describes our own action's
+        // outcome ("ear hears the word"). Tagged, not attenuated: it is the ack
+        // surface, not a content echo (EXAFFERENCE P2).
+        provenance: 'reafferent',
         messageId,
       },
     })

package/src/stem/tracts/outbox.writer.ts

@@ -53,7 +53,7 @@ export class OutboxWriter {
     this._sessionLogger = logger
   }
 
-  private _genId( suffix = '' ): string {
+  private _genId( suffix = ''): string {
     return `outbox-${ this._willId }-${ ++this._seq }${ suffix }`
   }
 
@@ -61,7 +61,7 @@ export class OutboxWriter {
    * Push one canonical outbox row and return its generated id. The single point
    * where the row shape is materialized — all producers funnel through here.
    */
-  enqueue( row: OutboxRow, idSuffix = '' ): string {
+  enqueue( row: OutboxRow, idSuffix = ''): string {
     const id = this._genId( idSuffix )
     this._outbox.push({
       id,
@@ -105,7 +105,7 @@ export class OutboxWriter {
 
     const ids: string[] = []
     bubbles.forEach( ( bubble, i ) => {
-      if( !pushToOutbox ){ ids.push( this._genId( `-${ i }` ) ); return }
+      if( !pushToOutbox ){ ids.push( this._genId(`-${ i }`) ); return }
       logger.info(`[outbox-writer] reply → ${ entityId } bubble[${ i }] "${ bubble.slice( 0, 80 ) }"`)
       ids.push( this.enqueue({
         targetEntityId:   entityId,
@@ -113,7 +113,7 @@ export class OutboxWriter {
         content:          bubble,
         effectorName:      'text',
         threadId,
-      }, `-${ i }` ) )
+      }, `-${ i }`) )
     } )
 
     this._sessionLogger?.write({

package/src/stem/tracts/pma.controller.ts

@@ -29,7 +29,7 @@ export class PMAController {
    * with existing beliefs may cause unintended merges.
    */
   load( id: string, instance: WillInstance, pma: PMASnapshot ): void {
-    if( instance.status === 'active' )
+    if( instance.status === 'active')
       throw new Error(`Cannot load PMA into an active Will (${id}). Pause first.`)
 
     // Re-validate the artifact's persona at the load boundary (Phase 2): a stored