@mindot/will 0.5.0 → 0.7.0

package/src/cognition/faculties/attachment.evaluator.ts

@@ -128,12 +128,12 @@ export class AttachmentEvaluator implements SimulationEngine, CognitiveEngine {
 
   onCognitiveEvent( e: CognitiveEvent ): StateCommands | void {
     this._model.observe( e.type, e.salience )
-    if( e.type === 'executive.prediction.formed' ){
+    if( e.type === 'executive.prediction.formed'){
       const p = e.payload as { predictedDomains: string[]; confidence: number }
       if( p.predictedDomains.includes('social') )
-        this._model.setPrecision( 'emotion.love', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('emotion.love', 1.0 + p.confidence * 0.5 )
     }
-    if( e.type === 'interaction.occurred' ){
+    if( e.type === 'interaction.occurred'){
       const p = e.payload as {
         keid: string; valence: number; intensity: number
         directedAtSelf: boolean; interactionType: string
@@ -146,7 +146,7 @@ export class AttachmentEvaluator implements SimulationEngine, CognitiveEngine {
         sharedExperience: false,
       })
     }
-    if( e.type === 'social.agents.present' ){
+    if( e.type === 'social.agents.present'){
       const p = e.payload as { activeAgents: number }
       this._cachedActiveAgents = p.activeAgents
     }
@@ -167,7 +167,7 @@ export class AttachmentEvaluator implements SimulationEngine, CognitiveEngine {
     // Channel A (agreeableness → attachment): how fast bonds form is refreshed each tick as
     // base ⊕ persona-prior. An agreeable Will develops a higher growth rate and bonds more
     // readily. (Seed existed but was ignored.)
-    this._growthRate = readEffectiveParams( state, 'engine-config-attachment' ).attachmentGrowthRate ?? this._growthRate
+    this._growthRate = readEffectiveParams( state, 'engine-config-attachment').attachmentGrowthRate ?? this._growthRate
 
     // On the very first tick after construction (including snapshot restores),
     // rehydrate _bonds from attachment.bond entities written by _persistBonds().
@@ -230,7 +230,7 @@ export class AttachmentEvaluator implements SimulationEngine, CognitiveEngine {
     // Phase C: publish cognitive event
     const _bus = this._bus
     if( _bus && love > 0.5 ){
-      const predErr = this._model.observe( 'emotion.love', love )
+      const predErr = this._model.observe('emotion.love', love )
       if( !predErr.gated )
         _bus.publish({ type: 'emotion.love.significant', version: 1, sourceEngine: this.name, salience: Math.min(1, love), payload: { love } })
     }

package/src/cognition/faculties/attention.allocator.ts

@@ -29,6 +29,7 @@ import type { CognitiveEngine, SimulationEngine, EngineResult } from '#cognition
 import type { CognitiveEventSchema } from '#cognition/schema.registry'
 import type { CognitiveEvent, CognitiveBus } from '#cognition/bus'
 import { GenerativeModel } from '#cognition/generative.model'
+import { ACP_SELF_PRECISION } from '#cognition/acp'
 import { readEffectiveParams } from '#cognition/persona.prior'
 
 export interface AttentionAllocatorConfig {
@@ -57,6 +58,25 @@ interface AttentionFocus {
 // a choice it relaxes back to baseline, so focus/rest are transient unless
 // renewed. Effort scales the ceiling, so vitals always win — you cannot focus
 // past exhaustion (a collapsed ceiling leaves nothing to engage).
+// ── ACP-P2 (ACTION_CONDITIONED_PREDICTION §3) — efferent anticipation ────────
+/** Expected attention-usage swing right after our own enaction. */
+const ACP_USAGE_UPLIFT = 0.15
+/** Conservative anticipation confidence (plan of record: 0.3–0.5). */
+const ACP_CONFIDENCE = 0.4
+/**
+ * Self-caused precision: measurement showed that after a stable stretch the
+ * salience denominator (EW variance) collapses, so ANY deviation saturates
+ * salience at 1.0 and a conservative anticipation nudge is invisible there.
+ * The measurable lever at this seam is precision (salience = base × precision,
+ * executive precedent at 'executive.prediction.formed'): our own action's
+ * swing carries reduced attention-grabbing weight — below the workspace gate
+ * (WORKSPACE_THRESHOLD = 0.4) even when the base saturates. Restored
+ * explicitly after ONE observe (GenerativeModel's own mean-reversion is
+ * 0.02/observe ≈ 50 ticks — that lingering would suppress genuine world
+ * surprise arriving after our action, the exact failure the plan forbids).
+ */
+// (moved to #cognition/acp — shared across ACP-P2 consumers)
+
 const EFFORT_BASELINE = 0.7   // homeostatic default utilization of the ceiling
 const EFFORT_MIN      = 0.4   // deepest voluntary stand-down (rest)
 const EFFORT_MAX      = 1.0   // full mobilization (focus)
@@ -90,6 +110,8 @@ export class AttentionAllocator implements SimulationEngine, CognitiveEngine {
   private _effort: number = EFFORT_BASELINE
   /** A one-shot focus/rest request from the executive, applied next react(). */
   private _effortRequest: number | null = null
+  /** ACP-P2: a self-caused precision attenuation is armed; react() restores after one observe. */
+  private _acpOneShot = false
 
   private _bus: CognitiveBus | null = null
 
@@ -115,6 +137,8 @@ export class AttentionAllocator implements SimulationEngine, CognitiveEngine {
       'executive.prediction.formed',
       'attention.regulate',   // voluntary focus/rest from the executive (Option C)
       'senses.*',   // all sense percepts — salience feeds attention allocation
+      // ACP-P2: our own enactions — anticipate the attention swing they cause
+      'agency.enacted', 'agency.communicate', 'agency.invocation',
     ]
   }
   publishes(): CognitiveEventSchema[] { return [] }
@@ -132,23 +156,46 @@ export class AttentionAllocator implements SimulationEngine, CognitiveEngine {
         // Voluntary focus/rest (Option C). Clamp the requested set-point; react()
         // applies it next tick and then decays it back toward baseline.
         const t = (e.payload as Record<string,number>)['effortTarget']
-        if( typeof t === 'number' )
+        if( typeof t === 'number')
           this._effortRequest = Math.min( EFFORT_MAX, Math.max( EFFORT_MIN, t ) )
         break
       }
       case 'executive.prediction.formed': {
         const p = e.payload as { predictedDomains: string[]; confidence: number }
         if( p.predictedDomains.includes('attention') )
-          this._model.setPrecision( 'attention.usage', 1.0 + p.confidence * 0.5 )
+          this._model.setPrecision('attention.usage', 1.0 + p.confidence * 0.5 )
+        break
+      }
+      case 'agency.enacted':
+      case 'agency.communicate':
+      case 'agency.invocation': {
+        // ACP-P2, first consumer: we just acted — our own attention state is
+        // about to move BECAUSE of it (usage up, free fraction down). Pre-blend
+        // that expectation so the self-caused swing lands with low prediction
+        // error and doesn't fire `attention.state.changed` as surprise; the
+        // world's own deviations still do. One-shot by construction — the
+        // anticipation weight is consumed by each stream's next observe().
+        // Only the two streams whose errors are actually consumed (they gate
+        // the publish) are anticipated; `attention.entity.*` errors are
+        // discarded today, so anticipating them would be theater.
+        const usage = this._model.predict('attention.usage')
+        const free  = this._model.predict('attention.free_fraction')
+        this._model.anticipate('attention.usage',         Math.min( 1, usage + ACP_USAGE_UPLIFT ), ACP_CONFIDENCE )
+        this._model.anticipate('attention.free_fraction', Math.max( 0, free  - ACP_USAGE_UPLIFT ), ACP_CONFIDENCE )
+        // The measurable half (see ACP_SELF_PRECISION): the next observe of
+        // each stream carries self-caused weight; react() restores after one.
+        this._model.setPrecision('attention.usage',         ACP_SELF_PRECISION )
+        this._model.setPrecision('attention.free_fraction', ACP_SELF_PRECISION )
+        this._acpOneShot = true
         break
       }
       default:
         // senses.*.percept — use the event's pre-computed salience as an
         // attention signal for the percept's source entity.
-        if( e.type.startsWith( 'senses.' ) ){
+        if( e.type.startsWith('senses.') ){
           const percept = e.payload as { sourceEntityId?: string; salience?: number }
           if( percept.sourceEntityId )
-            this._model.observe( `attention.entity.${percept.sourceEntityId}`, e.salience )
+            this._model.observe(`attention.entity.${percept.sourceEntityId}`, e.salience )
         }
         break
     }
@@ -194,7 +241,7 @@ export class AttentionAllocator implements SimulationEngine, CognitiveEngine {
     const
     energyLevel      = this._energyLevel,
     sleepPressure    = this._sleepPressure,
-    arousal          = state.metrics.get( 'affect.arousal' ) ?? AROUSAL_REST,
+    arousal          = state.metrics.get('affect.arousal') ?? AROUSAL_REST,
     energyFactor     = energyLevel < 30 ? 0.3 + ( energyLevel / 30 ) * 0.7 : 1.0,
     sleepFactor      = sleepPressure > 40
                          ? 1 - ( ( sleepPressure - 40 ) / 60 ) * 0.5
@@ -296,8 +343,16 @@ export class AttentionAllocator implements SimulationEngine, CognitiveEngine {
     // load — and thus usage — is steady; otherwise the budget would not move in a
     // quiet mind.
     if( _bus ){
-      const usageErr = this._model.observe( 'attention.usage', attentionUsage )
-      const freeErr  = this._model.observe( 'attention.free_fraction', freeFraction )
+      const usageErr = this._model.observe('attention.usage', attentionUsage )
+      const freeErr  = this._model.observe('attention.free_fraction', freeFraction )
+      // ACP-P2: the self-caused observe has happened — restore full precision
+      // immediately so a genuine world surprise NEXT tick is not dampened
+      // (the model's own mean-reversion would take ~50 observes).
+      if( this._acpOneShot ){
+        this._model.setPrecision('attention.usage',         1.0 )
+        this._model.setPrecision('attention.free_fraction', 1.0 )
+        this._acpOneShot = false
+      }
       if( !usageErr.gated || !freeErr.gated )
         _bus.publish({ type: 'attention.state.changed', version: 1, sourceEngine: this.name, salience: Math.max( usageErr.salience, freeErr.salience ), payload: { usage: attentionUsage, focusCount, capacity: effectiveCapacity, freeFraction } })
     }
@@ -310,7 +365,7 @@ export class AttentionAllocator implements SimulationEngine, CognitiveEngine {
     // Effective config = base engine-config-attention ⊕ persona-prior (single-source).
     // The persona-consolidator lowers shiftInertia on belief-formation bias (edge 8)
     // → attention shifts more readily, loosening the fixation that feeds the bias.
-    const p = readEffectiveParams( state, 'engine-config-attention' )
+    const p = readEffectiveParams( state, 'engine-config-attention')
     if( p.maxCapacity  != null ) this._maxCapacity  = p.maxCapacity
     if( p.costPerFocus != null ) this._costPerFocus = p.costPerFocus
     if( p.maxFoci      != null ) this._maxFoci      = p.maxFoci

package/src/cognition/faculties/autobiographical.narrator.ts

@@ -107,7 +107,7 @@ export class AutobiographicalNarrator implements SimulationEngine, CognitiveEngi
       case 'executive.prediction.formed': {
         const p = e.payload as { predictedDomains: string[]; confidence: number }
         if( p.predictedDomains.includes('narrative') )
-          this._model.setPrecision( 'narrative.change', 1.0 + p.confidence * 0.5 )
+          this._model.setPrecision('narrative.change', 1.0 + p.confidence * 0.5 )
         break
       }
     }
@@ -245,7 +245,7 @@ export class AutobiographicalNarrator implements SimulationEngine, CognitiveEngi
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus && this._narrative.version > 0 ){
-      const predErr = this._model.observe( 'narrative.change', narrativeSignificance )
+      const predErr = this._model.observe('narrative.change', narrativeSignificance )
       if( !predErr.gated )
         _bus.publish({ type: 'narrative.updated', version: 1, sourceEngine: this.name, salience: Math.max( 0.2, predErr.salience ), payload: { version: this._narrative.version, significance: narrativeSignificance } })
     }
@@ -269,7 +269,7 @@ export class AutobiographicalNarrator implements SimulationEngine, CognitiveEngi
    * re-narrates its life story sooner.
    */
   private _readConfigFromState( state: ReadonlySimulationState ): void {
-    const p = readEffectiveParams( state, 'engine-config-narrator' )
+    const p = readEffectiveParams( state, 'engine-config-narrator')
     if( p.minIntervalTicks   != null ) this._minIntervalTicks   = p.minIntervalTicks
     if( p.maxNarrativeLength != null ) this._maxNarrativeLength = p.maxNarrativeLength
   }

package/src/cognition/faculties/bias.detector.ts

@@ -100,7 +100,7 @@ export class BiasDetector implements SimulationEngine, CognitiveEngine {
       case 'executive.prediction.formed': {
         const p = e.payload as { predictedDomains: string[]; confidence: number }
         if( p.predictedDomains.includes('metacognition') )
-          this._model.setPrecision( 'bias.novelty', 1.0 + p.confidence * 0.5 )
+          this._model.setPrecision('bias.novelty', 1.0 + p.confidence * 0.5 )
 
         break
       }
@@ -168,7 +168,7 @@ export class BiasDetector implements SimulationEngine, CognitiveEngine {
       // Surprise is driven by how many biases *this scan* surfaced, not the
       // cumulative count (which only grows, then saturates against the prune
       // cap — a near-constant the gate could never read as surprising).
-      const predErr = this._model.observe( 'bias.novelty', newBiases.length )
+      const predErr = this._model.observe('bias.novelty', newBiases.length )
       if( !predErr.gated )
         _bus.publish({
           type: 'bias.detected',
@@ -193,7 +193,7 @@ export class BiasDetector implements SimulationEngine, CognitiveEngine {
    * mirror) and stays constructor-only to avoid a lossy numeric coercion.
    */
   private _readConfigFromState( state: ReadonlySimulationState ): void {
-    const p = readEffectiveParams( state, 'engine-config-bias-detector' )
+    const p = readEffectiveParams( state, 'engine-config-bias-detector')
 
     if( p.minDecisions      != null ) this._minDecisions      = p.minDecisions
     if( p.scanIntervalTicks != null ) this._scanIntervalTicks = p.scanIntervalTicks
@@ -209,7 +209,7 @@ export class BiasDetector implements SimulationEngine, CognitiveEngine {
     // 1. Overgeneralization: high-confidence beliefs from few episodes
     {
       const
-      beliefs = [ ...state.entities.values() ].filter( e => e.type === 'belief' )
+      beliefs = [ ...state.entities.values() ].filter( e => e.type === 'belief')
                                               .map( e => ({
                                                 confidence: ( e.metadata?.['confidence'] as number ) ?? 0,
                                                 supportingEpisodes: ( e.metadata?.['supportingEpisodes'] as number ) ?? 0,
@@ -230,7 +230,7 @@ export class BiasDetector implements SimulationEngine, CognitiveEngine {
     // 2. Recency bias: check if decisions heavily weight recent memories
     {
       const allEpisodes = [ ...state.entities.values() ]
-        .filter( e => e.type === 'episodic_memory' )
+        .filter( e => e.type === 'episodic_memory')
         .map( e => ({ timestamp: ( e.metadata?.['tick'] as number ) ?? 0 }))
       if( allEpisodes.length > 20 ){
         // `e.timestamp` is an episode tick, so the recency window is 50 ticks.
@@ -281,7 +281,7 @@ export class BiasDetector implements SimulationEngine, CognitiveEngine {
     //    bias-detection has a single home (introspection used to detect these too).
     {
       const decisions = [ ...state.entities.values() ]
-        .filter( e => e.type === 'decision.record' )
+        .filter( e => e.type === 'decision.record')
         .map( e => ({
           actionType: ( e.metadata?.['actionType'] as string ) ?? 'unknown',
           confidence: ( e.metadata?.['confidence'] as number ) ?? 0.5,
@@ -328,7 +328,7 @@ export class BiasDetector implements SimulationEngine, CognitiveEngine {
    */
   private _executiveCorroborates( type: string ): boolean {
     if( this._executiveNamedBiases.size === 0 ) return false
-    const norm = ( s: string ): string => s.toLowerCase().replace( /[^a-z]/g, '' )
+    const norm = ( s: string ): string => s.toLowerCase().replace( /[^a-z]/g, '')
     const t = norm( type )
     for( const named of this._executiveNamedBiases ){
       const n = norm( named )

package/src/cognition/faculties/circadian.oscillator.ts

@@ -79,10 +79,10 @@ export class CircadianOscillator implements SimulationEngine, CognitiveEngine {
 
   onCognitiveEvent( e: CognitiveEvent ): StateCommands | void {
     this._model.observe( e.type, e.salience )
-    if( e.type === 'executive.prediction.formed' ){
+    if( e.type === 'executive.prediction.formed'){
       const p = e.payload as { predictedDomains: string[]; confidence: number }
       if( p.predictedDomains.includes('circadian') )
-        this._model.setPrecision( 'circadian.alertness', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('circadian.alertness', 1.0 + p.confidence * 0.5 )
     }
   }
 
@@ -249,7 +249,7 @@ export class CircadianOscillator implements SimulationEngine, CognitiveEngine {
       _bus.publish({ type: 'circadian.alertness.shifted', version: 1, sourceEngine: this.name, salience: Math.abs(alertnessSignal - 0.5) * 0.6, payload: { alertness: alertnessSignal, phase: phaseLabel } })
     // Phase D + F: rich state-change event — gated by prediction error
     if( _bus ){
-      const predErr = this._model.observe( 'circadian.alertness', alertnessSignal )
+      const predErr = this._model.observe('circadian.alertness', alertnessSignal )
       if( !predErr.gated )
         _bus.publish({ type: 'circadian.state.changed', version: 1, sourceEngine: this.name, salience: predErr.salience, payload: { alertness: alertnessSignal, timeOfDay, phaseCode, moodBaseline: moodSignal } })
     }

package/src/cognition/faculties/confidence.calibrator.ts

@@ -97,7 +97,7 @@ export class ConfidenceCalibrator implements SimulationEngine, CognitiveEngine {
       case 'executive.prediction.formed': {
         const p = e.payload as { predictedDomains: string[]; confidence: number }
         if( p.predictedDomains.includes('metacognition') )
-          this._model.setPrecision( 'metacognition.bias', 1.0 + p.confidence * 0.5 )
+          this._model.setPrecision('metacognition.bias', 1.0 + p.confidence * 0.5 )
 
         break
       }
@@ -105,7 +105,7 @@ export class ConfidenceCalibrator implements SimulationEngine, CognitiveEngine {
         // Pair the decision's predicted confidence against the realised outcome
         // quality so per-domain over/under-confidence can be learned in react().
         const p = e.payload as { domain?: string; confidence?: number; outcomeQuality?: number; tick?: number }
-        if( typeof p.confidence === 'number' && typeof p.outcomeQuality === 'number' )
+        if( typeof p.confidence === 'number' && typeof p.outcomeQuality === 'number')
           this.recordOutcome( p.domain ?? 'general', p.confidence, p.outcomeQuality, ( ( p.tick ?? 0 ) as Tick ) )
 
         break
@@ -130,7 +130,7 @@ export class ConfidenceCalibrator implements SimulationEngine, CognitiveEngine {
   restore( snap: Record<string, unknown> ): void {
     if( !snap ) return
 
-    if( typeof snap.executiveFlaggedBiasCount === 'number' )
+    if( typeof snap.executiveFlaggedBiasCount === 'number')
       this._executiveFlaggedBiasCount = snap.executiveFlaggedBiasCount
 
     if( Array.isArray( snap.records ) )
@@ -154,7 +154,7 @@ export class ConfidenceCalibrator implements SimulationEngine, CognitiveEngine {
     if( !m ) return
 
     for( const [ domain, bias ] of Object.entries( m ) )
-      if( typeof bias === 'number' )
+      if( typeof bias === 'number')
         this._domainBias.set( domain, bias )
   }
 
@@ -195,7 +195,7 @@ export class ConfidenceCalibrator implements SimulationEngine, CognitiveEngine {
    * tunables and lets a future persona-prior modulate calibration aggressiveness.
    */
   private _readConfigFromState( state: ReadonlySimulationState ): void {
-    const p = readEffectiveParams( state, 'engine-config-confidence' )
+    const p = readEffectiveParams( state, 'engine-config-confidence')
 
     if( p.minSamplesPerDomain != null ) this._minSamplesPerDomain = p.minSamplesPerDomain
     if( p.calibrationRate     != null ) this._calibrationRate     = p.calibrationRate
@@ -286,13 +286,13 @@ export class ConfidenceCalibrator implements SimulationEngine, CognitiveEngine {
         type: 'confidence.calibrated',
         version: 1,
         sourceEngine: this.name,
-        salience: Math.max( 0.2, this._model.observe( 'calibration.event', overallBias ).salience ),
+        salience: Math.max( 0.2, this._model.observe('calibration.event', overallBias ).salience ),
         payload: { calibrationBias: overallBias }
       })
     
     // Phase D + F: rich state-change event — gated by prediction error
     if( _bus ){
-      const predErr = this._model.observe( 'metacognition.bias', overallBias )
+      const predErr = this._model.observe('metacognition.bias', overallBias )
       if( !predErr.gated )
         _bus.publish({
           type: 'metacognition.state.changed',

package/src/cognition/faculties/dream.simulator.ts

@@ -87,13 +87,13 @@ export class DreamSimulator implements SimulationEngine, CognitiveEngine {
 
   onCognitiveEvent( e: CognitiveEvent ): StateCommands | void {
     this._model.observe( e.type, e.salience )
-    if( e.type === 'executive.prediction.formed' ){
+    if( e.type === 'executive.prediction.formed'){
       const p = e.payload as { predictedDomains: string[]; confidence: number }
       if( p.predictedDomains.includes('memory') )
-        this._model.setPrecision( 'dream.reactivation', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('dream.reactivation', 1.0 + p.confidence * 0.5 )
     }
-    if( e.type === 'sleep.begun' ) this._isSleeping = true
-    if( e.type === 'sleep.ended' ) this._isSleeping = false
+    if( e.type === 'sleep.begun') this._isSleeping = true
+    if( e.type === 'sleep.ended') this._isSleeping = false
   }
 
   snapshot(): Record<string, unknown> { return {} }
@@ -197,7 +197,7 @@ export class DreamSimulator implements SimulationEngine, CognitiveEngine {
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus && reactivated > 0 ){
-      const predErr = this._model.observe( 'dream.reactivation', reactivated )
+      const predErr = this._model.observe('dream.reactivation', reactivated )
       if( !predErr.gated )
         _bus.publish({ type: 'dream.active', version: 1, sourceEngine: this.name, salience: Math.max( 0.3, predErr.salience ), payload: { reactivated } })
     }

package/src/cognition/faculties/empathy.simulator.ts

@@ -90,14 +90,14 @@ export class EmpathySimulator implements SimulationEngine, CognitiveEngine {
 
   onCognitiveEvent( e: CognitiveEvent ): StateCommands | void {
     this._model.observe( e.type, e.salience )
-    if( e.type === 'executive.prediction.formed' ){
+    if( e.type === 'executive.prediction.formed'){
       const p = e.payload as { predictedDomains: string[]; confidence: number }
       if( p.predictedDomains.includes('social') )
-        this._model.setPrecision( 'empathy.active', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('empathy.active', 1.0 + p.confidence * 0.5 )
     }
-    if( e.type === 'interaction.occurred' ){
+    if( e.type === 'interaction.occurred'){
       const p = e.payload as { keid: string; valence: number; intensity: number; directedAtSelf: boolean }
-      if( p.keid && p.keid !== 'agent-self' )
+      if( p.keid && p.keid !== 'agent-self')
         this._pendingInteractions.push( p )
     }
   }
@@ -117,7 +117,7 @@ export class EmpathySimulator implements SimulationEngine, CognitiveEngine {
     // Channel A (agreeableness → empathy): how strongly the Will resonates with others'
     // emotions is refreshed each tick as base ⊕ persona-prior. An agreeable Will develops
     // a higher resonance and feels others' states more. (Seed existed but was ignored.)
-    this._resonanceStrength = readEffectiveParams( state, 'engine-config-empathy' ).resonanceStrength ?? this._resonanceStrength
+    this._resonanceStrength = readEffectiveParams( state, 'engine-config-empathy').resonanceStrength ?? this._resonanceStrength
 
     if( !this._theoryOfMind ){
       commands.metrics!.push([ 'empathy.active_models', 0 ])
@@ -183,7 +183,7 @@ export class EmpathySimulator implements SimulationEngine, CognitiveEngine {
     // blender folds the vicarious valence/arousal into the blended PAD.
     let vicariousValence = 0, vicariousArousal = 0
     for( const es of empathicStates ){
-      const bond = ( state.entities.get( `bond-${es.targetKeid}` )?.metadata?.attachmentStrength as number ) ?? 0
+      const bond = ( state.entities.get(`bond-${es.targetKeid}`)?.metadata?.attachmentStrength as number ) ?? 0
       const w = es.resonanceStrength * ( 1 + EMPATHY_BOND_AMPLIFY * bond )
       vicariousValence += es.estimatedEmotion.valence * w
       vicariousArousal += es.estimatedEmotion.arousal * w
@@ -217,7 +217,7 @@ export class EmpathySimulator implements SimulationEngine, CognitiveEngine {
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus && empathicStates.length > 0 ){
-      const predErr = this._model.observe( 'empathy.active', empathicStates.length )
+      const predErr = this._model.observe('empathy.active', empathicStates.length )
       if( !predErr.gated )
         _bus.publish({ type: 'empathy.resonance', version: 1, sourceEngine: this.name, salience: Math.max( 0.3, predErr.salience ), payload: { activeModels: empathicStates.length } })
     }

package/src/cognition/faculties/energy.regulator.ts

@@ -93,10 +93,10 @@ export class EnergyRegulator implements SimulationEngine, CognitiveEngine {
 
   onCognitiveEvent( e: CognitiveEvent ): StateCommands | void {
     this._model.observe( e.type, e.salience )
-    if( e.type === 'executive.prediction.formed' ){
+    if( e.type === 'executive.prediction.formed'){
       const p = e.payload as { predictedDomains: string[]; confidence: number }
       if( p.predictedDomains.includes('energy') )
-        this._model.setPrecision( 'energy.level', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('energy.level', 1.0 + p.confidence * 0.5 )
     }
   }
 
@@ -290,11 +290,11 @@ export class EnergyRegulator implements SimulationEngine, CognitiveEngine {
     // Phase C: publish cognitive event
     const _bus = this._bus
     if( _bus && newEnergy < 20 )
-      _bus.publish({ type: 'energy.level.critical', version: 1, sourceEngine: this.name, salience: Math.max( 0.8, this._model.observe( 'energy.critical', 1 - newEnergy / 100 ).salience ), payload: { level: newEnergy } })
+      _bus.publish({ type: 'energy.level.critical', version: 1, sourceEngine: this.name, salience: Math.max( 0.8, this._model.observe('energy.critical', 1 - newEnergy / 100 ).salience ), payload: { level: newEnergy } })
     // Phase D + F: rich state-change event — gated by prediction error
     if( _bus ){
       const zoneCode = newEnergy < this._criticalThreshold ? 0 : newEnergy < this._lowThreshold ? 1 : 2
-      const predErr  = this._model.observe( 'energy.level', newEnergy )
+      const predErr  = this._model.observe('energy.level', newEnergy )
       if( !predErr.gated )
         _bus.publish({ type: 'energy.state.changed', version: 1, sourceEngine: this.name, salience: predErr.salience, payload: { level: newEnergy, zoneCode, stressLoad: state.metrics.get('stress.load') ?? 0, interoceptionComfort: state.metrics.get('interoception.comfort') ?? 0.5 } })
     }

package/src/cognition/faculties/episodic.consolidator.ts

@@ -234,7 +234,7 @@ export class EpisodicConsolidator implements SimulationEngine, CognitiveEngine {
         type: string,
         tags: string[],
       ): EpisodicMemory['outcomeStatus'] => {
-        if( type === 'conversation.exchange' ) return 'confirmed'
+        if( type === 'conversation.exchange') return 'confirmed'
         if( tags.includes('failed') || tags.includes('error') || tags.includes('timed_out') ) return 'failed'
         if( tags.includes('completed') || tags.includes('success') || tags.includes('confirmed') ) return 'confirmed'
         if( tags.includes('goal') || tags.includes('plan') ) return 'intended'
@@ -413,7 +413,7 @@ export class EpisodicConsolidator implements SimulationEngine, CognitiveEngine {
     // facet chains await this inside prompt building, so an unbounded hang here
     // stalls the mind's reasoning and everything downstream of it.
     // WILL_RECALL_TIMEOUT_MS (default 5000) — read lazily for tests/live tuning.
-    const timeoutMs = parseInt( process.env.WILL_RECALL_TIMEOUT_MS ?? '5000' )
+    const timeoutMs = parseInt( process.env.WILL_RECALL_TIMEOUT_MS ?? '5000')
     let timer: ReturnType<typeof setTimeout> | undefined
     const timedOut = Symbol('recall-timeout')
 
@@ -426,7 +426,7 @@ export class EpisodicConsolidator implements SimulationEngine, CognitiveEngine {
     ] ).finally( () => clearTimeout( timer ) )
 
     if( results === timedOut ){
-      logger.warn( `[EpisodicConsolidator] semanticQuery timed out after ${timeoutMs}ms — returning no recall (embedder slow/unreachable?)` )
+      logger.warn(`[EpisodicConsolidator] semanticQuery timed out after ${timeoutMs}ms — returning no recall (embedder slow/unreachable?)`)
       return []
     }
 
@@ -659,13 +659,13 @@ export class EpisodicConsolidator implements SimulationEngine, CognitiveEngine {
       await this._vectorMemory.load()
       if( this._vectorMemory.size === 0 && this._store.length > 0 ){
         await this._vectorMemory.rebuildFromStore( this._store )
-        logger.info( `[episodic] vector index rebuilt with ${this._store.length} episodes` )
+        logger.info(`[episodic] vector index rebuilt with ${this._store.length} episodes`)
       } else if( this._vectorMemory.size > 0 ){
-        logger.info( `[episodic] vector index loaded from disk (${this._vectorMemory.size} entries)` )
+        logger.info(`[episodic] vector index loaded from disk (${this._vectorMemory.size} entries)`)
       }
     }
 
-    logger.info( `[episodic] restored ${this._store.length} episodes from snapshot` )
+    logger.info(`[episodic] restored ${this._store.length} episodes from snapshot`)
   }
 
   // ── Internal ─────────────────────────────────────────────

package/src/cognition/faculties/executive.engine/commands.ts

@@ -148,7 +148,7 @@ export function buildStateCommands(
     const integrator = deps.semanticIntegrator
     const bus        = deps.bus
     output.knownEntityUpdates.forEach( ( u, ui ) => {
-      if( !u.keid || u.keid === 'agent-self' ) return
+      if( !u.keid || u.keid === 'agent-self') return
 
       const facts = u.learned ?? []
       facts.forEach( ( fact, fi ) => {
@@ -380,7 +380,7 @@ const COMMUNICATE_ACTION_TYPES = new Set([
 function resolveKnownEntity( target: string, state: ReadonlySimulationState ): string | undefined {
   const t = target.trim().toLowerCase()
   for( const e of state.entities.values() ){
-    if( e.type !== 'known-entity' ) continue
+    if( e.type !== 'known-entity') continue
     const m    = e.metadata as Record<string, unknown> | undefined
     const keid = typeof m?.['keid'] === 'string' ? m['keid'] as string : undefined
     const name = typeof m?.['name'] === 'string' ? m['name'] as string : undefined
@@ -414,9 +414,9 @@ function buildIdeomotorIntents(
   // the executive can only pre-activate what the situation actually offers.
   const externalBySchema = new Map<string, string>()
   for( const e of state.entities.values() ){
-    if( e.type !== 'affordance' ) continue
+    if( e.type !== 'affordance') continue
     const m = e.metadata as Record<string, unknown> | undefined
-    if( m?.['source'] !== 'external' ) continue
+    if( m?.['source'] !== 'external') continue
     const schema = typeof m['schema'] === 'string' ? m['schema'] as string : undefined
     if( schema ) externalBySchema.set( schema.toLowerCase(), schema )
   }
@@ -439,8 +439,8 @@ function buildIdeomotorIntents(
 
     // A host ability the executive imagines enacting, with its conscious args.
     const schema = externalBySchema.get( t )
-    if( !schema || seen.has( `ability:${ schema }` ) ) continue
-    seen.add( `ability:${ schema }` )
+    if( !schema || seen.has(`ability:${ schema }`) ) continue
+    seen.add(`ability:${ schema }`)
     const keid = action.target ? resolveKnownEntity( action.target, state ) : undefined
     set.push({
       id:   `ideomotor-${ schema }${ keid ? `-${ keid }` : '' }`,