@mindot/will 0.5.0 → 0.7.0

package/src/pma/eval.ts

@@ -368,7 +368,7 @@ export class PMAEvalHarness {
     let loadedTraits: Record<string, number> = {}
 
     for( const entity of state.entities.values() ){
-      if( entity.type === 'will.identity' ){
+      if( entity.type === 'will.identity'){
         loadedTraits = ( entity.metadata?.['traits'] as Record<string, number> ) ?? {}
         break
       }

package/src/pma/index.ts

@@ -345,7 +345,7 @@ export class PMADistiller {
    */
   private _extractPersona( state: SimulationState ): PMASnapshot['persona'] {
     const priorMeta = state.entities.get( PERSONA_PRIOR_ID )?.metadata as { priors?: Record<string, Record<string, number>> } | undefined
-    const calibMeta = state.entities.get( 'calibration-state' )?.metadata as { domainBias?: Record<string, number> } | undefined
+    const calibMeta = state.entities.get('calibration-state')?.metadata as { domainBias?: Record<string, number> } | undefined
 
     const configPriors    = priorMeta?.priors    ?? {}
     const calibrationBias = calibMeta?.domainBias ?? {}
@@ -358,7 +358,7 @@ export class PMADistiller {
 
   private _extractIdentity( state: SimulationState ): PMAIdentity {
     for( const entity of state.entities.values() ){
-      if( entity.type === 'will.identity' ){
+      if( entity.type === 'will.identity'){
         const m = entity.metadata ?? {}
         return {
           prompt:  ( m['prompt']  as string )                     ?? '',
@@ -390,9 +390,9 @@ export class PMADistiller {
     // If socialOrientation not explicitly set, infer from top actions
     if( !enhanced.socialOrientation && behavioral.fingerprint.topActions.length > 0 ){
       const topAction = behavioral.fingerprint.topActions[0] ?? ''
-      if( topAction.includes( 'social' ) || topAction.includes( 'talk' ) || topAction.includes( 'text' ) ){
+      if( topAction.includes('social') || topAction.includes('talk') || topAction.includes('text') ){
         enhanced.socialOrientation = 'gregarious'
-      } else if( topAction.includes( 'reflect' ) || topAction.includes( 'meditate' ) ){
+      } else if( topAction.includes('reflect') || topAction.includes('meditate') ){
         enhanced.socialOrientation = 'reserved'
       } else {
         enhanced.socialOrientation = 'ambivert'
@@ -418,7 +418,7 @@ export class PMADistiller {
     const raw: PMABelief[] = []
 
     for( const entity of state.entities.values() ){
-      if( entity.type !== 'belief' ) continue
+      if( entity.type !== 'belief') continue
 
       const m = entity.metadata ?? {}
       raw.push({
@@ -446,11 +446,11 @@ export class PMADistiller {
     const goals: PMAGoal[] = []
 
     for( const entity of state.entities.values() ){
-      if( entity.type !== 'goal' ) continue
+      if( entity.type !== 'goal') continue
 
       const m      = entity.metadata ?? {}
       const status = ( m['status'] as string ) ?? 'active'
-      if( status !== 'active' && status !== 'in_progress' ) continue
+      if( status !== 'active' && status !== 'in_progress') continue
 
       goals.push({
         id:                  entity.id,
@@ -459,7 +459,7 @@ export class PMADistiller {
         progress:            ( m['progress']            as number   ) ?? 0,
         status,
         tags:                ( m['tags']                as string[] ) ?? [],
-        completionType:      ( m['completionType']      as 'metric' | 'action' | 'epistemic' ) ?? 'epistemic',
+        completionType:      ( m['completionType']      as 'metric' | 'action' | 'epistemic') ?? 'epistemic',
         completionCondition: ( m['completionCondition'] as string   ) ?? undefined,
       })
     }
@@ -475,7 +475,7 @@ export class PMADistiller {
     const digestTick = new Map<string, number>()
 
     for( const entity of state.entities.values() ){
-      if( entity.type === 'attachment.bond' ){
+      if( entity.type === 'attachment.bond'){
         const m       = entity.metadata ?? {}
         const keid = m['keid'] as string | undefined
         if( !keid ) continue
@@ -492,7 +492,7 @@ export class PMADistiller {
         stubs.set( keid, stub )
       }
 
-      else if( entity.type === 'reputation' ){
+      else if( entity.type === 'reputation'){
         const m       = entity.metadata ?? {}
         const keid = m['keid'] as string | undefined
         if( !keid ) continue
@@ -512,7 +512,7 @@ export class PMADistiller {
         stubs.set( keid, stub )
       }
 
-      else if( entity.type === 'theory_of_mind' ){
+      else if( entity.type === 'theory_of_mind'){
         const m       = entity.metadata ?? {}
         const keid = m['keid'] as string | undefined
         if( !keid ) continue
@@ -526,15 +526,15 @@ export class PMADistiller {
         stubs.set( keid, stub )
       }
 
-      else if( entity.type === 'known-entity' ){
+      else if( entity.type === 'known-entity'){
         const m    = entity.metadata ?? {}
         const keid = m['keid'] as string | undefined
         if( !keid ) continue
 
         const stub = stubs.get( keid ) ?? { keid }
-        if( !stub.agentName && typeof m['name'] === 'string' ) stub.agentName = m['name'] as string
+        if( !stub.agentName && typeof m['name'] === 'string') stub.agentName = m['name'] as string
         stub.dossier = {
-          kind:                 ( m['kind']                 as 'sentient' | 'thing' ) ?? 'sentient',
+          kind:                 ( m['kind']                 as 'sentient' | 'thing') ?? 'sentient',
           name:                 ( m['name']                 as string | undefined ),
           familiarity:          ( m['familiarity']          as number ) ?? 0,
           valence:              ( m['valence']              as number ) ?? 0,
@@ -550,7 +550,7 @@ export class PMADistiller {
       // AuditionEngine memory sink + ProactiveCommunicator). The most recent
       // exchange summary wins.
       else if( entity.type === 'episodic_memory'
-            && entity.metadata?.['sourceType'] === 'conversation.exchange' ){
+            && entity.metadata?.['sourceType'] === 'conversation.exchange'){
         const content = ( entity.metadata['content'] as Record<string, unknown> | undefined ) ?? {}
         const keid = content['entityId'] as string | undefined
         if( !keid ) continue
@@ -599,7 +599,7 @@ export class PMADistiller {
       reactivity:          0.5,
     }
 
-    const filePath = join( dataDir, 'wills', willId, 'profiles', 'emotional_biography.jsonl' )
+    const filePath = join( dataDir, 'wills', willId, 'profiles', 'emotional_biography.jsonl')
     if( !existsSync( filePath ) ) return { baseline: defaultBaseline, sessionsRead: 0 }
 
     const summaries = _readLastNSummaries( filePath, 'session_summary', 5 )
@@ -673,7 +673,7 @@ export class PMADistiller {
       impulsivity:      0.3,
     }
 
-    const filePath = join( dataDir, 'wills', willId, 'profiles', 'behavioral.jsonl' )
+    const filePath = join( dataDir, 'wills', willId, 'profiles', 'behavioral.jsonl')
     if( !existsSync( filePath ) ) return { fingerprint: defaultFingerprint, sessionsRead: 0 }
 
     const summaries = _readLastNSummaries( filePath, 'session_summary', 5 )
@@ -860,7 +860,7 @@ export class PMALoader {
 
     // ── 3. Goals ──────────────────────────────────────────────
     for( const g of pma.goals ){
-      if( g.status !== 'active' && g.status !== 'in_progress' ) continue
+      if( g.status !== 'active' && g.status !== 'in_progress') continue
 
       cognition.goalManager.addGoal(
         g.description,
@@ -882,8 +882,8 @@ export class PMALoader {
       pma.emotionalBaseline.arousalProfile === 'calm'        ? 0.30 :
       0.45
 
-    sm.setMetric( 'affect.valence', valence )
-    sm.setMetric( 'affect.arousal', arousal )
+    sm.setMetric('affect.valence', valence )
+    sm.setMetric('affect.arousal', arousal )
 
     // ── 5. Temperament (influences emotional set-point) ───────
     const temperamentValence = pma.emotionalBaseline.temperamentValence
@@ -1068,7 +1068,7 @@ function _readLastNSummaries(
   n:        number
 ): Array<Record<string, unknown>> {
   try {
-    return readFileSync( filePath, 'utf8' )
+    return readFileSync( filePath, 'utf8')
       .split('\n')
       .filter( l => l.trim().length > 0 )
       .map( l => { try { return JSON.parse(l) as Record<string, unknown> } catch { return null } })

package/src/runners/outreach.runner.ts

@@ -111,8 +111,8 @@ async function main(): Promise<void> {
     lastBlocked   = g('agency.communicate.blocked')
 
     if( tick % 10 === 0 ){
-      const goals = [ ...snap.entities.values() ].filter( e => e.type === 'goal' && e.metadata?.status === 'active' ).length
-      const sent  = [ ...snap.entities.values() ].filter( e => e.type === 'conversation.sent' ).length
+      const goals = [ ...snap.entities.values() ].filter( e => e.type === 'goal' && e.metadata?.status === 'active').length
+      const sent  = [ ...snap.entities.values() ].filter( e => e.type === 'conversation.sent').length
       console.log(
         `[t${tick}] v=${g('affect.valence').toFixed(2)} arousal=${g('affect.arousal').toFixed(2)} ` +
         `frust=${g('emotion.frustration').toFixed(2)} energy=${g('energy.level').toFixed(0)} ` +
@@ -130,7 +130,7 @@ async function main(): Promise<void> {
   const startedAt = Date.now()
   while( true ){
     const s = m.listWills().find( w => w.id === WILL_ID )
-    if( !s || s.status === 'archived' ) break
+    if( !s || s.status === 'archived') break
     if( s.tickCount >= END_TICK ) break
     if( sawReactive && sawProactive ){ console.log('\n[scenario] both paths observed — wrapping up'); break }
     if( Date.now() - startedAt > SAFETY_MS ){ console.log('\n[scenario] safety cap hit'); break }

package/src/runners/social.runner.ts

@@ -134,7 +134,7 @@ async function main(): Promise<void> {
 
     // Beliefs the Will formed ABOUT Dr. Chen (social cognition evidence)
     const chenBeliefs = ( ( pma as { beliefs?: Array<{ statement?: string; content?: string }> } ).beliefs ?? [] )
-      .map( b => b.statement ?? b.content ?? '' )
+      .map( b => b.statement ?? b.content ?? '')
       .filter( s => /chen|she|her|researcher|observ/i.test( s ) )
       .slice( 0, 6 )
     if( chenBeliefs.length ){

package/src/runners/thin-shim.runner.ts

@@ -26,7 +26,7 @@ const TICK_MS        = parseInt( process.env.WILL_TICK_MS       ?? '1000')
 const MAX_TICKS      = parseInt( process.env.WILL_MAX_TICKS     ?? '0'    )
 const LOG_INTERVAL   = parseInt( process.env.WILL_LOG_INTERVAL  ?? '10'   )
 const RANDOM_SEED    = parseInt( process.env.WILL_SEED          ?? String( Date.now() ) )
-const ANATOMY        = ( process.env.WILL_ANATOMY ?? 'mind' ) as WillConfig['anatomy']
+const ANATOMY        = ( process.env.WILL_ANATOMY ?? 'mind') as WillConfig['anatomy']
 const EXECUTIVE_INT    = process.env.WILL_EXECUTIVE_INTERVAL
   ? parseInt( process.env.WILL_EXECUTIVE_INTERVAL )
   : undefined

package/src/sdk/will.ts

@@ -362,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
@@ -395,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 } ) ),
@@ -463,7 +463,7 @@ export class Will {
   private _buildConfig( id: string, opts: CreateWillOptions ): WillConfig {
     // 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' )
+      ?? ( 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'
@@ -581,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

@@ -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,7 +112,7 @@ 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 provider = ( process.env.WILL_LLM_PROVIDER ?? 'anthropic') as LLMProvider
   const director = new LLMDirector({
     willId:          opts.willId ?? 'identity-coherence',
     model:           process.env.WILL_LLM_MODEL ?? defaultModelFor( provider ),
@@ -131,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 }
@@ -143,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 )
@@ -807,6 +807,16 @@ export class WillStem {
     this._effector.confirmExecution( this._get( id ), invocationId, result )
   }
 
+  /**
+   * Resolve a policy escalation the Will raised (POLICY_REAFFERENCE P4).
+   * `approved` dispatches the held invocation to the world; otherwise it is
+   * refused. Applied at the next tick boundary. `invocationId` is the awaiting
+   * `agency.intent` id the escalation ask referenced.
+   */
+  resolveEscalation( id: string, invocationId: string, approved: boolean ): void {
+    this._effector.resolveEscalation( this._get( id ), invocationId, approved )
+  }
+
   // ── Messaging / outbox (11.1) ────────────────────────────────────────────
   // Delegates to OutboxController (R5-c). `_get(id)` validates the Will exists
   // and supplies the WillInstance; the outbox ops touch only instance fields.
@@ -963,6 +973,11 @@ export class WillStem {
         sensory: this._sensory,
       } )
 
+      // Apply policy refusals queued during the previous step's flush, at the
+      // same boundary and for the same reason (POLICY_REAFFERENCE P1): a denial
+      // reconciles as a host-rejection-shaped failure ack the step then sees.
+      this._effector.applyPolicyOutcomes( instance )
+
       await instance.simulation.step( 1 )
 
       instance.tickCount++
@@ -1029,9 +1044,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 +1054,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 +1116,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
       }