@mindot/will 0.5.0 → 0.7.0

package/src/cognition/memory/vector.embedder.ts

@@ -68,10 +68,10 @@ export class OpenAICompatibleEmbedder implements EmbeddingProvider {
     this._tokenTracker = config.tokenTracker ?? null
   }
 
-  async embed( content: unknown, fn: string = 'recall' ): Promise<number[]> {
+  async embed( content: unknown, fn: string = 'recall'): Promise<number[]> {
     let response: Response
     try {
-      response = await fetch( `${this._apiUrl}/embeddings`, {
+      response = await fetch(`${this._apiUrl}/embeddings`, {
         method: 'POST',
         headers: {
           'Content-Type': 'application/json',
@@ -87,13 +87,13 @@ export class OpenAICompatibleEmbedder implements EmbeddingProvider {
     }
     catch( err ){
       // AbortSignal.timeout rejects with a DOMException named 'TimeoutError'.
-      if( err instanceof Error && err.name === 'TimeoutError' )
-        throw new Error( `Embedding request timed out after ${this._timeoutMs}ms` )
+      if( err instanceof Error && err.name === 'TimeoutError')
+        throw new Error(`Embedding request timed out after ${this._timeoutMs}ms`)
       throw err
     }
 
     if( !response.ok )
-      throw new Error( `Embedding failed: ${response.status} ${response.statusText}` )
+      throw new Error(`Embedding failed: ${response.status} ${response.statusText}`)
 
     const data = await response.json() as {
       data?:  Array<{ embedding?: number[] }>
@@ -104,7 +104,7 @@ export class OpenAICompatibleEmbedder implements EmbeddingProvider {
     // opaque TypeError on an empty/malformed body (FN16).
     const embedding = data?.data?.[ 0 ]?.embedding
     if( !Array.isArray( embedding ) || embedding.length === 0 )
-      throw new Error( `Embedding response was empty or malformed for model ${this.modelName}` )
+      throw new Error(`Embedding response was empty or malformed for model ${this.modelName}`)
 
     // Meter embedding token usage (input-only — embeddings have no completion).
     // Recorded under the 'embedding' category so per-Will dashboards can split
@@ -128,7 +128,7 @@ export class OpenAICompatibleEmbedder implements EmbeddingProvider {
     return embedding
   }
 
-  async embedBatch( contents: unknown[], fn: string = 'index' ): Promise<number[][]> {
+  async embedBatch( contents: unknown[], fn: string = 'index'): Promise<number[][]> {
     // Bounded fan-out: cap concurrent requests at _maxConcurrency instead of
     // firing all of them at once (FN16), while preserving input order.
     const results: number[][] = new Array( contents.length )
@@ -170,7 +170,7 @@ export class MockEmbedder implements EmbeddingProvider {
     this._seed = seed
   }
 
-  async embed( content: unknown, _fn: string = 'recall' ): Promise<number[]> {
+  async embed( content: unknown, _fn: string = 'recall'): Promise<number[]> {
     const str = typeof content === 'string' ? content : JSON.stringify( content )
     const hash = this._hashString( str )
     const embedding: number[] = []
@@ -184,7 +184,7 @@ export class MockEmbedder implements EmbeddingProvider {
     return embedding
   }
 
-  async embedBatch( contents: unknown[], fn: string = 'index' ): Promise<number[][]> {
+  async embedBatch( contents: unknown[], fn: string = 'index'): Promise<number[][]> {
     return Promise.all( contents.map( c => this.embed( c, fn ) ) )
   }
 

package/src/cognition/persona.prior.ts

@@ -77,7 +77,7 @@ export function readEffectiveParams(
 
   const out: Record<string, number> = { ...base }
   for( const [ key, delta ] of Object.entries( prior ) )
-    if( typeof out[ key ] === 'number' && typeof delta === 'number' )
+    if( typeof out[ key ] === 'number' && typeof delta === 'number')
       out[ key ] = out[ key ] + delta
 
   return out

package/src/cognition/schema.registry.ts

@@ -137,8 +137,8 @@ globalSchemaRegistry.register({
   version: 1,
   validate( payload ){
     if( !isRecord( payload ) ) return 'clock.tick payload must be an object'
-    if( typeof payload['tick'] !== 'number' ) return 'clock.tick requires numeric tick'
-    if( typeof payload['delta'] !== 'number' ) return 'clock.tick requires numeric delta'
+    if( typeof payload['tick'] !== 'number') return 'clock.tick requires numeric tick'
+    if( typeof payload['delta'] !== 'number') return 'clock.tick requires numeric delta'
 
     return null
   }

package/src/cognition/senses/audition.engine/engine.ts

@@ -474,7 +474,7 @@ export class AuditionEngine extends BaseSenseEngine {
       attachmentScore: this._getAttachmentScore?.( entityId ) ?? 0,
       activeGoalText:  this._getActiveGoalText?.()            ?? [],
     })
-    const salience = this._model.observe( `audition.${entityId}`, langEnergy ).salience
+    const salience = this._model.observe(`audition.${entityId}`, langEnergy ).salience
 
     // ── Percept ────────────────────────────────────────────────
     const percept: LanguagePercept = {
@@ -717,7 +717,7 @@ export class AuditionEngine extends BaseSenseEngine {
           goalsToAbandon:          output.goalsToAbandon,
           newBeliefs:              output.newBeliefs,
           knownEntityUpdates:      output.knownEntityUpdates,
-          requiresMasterAttention: ( output.actions ?? [] ).some( a => a.type === 'escalate' ),
+          requiresMasterAttention: ( output.actions ?? [] ).some( a => a.type === 'escalate'),
         }
       }
     }

package/src/cognition/senses/base.sense.engine.ts

@@ -112,6 +112,6 @@ export abstract class ShellSenseEngine extends BaseSenseEngine {
   }
 
   protected async _perceive( _input: SensoryInput ): Promise<void> {
-    logger.warn( `[${this.name}] ingest() called — engine is a shell, not yet implemented.` )
+    logger.warn(`[${this.name}] ingest() called — engine is a shell, not yet implemented.`)
   }
 }

package/src/cognition/utilities/token.tracker.ts

@@ -96,9 +96,9 @@ const CACHE_WRITE_MULT = 1.25
  */
 function normalizeModelKey( model: string ): string {
   let m = model.toLowerCase().trim()
-  const slash = m.lastIndexOf( '/' )
+  const slash = m.lastIndexOf('/')
   if( slash >= 0 ) m = m.slice( slash + 1 )   // drop "provider/" prefix
-  return m.replace( /[-@]\d{6,8}$/, '' )        // drop trailing -YYYYMMDD date stamp
+  return m.replace( /[-@]\d{6,8}$/, '')        // drop trailing -YYYYMMDD date stamp
 }
 
 // Pre-index the pricing table by normalized model name for O(1), date-insensitive
@@ -106,7 +106,7 @@ function normalizeModelKey( model: string ): string {
 const PRICING_BY_NORM: Record<string, { input: number; output: number }> = ( () => {
   const out: Record<string, { input: number; output: number }> = {}
   for( const [ key, price ] of Object.entries( MODEL_PRICING ) ){
-    if( key === '__default__' ) continue
+    if( key === '__default__') continue
     out[ normalizeModelKey( key ) ] = price
   }
   return out
@@ -305,10 +305,10 @@ export class TokenTracker implements SimulationEngine {
     if( this._ledgerPath ){
       try {
         if( !this._ledgerDirReady ){
-          mkdirSync( this._ledgerPath.slice( 0, this._ledgerPath.lastIndexOf( '/' ) ), { recursive: true } )
+          mkdirSync( this._ledgerPath.slice( 0, this._ledgerPath.lastIndexOf('/') ), { recursive: true } )
           this._ledgerDirReady = true
         }
-        appendFileSync( this._ledgerPath, JSON.stringify( record ) + '\n' )
+        appendFileSync( this._ledgerPath, JSON.stringify( record ) + '\n')
       }
       catch { /* ledger file is best-effort */ }
     }

package/src/core/abstracts.ts

@@ -47,7 +47,7 @@ export class BunStorageAdapter implements StorageAdapter {
       return Bun.file( path ).text()
 
     const { readFile } = await import('node:fs/promises')
-    return readFile( path, 'utf8' )
+    return readFile( path, 'utf8')
   }
 
   async readBytes( path: string ): Promise<Uint8Array> {

package/src/core/completion.recorder.ts

@@ -97,11 +97,11 @@ export class RecordedCompletionSource implements LLMCompletionSource {
   nextCompletion( tick: number, systemPrompt: string, userMessage: string ): LLMCompletionRecord {
     const queue = this._byTick.get( tick )
     if( !queue || queue.length === 0 )
-      throw new Error( `replay: no recorded LLM completion for tick ${tick} (recording is incomplete or call timing diverged)` )
+      throw new Error(`replay: no recorded LLM completion for tick ${tick} (recording is incomplete or call timing diverged)`)
 
     const idx = queue.findIndex( r => r.systemPrompt === systemPrompt && r.userMessage === userMessage )
     if( idx === -1 )
-      throw new Error( `replay: LLM prompt diverged at tick ${tick} — no recorded completion matches this call (upstream non-determinism)` )
+      throw new Error(`replay: LLM prompt diverged at tick ${tick} — no recorded completion matches this call (upstream non-determinism)`)
 
     return queue.splice( idx, 1 )[ 0 ]!
   }

package/src/core/serialization.ts

@@ -222,7 +222,7 @@ export class DefaultSerializer implements Serializer {
     if( Array.isArray( value ) )
       return value.map( v => this._encodeSpecial( v ) )
 
-    if( typeof value === 'object' ){
+    if( typeof value === 'object'){
       const out: Record<string, unknown> = {}
       for( const [ k, v ] of Object.entries( value as Record<string, unknown> ) )
         out[k] = this._encodeSpecial( v )
@@ -233,11 +233,11 @@ export class DefaultSerializer implements Serializer {
   }
 
   private _decodeSpecial( value: unknown ): unknown {
-    if( value === null || typeof value !== 'object' ) return value
+    if( value === null || typeof value !== 'object') return value
     if( Array.isArray( value ) ) return value.map( v => this._decodeSpecial( v ) )
 
     const tag = ( value as Record<string, unknown> ).__ser
-    if( typeof tag === 'string' ){
+    if( typeof tag === 'string'){
       const payload = ( value as Record<string, unknown> ).__val
       switch( tag ){
         case 'undefined': return undefined

package/src/core/snapshot.manager.ts

@@ -243,7 +243,7 @@ export class SnapshotManager {
       return this._serializer.deserialize( JSON.stringify( parsed ) )
     }
     catch( err ){
-      logger.warn( `[SnapshotManager] Could not load latest snapshot:`, err )
+      logger.warn(`[SnapshotManager] Could not load latest snapshot:`, err )
       return undefined
     }
   }

package/src/core/state.manager.ts

@@ -14,7 +14,7 @@ import { deepFreeze } from '#core/utils'
  */
 function resolveFreezeState(): boolean {
   const flag = process.env.WILL_FREEZE_STATE
-  if( flag !== undefined && flag !== '' )
+  if( flag !== undefined && flag !== '')
     return flag !== '0' && flag.toLowerCase() !== 'false'
   return process.env.NODE_ENV !== 'production'
 }

package/src/core/utils.ts

@@ -52,7 +52,7 @@ export function createPRNG( seed: number ): SeededPRNG {
  */
 export function deepFreeze<T>( value: T ): T {
   // Only objects/arrays/functions are freezable; primitives are immutable already.
-  if( value === null || typeof value !== 'object' ) return value
+  if( value === null || typeof value !== 'object') return value
   if( Object.isFrozen( value ) ) return value
 
   // Freeze the container first so a cyclic reference back to it hits the

package/src/host/boot.ts

@@ -37,12 +37,12 @@ import { anthropicWireHeaders, defaultBaseFor, defaultModelFor } from '#llm/inde
  */
 export function routeLogsToStderr(): void {
   const err = ( level: string ) => ( msg: string, ...rest: unknown[] ) =>
-    console.error( `[will:${ level }] ${ msg }`, ...rest )
-  setLogger( { debug: () => {}, info: err( 'info' ), warn: err( 'warn' ), error: err( 'error' ) } )
+    console.error(`[will:${ level }] ${ msg }`, ...rest )
+  setLogger( { debug: () => {}, info: err('info'), warn: err('warn'), error: err('error') } )
 }
 
 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'
 }
 
 /** The LLM mode the hosts will boot with: an explicit WILL_LLM, else whichever
@@ -57,7 +57,7 @@ export function resolveLlmMode(): 'mock' | 'anthropic' | 'glm' {
 
 /** The key for a live mode — the provider-agnostic override first, then the
  *  provider's own env. */
-function resolveLlmKey( mode: 'anthropic' | 'glm' ): string | undefined {
+function resolveLlmKey( mode: 'anthropic' | 'glm'): string | undefined {
   return process.env.WILL_LLM_API_KEY
     ?? ( mode === 'glm' ? process.env.ZAI_API_KEY : process.env.ANTHROPIC_API_KEY )
 }
@@ -79,13 +79,13 @@ function resolveLlmKey( mode: 'anthropic' | 'glm' ): string | undefined {
  */
 async function preflightLLM( anatomy: string ): Promise<void> {
   const mode = resolveLlmMode()
-  if( mode === 'mock' || anatomy === 'reflex' ) return
+  if( mode === 'mock' || anatomy === 'reflex') return
 
   const key = resolveLlmKey( mode )
   if( !key ){
     const expected = mode === 'glm' ? 'ZAI_API_KEY' : 'ANTHROPIC_API_KEY'
-    console.error( `[will] WILL_LLM=${ mode } but no ${ expected } / WILL_LLM_API_KEY is set.` )
-    console.error( '[will] The Will would boot, perceive, and never speak. Set a key, or run keyless with WILL_LLM=mock.' )
+    console.error(`[will] WILL_LLM=${ mode } but no ${ expected } / WILL_LLM_API_KEY is set.`)
+    console.error('[will] The Will would boot, perceive, and never speak. Set a key, or run keyless with WILL_LLM=mock.')
     process.exit( 2 )
   }
 
@@ -95,9 +95,9 @@ async function preflightLLM( anatomy: string ): Promise<void> {
   // speaks the same wire at Z.ai's compat endpoint, so one ping serves both.
   const base  = process.env.WILL_LLM_BASE_URL ?? defaultBaseFor( mode )
   const model = process.env.WILL_LLM_MODEL
-    ?? ( mode === 'glm' ? defaultModelFor( 'glm' ) : 'claude-haiku-4-5-20251001' )
+    ?? ( mode === 'glm' ? defaultModelFor('glm') : 'claude-haiku-4-5-20251001')
   try {
-    const res = await fetch( `${ base }/messages`, {
+    const res = await fetch(`${ base }/messages`, {
       method:  'POST',
       headers: anthropicWireHeaders( mode, key ),
       body:    JSON.stringify( { model, max_tokens: 1, messages: [ { role: 'user', content: 'ping' } ] } ),
@@ -105,20 +105,20 @@ async function preflightLLM( anatomy: string ): Promise<void> {
     } )
     if( res.ok ) return
 
-    const detail = ( await res.text().catch( () => '' ) ).slice( 0, 300 )
+    const detail = ( await res.text().catch( () => '') ).slice( 0, 300 )
     const fatal  = res.status === 400 || res.status === 401 || res.status === 403
     if( !fatal ){
-      console.error( `[will] the executive's LLM answered ${ res.status } on a test call — raising the mind anyway (it retries): ${ detail }` )
+      console.error(`[will] the executive's LLM answered ${ res.status } on a test call — raising the mind anyway (it retries): ${ detail }`)
       return
     }
-    console.error( `[will] the executive's LLM refused a test call (${ res.status }) — this Will would boot, perceive, and never speak:` )
-    console.error( `       ${ detail }` )
-    console.error( '[will] fix the key / credit / model above, or run keyless with WILL_LLM=mock.' )
+    console.error(`[will] the executive's LLM refused a test call (${ res.status }) — this Will would boot, perceive, and never speak:`)
+    console.error(`       ${ detail }`)
+    console.error('[will] fix the key / credit / model above, or run keyless with WILL_LLM=mock.')
     process.exit( 1 )
   }
   catch( e ){
-    console.error( `[will] could not reach the executive's LLM: ${ ( e as Error ).message }` )
-    console.error( '[will] the Will would boot and stay silent. Check the network / WILL_LLM_BASE_URL, or run keyless with WILL_LLM=mock.' )
+    console.error(`[will] could not reach the executive's LLM: ${ ( e as Error ).message }`)
+    console.error('[will] the Will would boot and stay silent. Check the network / WILL_LLM_BASE_URL, or run keyless with WILL_LLM=mock.')
     process.exit( 1 )
   }
 }
@@ -138,8 +138,8 @@ export interface BootedWill {
 /** Raise the mind from env config — wake from the artifact if one exists. */
 export async function bootWillFromEnv(): Promise<BootedWill> {
   const name       = process.env.WILL_NAME ?? 'Will'
-  const pmaPath    = resolve( process.env.WILL_PMA_PATH ?? `.will/${ slug( name ) }.pma.json` )
-  const tickMs     = parseInt( process.env.WILL_TICK_MS ?? '1000' )
+  const pmaPath    = resolve( process.env.WILL_PMA_PATH ?? `.will/${ slug( name ) }.pma.json`)
+  const tickMs     = parseInt( process.env.WILL_TICK_MS ?? '1000')
   const anatomy = ( process.env.WILL_ANATOMY as CreateWillOptions['anatomy'] ) ?? 'mind'
 
   await preflightLLM( anatomy )
@@ -153,23 +153,23 @@ export async function bootWillFromEnv(): Promise<BootedWill> {
 
   let will: Will
   if( existsSync( pmaPath ) ){
-    const pma = JSON.parse( readFileSync( pmaPath, 'utf8' ) ) as PMASnapshot
+    const pma = JSON.parse( readFileSync( pmaPath, 'utf8') ) as PMASnapshot
     will = await Will.wake( pma, opts )
-    console.error( `[will] ${ name } woke from ${ pmaPath }` )
+    console.error(`[will] ${ name } woke from ${ pmaPath }`)
     // A woken Will carries its own identity — that is the point of an artifact.
     // But an operator editing WILL_IDENTITY and seeing nothing change deserves
     // to know why, rather than concluding the persona layer is broken.
     if( process.env.WILL_IDENTITY )
-      console.error( `[will] note: WILL_IDENTITY is ignored — ${ name } woke as itself. Delete ${ pmaPath } to be born fresh from it.` )
+      console.error(`[will] note: WILL_IDENTITY is ignored — ${ name } woke as itself. Delete ${ pmaPath } to be born fresh from it.`)
   }
   else {
     will = await Will.create( {
       ...opts,
       identity: { prompt: process.env.WILL_IDENTITY ?? `I am ${ name }, a persistent mind.` },
     } )
-    console.error( `[will] ${ name } born (no artifact at ${ pmaPath } yet)` )
+    console.error(`[will] ${ name } born (no artifact at ${ pmaPath } yet)`)
   }
-  will.on( 'error', e => console.error( `[will] error: ${ e.message }` ) )
+  will.on('error', e => console.error(`[will] error: ${ e.message }`) )
 
   // Onward bridges: MCP servers whose tools become the Will's OWN abilities.
   // Best-effort — a bad entry warns and is skipped; the mind still boots.
@@ -181,12 +181,12 @@ export async function bootWillFromEnv(): Promise<BootedWill> {
         try {
           const { names, close } = await connectMcpEffectors( will, source )
           cleanups.push( close )
-          console.error( `[will] ${ name } gained abilities: ${ names.join( ', ' ) }` )
+          console.error(`[will] ${ name } gained abilities: ${ names.join(', ') }`)
         }
-        catch( e ){ console.error( `[will] MCP bridge failed (skipped): ${ ( e as Error ).message }` ) }
+        catch( e ){ console.error(`[will] MCP bridge failed (skipped): ${ ( e as Error ).message }`) }
       }
     }
-    catch( e ){ console.error( `[will] WILL_MCP_SERVERS is not valid JSON — ignoring: ${ ( e as Error ).message }` ) }
+    catch( e ){ console.error(`[will] WILL_MCP_SERVERS is not valid JSON — ignoring: ${ ( e as Error ).message }`) }
   }
 
   // Hibernate exactly once on the way out — cleanups (LIFO), distill + stop, persist.
@@ -199,13 +199,13 @@ export async function bootWillFromEnv(): Promise<BootedWill> {
       const pma = await will.hibernate()
       mkdirSync( dirname( pmaPath ), { recursive: true } )
       writeFileSync( pmaPath, JSON.stringify( pma ) )
-      console.error( `[will] ${ name } hibernated to ${ pmaPath } (${ why })` )
+      console.error(`[will] ${ name } hibernated to ${ pmaPath } (${ why })`)
     }
-    catch( e ){ console.error( `[will] hibernate failed: ${ ( e as Error ).message }` ) }
+    catch( e ){ console.error(`[will] hibernate failed: ${ ( e as Error ).message }`) }
     process.exit( 0 )
   }
-  process.on( 'SIGINT',  () => void shutdown( 'SIGINT' ) )
-  process.on( 'SIGTERM', () => void shutdown( 'SIGTERM' ) )
+  process.on('SIGINT',  () => void shutdown('SIGINT') )
+  process.on('SIGTERM', () => void shutdown('SIGTERM') )
 
   return {
     will, name, pmaPath, tickMs, anatomy,

package/src/host/utterances.ts

@@ -20,7 +20,7 @@ export class UtteranceTap {
 
   constructor( will: Will ){
     this._will = will
-    will.on( 'message', m => {
+    will.on('message', m => {
       this._pending.push( m )
       if( this._pending.length > BUFFER_CAP ) this._pending.shift()
     } )

package/src/llm/index.ts

@@ -187,7 +187,7 @@ export class LLMDirector {
    *   {"actions":[{"type":"...","reasoning":"...","expectedOutcome":"..."}],...}
    *   Strategy 1 (JSON.parse) handles this directly.
    */
-  private _mockResponse( tick: number, userMessage: string = '' ): LLMCallResult {
+  private _mockResponse( tick: number, userMessage: string = ''): LLMCallResult {
     // ── Conversation facet turn ────────────────────────────────
     // Detect the AuditionEngine facet focus via the SHARED contract (see
     // llm/wire.contracts.ts) — the render/match pair whose earlier drift
@@ -404,7 +404,7 @@ export class LLMDirector {
     catch( err ){
       clearTimeout( timer )
       if( controller.signal.aborted )
-        throw new Error( `LLM stream to ${this._provider} timed out after ${this._timeoutMs}ms (no response)` )
+        throw new Error(`LLM stream to ${this._provider} timed out after ${this._timeoutMs}ms (no response)`)
       throw err
     }
 
@@ -434,7 +434,7 @@ export class LLMDirector {
         for( const line of lines ){
           if( !line.startsWith('data: ') ) continue
           const raw = line.slice(6).trim()
-          if( raw === '[DONE]' ) break
+          if( raw === '[DONE]') break
 
           try {
             const ev = JSON.parse( raw ) as {
@@ -552,8 +552,8 @@ export class LLMDirector {
     }
     catch( err ){
       // AbortSignal.timeout rejects with a DOMException named 'TimeoutError'.
-      if( err instanceof Error && err.name === 'TimeoutError' )
-        throw new Error( `LLM request to ${this._provider} timed out after ${this._timeoutMs}ms` )
+      if( err instanceof Error && err.name === 'TimeoutError')
+        throw new Error(`LLM request to ${this._provider} timed out after ${this._timeoutMs}ms`)
       throw err
     }
   }
@@ -592,7 +592,7 @@ export class LLMDirector {
       content: Array<{ type: string; text: string }>
       usage: { input_tokens: number; output_tokens: number; cache_read_input_tokens?: number; cache_creation_input_tokens?: number }
     },
-    text = data.content.find( b => b.type === 'text' )?.text ?? ''
+    text = data.content.find( b => b.type === 'text')?.text ?? ''
 
     return {
       text,
@@ -673,7 +673,7 @@ export class LLMDirector {
     }
 
     const text = ( data.candidates?.[ 0 ]?.content?.parts ?? [] )
-      .map( p => p.text ?? '' )
+      .map( p => p.text ?? '')
       .join('')
 
     return {
@@ -715,7 +715,7 @@ export class LLMDirector {
         userMessage,
       ].join('\n')
 
-      const filepath = `${debugDir}/prompt-tick-${String( tick ).padStart( 6, '0' )}.txt`
+      const filepath = `${debugDir}/prompt-tick-${String( tick ).padStart( 6, '0')}.txt`
       writeFileSync( filepath, content )
 
       logger.info(`[executive] Debug prompt written → ${filepath} (~${estimatedTokens} tok estimated)`)
@@ -755,7 +755,7 @@ export class LLMDirector {
         responseText,
       ].join('\n')
 
-      const filepath = `${debugDir}/response-tick-${String( tick ).padStart( 6, '0' )}.txt`
+      const filepath = `${debugDir}/response-tick-${String( tick ).padStart( 6, '0')}.txt`
       writeFileSync( filepath, content )
     }
     catch {

package/src/llm/summarizer.ts

@@ -130,7 +130,7 @@ export class ExecutiveSummarizer {
 
   private async _run(): Promise<void> {
     if( !this._llmDirector ){
-      logger.warn( '[summarizer] skipping — LLMDirector not attached yet' )
+      logger.warn('[summarizer] skipping — LLMDirector not attached yet')
       return
     }
 
@@ -139,8 +139,8 @@ export class ExecutiveSummarizer {
 
     try {
       const userMessage = snapshot
-        .map( ( r, i ) => `[Cycle ${i + 1}]\n${r}` )
-        .join( '\n\n---\n\n' )
+        .map( ( r, i ) => `[Cycle ${i + 1}]\n${r}`)
+        .join('\n\n---\n\n')
 
       // Use _callCount as the tick value — it's only used for token tracking/logging
       const result = await this._llmDirector.call(
@@ -161,7 +161,7 @@ export class ExecutiveSummarizer {
       }
     }
     catch( err ){
-      logger.warn( '[summarizer] failed:', err instanceof Error ? err.message : err )
+      logger.warn('[summarizer] failed:', err instanceof Error ? err.message : err )
     }
     finally {
       this._summarizing = false

package/src/llm/wire.contracts.ts

@@ -36,7 +36,7 @@ export const REPLY_TEXT_CLOSE = `[/${REPLY_TEXT_TAG}]`
 
 /** Wrap a reply body in the block markers (the mock's emission shape). */
 export function wrapReplyText( body: string ): string {
-  return [ REPLY_TEXT_OPEN, body, REPLY_TEXT_CLOSE ].join( '\n' )
+  return [ REPLY_TEXT_OPEN, body, REPLY_TEXT_CLOSE ].join('\n')
 }
 
 // ── Conversation-facet focus — render ↔ match pair ────────────

package/src/mcp/effectors.ts

@@ -67,10 +67,10 @@ export function describeMcpTool( tool: McpToolInfo ): string {
   const props    = tool.inputSchema?.properties ?? {}
   const required = new Set( tool.inputSchema?.required ?? [] )
   const argHints = Object.entries( props ).map( ( [ key, p ] ) =>
-    `${ key }${ required.has( key ) ? '' : '?' }${ p.description ? `: ${ p.description }` : '' }` )
+    `${ key }${ required.has( key ) ? '' : '?' }${ p.description ? `: ${ p.description }` : '' }`)
 
-  const base = ( tool.description ?? `The ${ tool.name } tool.` ).trim().replace( /\s+/g, ' ' )
-  const hint = argHints.length > 0 ? ` (args — ${ argHints.join( '; ' ) })` : ''
+  const base = ( tool.description ?? `The ${ tool.name } tool.`).trim().replace( /\s+/g, ' ')
+  const hint = argHints.length > 0 ? ` (args — ${ argHints.join('; ') })` : ''
   const full = `${ base }${ hint }`
   return full.length > MEANING_CAP ? `${ full.slice( 0, MEANING_CAP - 1 ) }…` : full
 }
@@ -90,21 +90,21 @@ export function buildMcpHandler( client: Client, tool: McpToolInfo ): EffectorHa
       if( !props || k in props ) filtered[ k ] = v
 
     const missing = ( tool.inputSchema?.required ?? [] ).filter(
-      k => filtered[ k ] === undefined || filtered[ k ] === '' )
+      k => filtered[ k ] === undefined || filtered[ k ] === '')
     if( missing.length > 0 )
       return {
         success: false,
-        description: `${ tool.name } needs ${ missing.join( ', ' ) } — enact it deliberately, supplying them in the action's args.`,
+        description: `${ tool.name } needs ${ missing.join(', ') } — enact it deliberately, supplying them in the action's args.`,
       }
 
     try {
       const res  = await client.callTool( { name: tool.name, arguments: filtered } ) as
         { content?: Array<{ type: string; text?: string }>; isError?: boolean }
       const text = ( res.content ?? [] )
-        .filter( c => c.type === 'text' && typeof c.text === 'string' )
+        .filter( c => c.type === 'text' && typeof c.text === 'string')
         .map( c => c.text as string )
-        .join( '\n' )
-        .trim() || ( res.isError ? 'The tool reported an error.' : 'Done (no output).' )
+        .join('\n')
+        .trim() || ( res.isError ? 'The tool reported an error.' : 'Done (no output).')
       const bounded = text.length > RESULT_DESCRIPTION_CAP ? `${ text.slice( 0, RESULT_DESCRIPTION_CAP - 1 ) }…` : text
       return { success: !res.isError, description: bounded }
     }
@@ -115,10 +115,10 @@ export function buildMcpHandler( client: Client, tool: McpToolInfo ): EffectorHa
 }
 
 async function connect( source: McpToolsSource ): Promise<{ client: Client; owned: boolean }> {
-  if( 'client' in source ) return { client: source.client, owned: false }
+  if('client' in source ) return { client: source.client, owned: false }
 
   const client = new Client( { name: 'mindot-will', version: '0' } )
-  if( 'url' in source )
+  if('url' in source )
     await client.connect( new StreamableHTTPClientTransport( new URL( source.url ) ) )
   else
     await client.connect( new StdioClientTransport( {

package/src/mcp/server.ts

@@ -35,7 +35,7 @@ export interface WillMcpOptions {
 function serverVersion(): string {
   // Same relative depth from src/mcp/ and dist/mcp/ — resolves in both.
   try {
-    return JSON.parse( readFileSync( new URL( '../../package.json', import.meta.url ), 'utf8' ) ).version ?? '0.0.0'
+    return JSON.parse( readFileSync( new URL('../../package.json', import.meta.url ), 'utf8') ).version ?? '0.0.0'
   }
   catch { return '0.0.0' }
 }
@@ -54,7 +54,7 @@ export function buildWillMcpServer( will: Will, opts: WillMcpOptions = {} ): Mcp
 
   // ── Tools ─────────────────────────────────────────────────
 
-  server.registerTool( 'perceive', {
+  server.registerTool('perceive', {
     title: 'Perceive',
     description:
       `Deliver a stimulus (something said or observed) into ${ will.name }'s sensory field. ` +
@@ -62,9 +62,9 @@ export function buildWillMcpServer( will: Will, opts: WillMcpOptions = {} ): Mcp
       `NOT when it has responded. Its response — if it chooses to give one — arrives as its next ` +
       `utterance (use the next_utterance tool). Staying silent is a valid choice, not an error.`,
     inputSchema: {
-      text:    z.string().describe( 'What is said or observed.' ),
+      text:    z.string().describe('What is said or observed.'),
       from:    z.string().optional().describe( "Who it's from (entity id, default 'user'). Use a stable id per person." ),
-      speaker: z.string().optional().describe( 'Display name of the speaker.' ),
+      speaker: z.string().optional().describe('Display name of the speaker.'),
     },
   }, async ( { text, from, speaker } ) => {
     await will.perceive( { text, ...( from ? { from } : {} ), ...( speaker ? { speaker } : {} ) } )
@@ -77,15 +77,15 @@ export function buildWillMcpServer( will: Will, opts: WillMcpOptions = {} ): Mcp
     }
   } )
 
-  server.registerTool( 'next_utterance', {
+  server.registerTool('next_utterance', {
     title: 'Next utterance',
     description:
       `Await ${ will.name }'s next spontaneous utterance. Returns what it says next, or reports ` +
       `that it chose silence within the wait window — silence is a real outcome, not a failure. ` +
       `Call after perceive to hear the response, or on its own to listen for unprompted speech.`,
     inputSchema: {
-      within_ms: z.number().optional().describe( 'How long to wait before accepting silence (default 15000, max 120000).' ),
-      from:      z.string().optional().describe( 'Only accept an utterance addressed to this entity id.' ),
+      within_ms: z.number().optional().describe('How long to wait before accepting silence (default 15000, max 120000).'),
+      from:      z.string().optional().describe('Only accept an utterance addressed to this entity id.'),
     },
   }, async ( { within_ms, from } ) => {
     const within = Math.min( Math.max( within_ms ?? 15_000, 100 ), 120_000 )
@@ -101,7 +101,7 @@ export function buildWillMcpServer( will: Will, opts: WillMcpOptions = {} ): Mcp
     }
   } )
 
-  server.registerTool( 'state', {
+  server.registerTool('state', {
     title: 'Inner state',
     description:
       `Read a snapshot of ${ will.name }'s current inner life: tick, body/affect metrics ` +
@@ -112,7 +112,7 @@ export function buildWillMcpServer( will: Will, opts: WillMcpOptions = {} ): Mcp
     { content: [ { type: 'text', text: JSON.stringify( will.state(), null, 2 ) } ] }
   ) )
 
-  server.registerTool( 'save', {
+  server.registerTool('save', {
     title: 'Save (checkpoint)',
     description:
       `Checkpoint ${ will.name } into a portable PMA artifact on disk — non-destructive, it keeps ` +
@@ -130,12 +130,12 @@ export function buildWillMcpServer( will: Will, opts: WillMcpOptions = {} ): Mcp
 
   // ── Resources (read-only projections) ─────────────────────
 
-  server.registerResource( 'state', 'will://state',
+  server.registerResource('state', 'will://state',
     { title: `${ will.name } — inner state`, description: 'Live snapshot of the mind: metrics, goals, beliefs, narrative.', mimeType: 'application/json' },
     async uri => ( { contents: [ { uri: uri.href, mimeType: 'application/json', text: JSON.stringify( will.state(), null, 2 ) } ] } ),
   )
 
-  server.registerResource( 'narrative', 'will://narrative',
+  server.registerResource('narrative', 'will://narrative',
     { title: `${ will.name } — self-narrative`, description: 'The story the mind currently tells about itself.', mimeType: 'text/plain' },
     async uri => ( { contents: [ { uri: uri.href, mimeType: 'text/plain', text: will.state().narrative || '(no narrative formed yet)' } ] } ),
   )