@mindot/will 0.4.0 → 0.6.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

@@ -53,6 +53,12 @@ const MODEL_PRICING: Record<string, { input: number; output: number }> = {
   'anthropic/claude-haiku-4':    { input: 1.00,  output: 5.00  },
   'anthropic/claude-opus-4':     { input: 5.00,  output: 25.00 },
   
+  // Z.ai (GLM-5 family). `glm-5.2[1m]` is the same model asking for its 1M
+  // context window — same rate, so it gets its own row rather than relying on
+  // the normalizer (a future long-context tier would price differently).
+  'glm/glm-5.2':                { input: 1.40,  output: 4.40  },
+  'glm/glm-5.2[1m]':            { input: 1.40,  output: 4.40  },
+
   // Google
   'google/gemini-2.0-flash':    { input: 0.10,  output: 0.40  },
   'google/gemini-2.0-pro':      { input: 1.25,  output: 5.00  },
@@ -90,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
@@ -100,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
@@ -299,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

@@ -12,8 +12,9 @@
 //   WILL_NAME        display name                    (default "Will")
 //   WILL_IDENTITY    persona prompt                  (default a minimal self)
 //   WILL_TIER        basic | standard | full         (default standard)
-//   WILL_LLM         mock | anthropic                (default: auto — anthropic when
-//                                                     ANTHROPIC_API_KEY is set, else mock)
+//   WILL_LLM         mock | anthropic | glm          (default: auto — anthropic when
+//                                                     ANTHROPIC_API_KEY is set, glm when
+//                                                     ZAI_API_KEY is, else mock)
 //   WILL_TICK_MS     ms per tick                     (default 1000)
 //   WILL_SEED        deterministic seed (testing)    (default unseeded/wall-time)
 //   WILL_PMA_PATH    PMA artifact path               (default ./.will/<name>.pma.json)
@@ -27,6 +28,7 @@ import { setLogger } from '#core/logger'
 import { Will, type CreateWillOptions } from '#sdk/will'
 import type { PMASnapshot } from '#pma/index'
 import { connectMcpEffectors, type McpToolsSource } from '#root/mcp/effectors'
+import { anthropicWireHeaders, defaultBaseFor, defaultModelFor } from '#llm/index'
 
 /**
  * Route every engine log line to stderr. For `will mcp`, stdout is the MCP
@@ -35,12 +37,29 @@ import { connectMcpEffectors, type McpToolsSource } from '#root/mcp/effectors'
  */
 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
+ *  provider's key is present, else the zero-key mock. */
+export function resolveLlmMode(): 'mock' | 'anthropic' | 'glm' {
+  const explicit = process.env.WILL_LLM as 'mock' | 'anthropic' | 'glm' | undefined
+  if( explicit ) return explicit
+  if( process.env.ANTHROPIC_API_KEY ) return 'anthropic'
+  if( process.env.ZAI_API_KEY ) return 'glm'
+  return 'mock'
+}
+
+/** The key for a live mode — the provider-agnostic override first, then the
+ *  provider's own env. */
+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 )
 }
 
 /**
@@ -59,44 +78,47 @@ function slug( s: string ): string {
  * Skipped for the mock executive and the no-LLM `reflex` anatomy.
  */
 async function preflightLLM( anatomy: string ): Promise<void> {
-  const mode = process.env.WILL_LLM ?? ( process.env.ANTHROPIC_API_KEY ? 'anthropic' : 'mock' )
-  if( mode === 'mock' || anatomy === 'reflex' ) return
+  const mode = resolveLlmMode()
+  if( mode === 'mock' || anatomy === 'reflex') return
 
-  const key = process.env.WILL_LLM_API_KEY ?? process.env.ANTHROPIC_API_KEY
+  const key = resolveLlmKey( mode )
   if( !key ){
-    console.error( '[will] WILL_LLM=anthropic but no ANTHROPIC_API_KEY / WILL_LLM_API_KEY is set.' )
-    console.error( '[will] The Will would boot, perceive, and never speak. Set a key, or run keyless with WILL_LLM=mock.' )
+    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.')
     process.exit( 2 )
   }
 
   // The ping validates key + balance + reachability, which is the failure class
   // that strands an operator. It uses the pinned model when there is one, so a
-  // bad model id is caught too; otherwise the cheapest model stands in.
-  const base  = process.env.WILL_LLM_BASE_URL ?? 'https://api.anthropic.com/v1'
-  const model = process.env.WILL_LLM_MODEL ?? 'claude-haiku-4-5-20251001'
+  // bad model id is caught too; otherwise the cheapest model stands in. GLM
+  // 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')
   try {
-    const res = await fetch( `${ base }/messages`, {
+    const res = await fetch(`${ base }/messages`, {
       method:  'POST',
-      headers: { 'content-type': 'application/json', 'anthropic-version': '2023-06-01', 'x-api-key': key },
+      headers: anthropicWireHeaders( mode, key ),
       body:    JSON.stringify( { model, max_tokens: 1, messages: [ { role: 'user', content: 'ping' } ] } ),
       signal:  AbortSignal.timeout( 20_000 ),
     } )
     if( res.ok ) return
 
-    const detail = ( await res.text().catch( () => '' ) ).slice( 0, 300 )
+    const 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 )
   }
 }
@@ -116,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 )
@@ -125,29 +147,29 @@ export async function bootWillFromEnv(): Promise<BootedWill> {
   const opts: Omit<CreateWillOptions, 'identity'> = {
     name, anatomy, tickMs,
     ...( process.env.WILL_LLM_MODEL ? { model: process.env.WILL_LLM_MODEL } : {} ),
-    ...( process.env.WILL_LLM  ? { llm: process.env.WILL_LLM as 'mock' | 'anthropic' } : {} ),
+    ...( process.env.WILL_LLM ? { llm: process.env.WILL_LLM as CreateWillOptions['llm'] } : {} ),
     ...( process.env.WILL_SEED ? { seed: parseInt( process.env.WILL_SEED ) } : {} ),
   }
 
   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.
@@ -159,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.
@@ -177,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()
     } )