@mindot/will 0.4.0 → 0.6.0

package/src/cognition/faculties/self.model.updater.ts

@@ -167,7 +167,7 @@ export class SelfModelUpdater extends AsyncEngine implements CognitiveEngine {
       case 'executive.prediction.formed': {
         const p = e.payload as { predictedDomains: string[]; confidence: number }
         if( p.predictedDomains.includes('metacognition') )
-          this._model.setPrecision( 'self_model.change', 1.0 + p.confidence * 0.5 )
+          this._model.setPrecision('self_model.change', 1.0 + p.confidence * 0.5 )
         
         break
       }
@@ -196,13 +196,13 @@ export class SelfModelUpdater extends AsyncEngine implements CognitiveEngine {
   restore( snap: Record<string, unknown> ): void {
     if( !snap ) return
 
-    if( typeof snap.executiveReflectionTick === 'number' ) 
+    if( typeof snap.executiveReflectionTick === 'number') 
       this._executiveReflectionTick = snap.executiveReflectionTick
 
-    if( typeof snap.lastEvaluationTick === 'number' )
+    if( typeof snap.lastEvaluationTick === 'number')
       this._lastEvaluationTick = snap.lastEvaluationTick
 
-    if( typeof snap.experienceCountAtLastEval === 'number' )
+    if( typeof snap.experienceCountAtLastEval === 'number')
       this._experienceCountAtLastEval = snap.experienceCountAtLastEval
     
     if( Array.isArray( snap.domainPerformance ) )
@@ -231,7 +231,7 @@ export class SelfModelUpdater extends AsyncEngine implements CognitiveEngine {
     // closed edge of the metacognition cycle: a learned prior (written back by
     // the consolidator from the Will's own introspection) modulates how often
     // the self-model re-evaluates, without ever mutating the seeded base.
-    const p = readEffectiveParams( state, 'engine-config-self-model' )
+    const p = readEffectiveParams( state, 'engine-config-self-model')
 
     if( p.minIntervalTicks != null ) this._minIntervalTicks = p.minIntervalTicks
     if( p.minNewExperiences != null ) this._minNewExperiences = p.minNewExperiences
@@ -483,7 +483,7 @@ export class SelfModelUpdater extends AsyncEngine implements CognitiveEngine {
             supportingEpisodes: da.sampleSize,
             lastUpdatedAt:      tick,
             tags:               [ da.domain, 'competence', 'self', 'positive' ]
-          }, tick, 'self-model' )
+          }, tick, 'self-model')
         
         else if( da.successRate < 0.30 )
           this._semanticIntegrator.integrateExecutiveBelief({
@@ -494,14 +494,14 @@ export class SelfModelUpdater extends AsyncEngine implements CognitiveEngine {
             supportingEpisodes: da.sampleSize,
             lastUpdatedAt:      tick,
             tags:               [ da.domain, 'competence', 'self', 'negative' ]
-          }, tick, 'self-model' )
+          }, tick, 'self-model')
       }
     }
 
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus ){
-      const predErr = this._model.observe( 'self_model.change', changeMagnitude )
+      const predErr = this._model.observe('self_model.change', changeMagnitude )
       if( !predErr.gated )
         _bus.publish({ 
           type: 'self_model.updated',

package/src/cognition/faculties/semantic.engine/integrator.ts

@@ -87,7 +87,7 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
    * Confidence is capped by evidence count before integration — prevents the
    * executive from asserting high-certainty beliefs from thin episodic support.
    */
-  integrateExecutiveBelief( belief: Belief, tick?: number, cause = 'executive' ): void {
+  integrateExecutiveBelief( belief: Belief, tick?: number, cause = 'executive'): void {
     const capped = this._capConfidenceByEvidence( belief.confidence, belief.supportingEpisodes )
     const result = this._integrateBelief({ ...belief, confidence: capped }, cause )
 
@@ -118,7 +118,7 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
    */
   private _restoreFromState( state: ReadonlySimulationState ): void {
     for( const entity of state.entities.values() ){
-      if( entity.type !== 'belief' ) continue
+      if( entity.type !== 'belief') continue
       if( this._beliefs.some( b => b.id === entity.id ) ) continue
 
       const m = entity.metadata ?? {}
@@ -160,7 +160,7 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
       case 'executive.prediction.formed': {
         const p = e.payload as { predictedDomains: string[]; confidence: number }
         if( p.predictedDomains.includes('memory') )
-          this._model.setPrecision( 'belief.count', 1.0 + p.confidence * 0.5 )
+          this._model.setPrecision('belief.count', 1.0 + p.confidence * 0.5 )
 
         break
       }
@@ -201,7 +201,7 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
         if( payload.knownEntityUpdates )
           for( const u of payload.knownEntityUpdates )
             for( const fact of u.learned ?? [] )
-              if( fact && u.keid && u.keid !== 'agent-self' )
+              if( fact && u.keid && u.keid !== 'agent-self')
                 this.integrateExecutiveBelief({
                   id: `belief-ke-facet-${( this._idSeq++ ).toString( 36 )}`,
                   statement: fact,
@@ -224,7 +224,7 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
    * No-op at boot: mirror params equal the constructor defaults (reconciled in #83).
    */
   private _readConfigFromState( state: ReadonlySimulationState ): void {
-    const p = readEffectiveParams( state, 'engine-config-semantic' )
+    const p = readEffectiveParams( state, 'engine-config-semantic')
     if( p.minIntervalTicks         != null ) this._minIntervalTicks         = p.minIntervalTicks
     if( p.minNewEpisodes           != null ) this._minNewEpisodes           = p.minNewEpisodes
     if( p.maxBeliefs               != null ) this._maxBeliefs               = p.maxBeliefs
@@ -259,7 +259,7 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
     if( this._episodicConsolidator && this._shouldRunHeuristic( tick ) ){
       const newBeliefs = await this._heuristicPatternDetection( tick, state )
       for( const belief of newBeliefs )
-        this._integrateBelief( belief, 'heuristic' )
+        this._integrateBelief( belief, 'heuristic')
       
       this._lastIntegrationTick = tick
       if( this._episodicConsolidator )
@@ -283,7 +283,7 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
         const prev = belief.confidence
         belief.confidence = Math.max( 0.10, belief.confidence - this._beliefDecayRate )
         if( belief.confidence !== prev )
-          SemanticIntegrator._recordHistory( belief, tick, prev, 'decayed' )
+          SemanticIntegrator._recordHistory( belief, tick, prev, 'decayed')
       }
     }
 
@@ -315,7 +315,7 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus && this._beliefs.length > 0 ){
-      const predErr = this._model.observe( 'belief.count', this._beliefs.length )
+      const predErr = this._model.observe('belief.count', this._beliefs.length )
       if( !predErr.gated )
         _bus.publish({
           type: 'belief.updated',
@@ -531,7 +531,7 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
       .sort( ( a, b ) => b[1] - a[1] )
       .find( ( [ , count ] ) => count > semanticResults.length * 0.5 )
     
-    if( dominantSource && dominantSource[0] !== 'unknown' ){
+    if( dominantSource && dominantSource[0] !== 'unknown'){
       beliefs.push({
         id: `belief-semantic-source-${( this._idSeq++ ).toString( 36 )}`,
         statement: `My semantically similar experiences tend to come from: ${dominantSource[0]}`,
@@ -567,7 +567,7 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
       .map( ( [ tag ] ) => tag )
     
     if( topTags.length > 0 ){
-      parts.push( `Themes: ${topTags.join( ', ' )}` )
+      parts.push(`Themes: ${topTags.join(', ')}`)
     }
     
     // Add a sample of recent episode content (first 3, truncated)
@@ -581,17 +581,17 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
       })
     
     if( contentSamples.length > 0 ){
-      parts.push( `Recent experiences: ${contentSamples.join( '; ' )}` )
+      parts.push(`Recent experiences: ${contentSamples.join('; ')}`)
     }
     
     // Add affective context if consistent
     const valenceSum = episodes.reduce( ( s, ep ) => s + ( ep.affectiveContext?.valence ?? 0 ), 0 )
     const meanValence = valenceSum / episodes.length
     if( Math.abs( meanValence ) > 0.2 ){
-      parts.push( `Emotional tone: ${meanValence > 0 ? 'positive' : 'negative'}` )
+      parts.push(`Emotional tone: ${meanValence > 0 ? 'positive' : 'negative'}`)
     }
     
-    return parts.length > 0 ? parts.join( '. ' ) : 'What patterns emerge from my recent experiences?'
+    return parts.length > 0 ? parts.join('. ') : 'What patterns emerge from my recent experiences?'
   }
 
   // ── Belief management ────────────────────────────────────
@@ -620,7 +620,7 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
     belief.history = next
   }
 
-  private _integrateBelief( newBelief: Belief, cause = 'created' ): Belief {
+  private _integrateBelief( newBelief: Belief, cause = 'created'): Belief {
     const existing = this._beliefs.find( b => this._shouldMerge( b, newBelief ) )
 
     if( existing ){
@@ -628,7 +628,7 @@ export class SemanticIntegrator implements SimulationEngine, CognitiveEngine {
       existing.confidence      = ( existing.confidence + newBelief.confidence ) / 2
       existing.supportingEpisodes += newBelief.supportingEpisodes
       existing.lastUpdatedAt   = newBelief.lastUpdatedAt
-      SemanticIntegrator._recordHistory( existing, newBelief.lastUpdatedAt, prev, 'reinforced' )
+      SemanticIntegrator._recordHistory( existing, newBelief.lastUpdatedAt, prev, 'reinforced')
       return existing
     }
 

package/src/cognition/faculties/sleep.pressure.regulator.ts

@@ -84,10 +84,10 @@ export class SleepPressureRegulator 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('interoception') )
-        this._model.setPrecision( 'sleep.pressure', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('sleep.pressure', 1.0 + p.confidence * 0.5 )
     }
   }
 
@@ -224,10 +224,10 @@ export class SleepPressureRegulator implements SimulationEngine, CognitiveEngine
     // Phase C: publish cognitive event
     const _bus = this._bus
     if( _bus && newPressure > 70 )
-      _bus.publish({ type: 'sleep.pressure.critical', version: 1, sourceEngine: this.name, salience: Math.max( 0.7, this._model.observe( 'sleep.critical', newPressure ).salience ), payload: { pressure: newPressure } })
+      _bus.publish({ type: 'sleep.pressure.critical', version: 1, sourceEngine: this.name, salience: Math.max( 0.7, this._model.observe('sleep.critical', newPressure ).salience ), payload: { pressure: newPressure } })
     // Phase D + F: rich state-change event — gated by prediction error
     if( _bus ){
-      const predErr = this._model.observe( 'sleep.pressure', newPressure )
+      const predErr = this._model.observe('sleep.pressure', newPressure )
       if( !predErr.gated )
         _bus.publish({ type: 'sleep.state.changed', version: 1, sourceEngine: this.name, salience: predErr.salience, payload: { pressure: newPressure, intensity } })
     }

package/src/cognition/faculties/social.perception.ts

@@ -88,10 +88,10 @@ export class SocialPerception 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( 'social.agent_count', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('social.agent_count', 1.0 + p.confidence * 0.5 )
     }
   }
 
@@ -159,7 +159,7 @@ export class SocialPerception implements SimulationEngine, CognitiveEngine {
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus && activeAgents > 0 ){
-      const predErr = this._model.observe( 'social.agent_count', activeAgents )
+      const predErr = this._model.observe('social.agent_count', activeAgents )
       if( !predErr.gated )
         _bus.publish({ type: 'social.agents.present', version: 1, sourceEngine: this.name, salience: Math.max( 0.3, predErr.salience ), payload: { activeAgents } })
     }

package/src/cognition/faculties/spaced.repetition.ts

@@ -471,7 +471,7 @@ export class SpacedRepetition implements SimulationEngine, CognitiveEngine {
       belief.lastUpdatedAt = tick
       
       // Record history if SemanticIntegrator exposes it
-      this._recordBeliefHistory( belief, tick, prevConfidence, 'spaced_repetition_reinforced' )
+      this._recordBeliefHistory( belief, tick, prevConfidence, 'spaced_repetition_reinforced')
     }
     else {
       // Failed review — reset interval and decrease confidence
@@ -483,7 +483,7 @@ export class SpacedRepetition implements SimulationEngine, CognitiveEngine {
       belief.confidence = newConfidence
       belief.lastUpdatedAt = tick
       
-      this._recordBeliefHistory( belief, tick, prevConfidence, 'spaced_repetition_failed' )
+      this._recordBeliefHistory( belief, tick, prevConfidence, 'spaced_repetition_failed')
     }
 
     record.lastReviewedAt = tick

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

@@ -33,6 +33,7 @@ import type { SimulationEngine, EngineResult, CognitiveEngine } 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 StressRegulatorConfig {
@@ -93,7 +94,9 @@ export class StressRegulator implements SimulationEngine, CognitiveEngine {
   // ── Engine interface ─────────────────────────────────────
 
 
-  subscribes(): string[] { return ["energy.state.changed","sleep.state.changed","novelty.state.changed","goal.state.changed","metacognition.state.changed","executive.prediction.formed"] }
+  subscribes(): string[] { return ["energy.state.changed","sleep.state.changed","novelty.state.changed","goal.state.changed","metacognition.state.changed","executive.prediction.formed",
+    // ACP-P2: our own enactions — the stress swing they cause is expected
+    "agency.enacted","agency.communicate","agency.invocation"] }
   publishes(): CognitiveEventSchema[] { return [] }
 
   onCognitiveEvent( e: CognitiveEvent ): StateCommands | void {
@@ -120,9 +123,24 @@ export class StressRegulator implements SimulationEngine, CognitiveEngine {
           this._model.setPrecision('stress.load', 1.0 + p.confidence * 0.5)
         break
       }
+      case 'agency.enacted':
+      case 'agency.communicate':
+      case 'agency.invocation': {
+        // ACP-P2 (final inventoried consumer): we just acted — the stress
+        // swing that follows is our own doing. Precision-only (no directional
+        // prior: acting can LOAD or RELIEVE, so we don't pretend to know the
+        // sign); react() restores after one observe so a genuine world
+        // stressor next tick lands at full weight.
+        this._model.setPrecision('stress.load', ACP_SELF_PRECISION )
+        this._acpOneShot = true
+        break
+      }
     }
   }
 
+  /** ACP-P2: self-caused stress attenuation armed; react() restores after one observe. */
+  private _acpOneShot = false
+
   snapshot(): Record<string, unknown> {
     return {
       energyLevel: this._energyLevel,
@@ -261,12 +279,17 @@ export class StressRegulator implements SimulationEngine, CognitiveEngine {
 
     // Phase C: publish cognitive event
     const _bus = this._bus
-    if( _bus && ( zone === 'distress' || zone === 'overload' ) )
+    if( _bus && ( zone === 'distress' || zone === 'overload') )
       _bus.publish({ type: 'stress.zone.transition', version: 1, sourceEngine: this.name, salience: Math.min(1, newLoad / 100), payload: { zone, load: newLoad } })
     // Phase D + F: rich state-change event — gated by prediction error
     if( _bus ){
       const zoneCode = zone === 'low' ? 0 : zone === 'optimal' ? 1 : zone === 'distress' ? 2 : 3
-      const predErr  = this._model.observe( 'stress.load', newLoad )
+      const predErr  = this._model.observe('stress.load', newLoad )
+      // ACP-P2: self-caused observe done — restore full precision immediately.
+      if( this._acpOneShot ){
+        this._model.setPrecision('stress.load', 1.0 )
+        this._acpOneShot = false
+      }
       if( !predErr.gated || zone !== previousZone ){
         _bus.publish({ type: 'stress.state.changed', version: 1, sourceEngine: this.name, salience: predErr.salience, payload: { load: newLoad, zoneCode, deadlineUrgency: state.metrics.get('deadline.urgency') ?? 0, cognitiveLoad: state.metrics.get('cognitive.load') ?? state.metrics.get('attention.usage') ?? 0 } })
       }
@@ -279,7 +302,7 @@ export class StressRegulator implements SimulationEngine, CognitiveEngine {
   private _readConfigFromState( state: ReadonlySimulationState ): void {
     // Effective config = base engine-config-stress ⊕ persona-prior. Channel A: a steadier
     // (emotionally-stable) Will develops a higher baseDecayRate and so sheds stress faster.
-    const p = readEffectiveParams( state, 'engine-config-stress' )
+    const p = readEffectiveParams( state, 'engine-config-stress')
     if( p.baseDecayRate       != null ) this._baseDecayRate     = p.baseDecayRate
     if( p.optimalThreshold    != null ) this._optimalThreshold  = p.optimalThreshold
     if( p.distressThreshold   != null ) this._distressThreshold = p.distressThreshold

package/src/cognition/faculties/task.switcher.ts

@@ -81,7 +81,7 @@ export class TaskSwitcher implements SimulationEngine, CognitiveEngine {
   private _readConfigFromState( state: ReadonlySimulationState ): void {
     // Effective config = base engine-config-task-switcher ⊕ persona-prior. Channel A: a
     // conscientious Will develops a higher baseSwitchCost and so is less distractible.
-    const p = readEffectiveParams( state, 'engine-config-task-switcher' )
+    const p = readEffectiveParams( state, 'engine-config-task-switcher')
     if( p.baseSwitchCost != null ) this._baseSwitchCost = p.baseSwitchCost
     if( p.switchThreshold != null ) this._switchThreshold = p.switchThreshold
     if( p.minFocusTicks != null ) this._minFocusTicks = p.minFocusTicks
@@ -93,10 +93,10 @@ export class TaskSwitcher 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('executive') )
-        this._model.setPrecision( 'task.focus_ticks', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('task.focus_ticks', 1.0 + p.confidence * 0.5 )
     }
   }
 
@@ -143,8 +143,13 @@ export class TaskSwitcher implements SimulationEngine, CognitiveEngine {
         const currentPriority = currentGoal?.priority ?? 0
         const switchAdvantage = topGoal.priority - currentPriority
 
-        // Account for switching cost
-        const switchCost = this._baseSwitchCost * ( 1 + this._currentFocus.focusTicks * 0.01 )
+        // Account for switching cost. EXAFFERENCE P3 follow-up: `situation.stability`
+        // (absent ⇒ 1 ⇒ unchanged) scales the focus-hardening term, so a
+        // destabilized world loosens focus here exactly as it does in the
+        // ActionSelector — the two owners of switch resistance now read the same
+        // stability signal at their native scales (goal-priority vs. activation).
+        const stability  = state.metrics.get('situation.stability') ?? 1
+        const switchCost = this._baseSwitchCost * ( 1 + this._currentFocus.focusTicks * 0.01 * stability )
         const netBenefit = switchAdvantage - switchCost
 
         if( netBenefit > this._switchThreshold
@@ -204,7 +209,7 @@ export class TaskSwitcher implements SimulationEngine, CognitiveEngine {
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus ){
-      const predErr = this._model.observe( 'task.focus_ticks', this._currentFocus.focusTicks )
+      const predErr = this._model.observe('task.focus_ticks', this._currentFocus.focusTicks )
       if( !predErr.gated )
         _bus.publish({ type: 'task.focus.changed', version: 1, sourceEngine: this.name, salience: Math.max( 0.3, predErr.salience ), payload: { focusTicks: this._currentFocus.focusTicks } })
     }

package/src/cognition/faculties/theory.of.mind.ts

@@ -98,17 +98,17 @@ export class TheoryOfMind 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( 'tom.models', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('tom.models', 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
       }
-      if( p.keid && p.keid !== 'agent-self' )
+      if( p.keid && p.keid !== 'agent-self')
         this._pendingInteractions.push( p )
     }
   }
@@ -191,7 +191,7 @@ export class TheoryOfMind implements SimulationEngine, CognitiveEngine {
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus && this._models.size > 0 ){
-      const predErr = this._model.observe( 'tom.models', this._models.size )
+      const predErr = this._model.observe('tom.models', this._models.size )
       if( !predErr.gated )
         _bus.publish({ type: 'theory_of_mind.model.updated', version: 1, sourceEngine: this.name, salience: Math.max( 0.2, predErr.salience ), payload: { modelsActive: this._models.size } })
     }
@@ -231,7 +231,7 @@ export class TheoryOfMind implements SimulationEngine, CognitiveEngine {
    */
   private _restoreFromState( state: ReadonlySimulationState ): void {
     for( const entity of state.entities.values() ){
-      if( entity.type !== 'theory_of_mind' ) continue
+      if( entity.type !== 'theory_of_mind') continue
       const m       = entity.metadata ?? {}
       const keid = m['keid'] as string | undefined
       if( !keid ) continue

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

@@ -180,12 +180,12 @@ export class ThreatEvaluator implements SimulationEngine, CognitiveEngine {
     // event is refreshed each tick as base ⊕ persona-prior, so a steadier Will develops a
     // HIGHER threshold and is less easily alarmed. _computeAndEmit (no `state`) reads the
     // cached field. (The seed entity existed but was ignored before.)
-    this._fearEventThreshold = readEffectiveParams( state, 'engine-config-threat' ).fearEventThreshold ?? this._fearEventThreshold
+    this._fearEventThreshold = readEffectiveParams( state, 'engine-config-threat').fearEventThreshold ?? this._fearEventThreshold
 
     // Recompute hostile threat from state entities every tick
     let maxHostile = 0
     for( const entity of state.entities.values() ){
-      if( entity.type !== 'threat' ) continue
+      if( entity.type !== 'threat') continue
       if( entity.metadata?.active === false )  continue
       if( !entity.metadata?.hostile )          continue
       const intensity = typeof entity.metadata?.intensity === 'number'
@@ -288,7 +288,7 @@ export class ThreatEvaluator implements SimulationEngine, CognitiveEngine {
       // worldState.threatLevel). observe() runs every tick so the baseline tracks
       // and the executive's top-down precision (set on 'threat.level') applies;
       // the one value is reused across the tiered events.
-      const threatSalience = this._model.observe( 'threat.level', threatLevel ).salience
+      const threatSalience = this._model.observe('threat.level', threatLevel ).salience
 
       if( fear > 0.4 )
         _bus.publish({ type: 'emotion.fear.elevated', version: 1, sourceEngine: this.name, salience: threatSalience, payload: { fear } })

package/src/cognition/faculties/working.memory.ts

@@ -132,7 +132,7 @@ export class WorkingMemory implements SimulationEngine, CognitiveEngine {
       case 'executive.prediction.formed': {
         const p = e.payload as { predictedDomains: string[]; confidence: number }
         if( p.predictedDomains.includes('memory') )
-          this._model.setPrecision( 'memory.working.load', 1.0 + p.confidence * 0.5 )
+          this._model.setPrecision('memory.working.load', 1.0 + p.confidence * 0.5 )
         break
       }
     }
@@ -174,7 +174,7 @@ export class WorkingMemory implements SimulationEngine, CognitiveEngine {
    * No-op at boot: mirror params equal the constructor defaults (reconciled in #83).
    */
   private _readConfigFromState( state: ReadonlySimulationState ): void {
-    const p = readEffectiveParams( state, 'engine-config-working-memory' )
+    const p = readEffectiveParams( state, 'engine-config-working-memory')
     if( p.maxChunks           != null ) this._maxChunks           = p.maxChunks
     if( p.baseDecayRate       != null ) this._baseDecayRate       = p.baseDecayRate
     if( p.attentionProtection != null ) this._attentionProtection = p.attentionProtection
@@ -241,7 +241,7 @@ export class WorkingMemory implements SimulationEngine, CognitiveEngine {
         type: 'memory.working.changed',
         version: 1,
         sourceEngine: this.name,
-        salience: this._model.observe( 'memory.working.load', load ).salience,
+        salience: this._model.observe('memory.working.load', load ).salience,
         payload: { items: this._items.length, capacity: this._modulatedCapacity, load },
       })
 
@@ -275,10 +275,10 @@ export class WorkingMemory implements SimulationEngine, CognitiveEngine {
    */
   private _ingestPercepts( state: ReadonlySimulationState, tick: Tick ): void {
     for( const entity of state.entities.values() ){
-      if( entity.type !== 'percept' ) continue
+      if( entity.type !== 'percept') continue
       if( this._items.some( i => i.sourceEntityId === entity.id ) ) continue
 
-      const summary = ( entity.metadata?.summary ?? entity.metadata?.content ?? '' ) as string
+      const summary = ( entity.metadata?.summary ?? entity.metadata?.content ?? '') as string
       if( !summary || summary.startsWith('New percept:') ) continue
 
       this._evictIfNeeded()
@@ -301,8 +301,8 @@ export class WorkingMemory implements SimulationEngine, CognitiveEngine {
    */
   private _ingestGoals( state: ReadonlySimulationState, tick: Tick ): void {
     for( const entity of state.entities.values() ){
-      if( entity.type !== 'goal' ) continue
-      if( entity.metadata?.status !== 'active' ) continue
+      if( entity.type !== 'goal') continue
+      if( entity.metadata?.status !== 'active') continue
       if( this._items.some( i => i.sourceEntityId === entity.id ) ) continue
 
       this._evictIfNeeded()
@@ -335,7 +335,7 @@ export class WorkingMemory implements SimulationEngine, CognitiveEngine {
 
     // State-entity fallback: attention.focus entities
     for( const entity of state.entities.values() ){
-      if( entity.type !== 'attention.focus' ) continue
+      if( entity.type !== 'attention.focus') continue
       const targetId = entity.metadata?.targetEntityId as string | undefined
       if( !targetId ) continue
       const item = this._items.find( i => i.sourceEntityId === targetId )

package/src/cognition/generative.model.ts

@@ -289,8 +289,8 @@ export class GenerativeModel {
    */
   restore( snap: GenerativeModelSnapshot | undefined | null ): void {
     if( !snap ) return
-    if( typeof snap.defaultAlpha === 'number' ) this._defaultAlpha = snap.defaultAlpha
-    if( typeof snap.defaultRange === 'number' ) this._defaultRange = snap.defaultRange
+    if( typeof snap.defaultAlpha === 'number') this._defaultAlpha = snap.defaultAlpha
+    if( typeof snap.defaultRange === 'number') this._defaultRange = snap.defaultRange
 
     this._streams = new Map(
       ( snap.streams ?? [] ).map( ([ k, v ]) => [ k, {

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

@@ -104,7 +104,7 @@ export class DefaultVectorMemoryAdapter implements VectorMemoryAdapter {
     if( this._index.size >= this._maxIndexedEpisodes )
       await this._evictColdest()
 
-    const embedding = await this._embedder.embed( episodeContentToText( content ), 'index' )
+    const embedding = await this._embedder.embed( episodeContentToText( content ), 'index')
 
     const record: VectorRecord = {
       id: episode.id,
@@ -138,7 +138,7 @@ export class DefaultVectorMemoryAdapter implements VectorMemoryAdapter {
       await this._evictColdest()
 
     const contents = newEpisodes.map( e => episodeContentToText( e.content ) )
-    const embeddings = await this._embedder.embedBatch( contents, 'index' )
+    const embeddings = await this._embedder.embedBatch( contents, 'index')
 
     for( let i = 0; i < newEpisodes.length; i++ ){
       const { episode } = newEpisodes[i]!
@@ -167,7 +167,7 @@ export class DefaultVectorMemoryAdapter implements VectorMemoryAdapter {
   }
 
   async search( query: unknown, filter?: VectorQueryFilter ): Promise<VectorQueryResult[]> {
-    const embedding = await this._embedder.embed( episodeContentToText( query ), 'recall' )
+    const embedding = await this._embedder.embed( episodeContentToText( query ), 'recall')
     return this.searchWithVector( embedding, filter )
   }
 
@@ -275,7 +275,7 @@ export class DefaultVectorMemoryAdapter implements VectorMemoryAdapter {
       }
     }
     catch( err ){
-      logger.warn( `[VectorMemoryAdapter] Failed to load index:`, err )
+      logger.warn(`[VectorMemoryAdapter] Failed to load index:`, err )
     }
   }
 
@@ -308,7 +308,7 @@ export class DefaultVectorMemoryAdapter implements VectorMemoryAdapter {
 
     this._persistDebounceTimer = setTimeout( () => {
       this.persist().catch( err => {
-        logger.error( `[VectorMemoryAdapter] Persist failed:`, err )
+        logger.error(`[VectorMemoryAdapter] Persist failed:`, err )
       } )
       this._persistDebounceTimer = null
     }, 5000 )

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

@@ -18,9 +18,9 @@
  * strings are already clean text and pass through unchanged.
  */
 export function episodeContentToText( content: unknown ): string {
-  if( typeof content === 'string' ) return content
+  if( typeof content === 'string') return content
 
-  if( content && typeof content === 'object' ){
+  if( content && typeof content === 'object'){
     const m = content as Record<string, unknown>
 
     // Conversation exchanges carry the actual dialogue — by far the strongest
@@ -28,7 +28,7 @@ export function episodeContentToText( content: unknown ): string {
     const user  = typeof m['userMessage'] === 'string' ? m['userMessage'] as string : ''
     const reply = typeof m['willReply']   === 'string' ? m['willReply']   as string : ''
     if( user || reply )
-      return [ user, reply ].filter( Boolean ).join( ' → ' )
+      return [ user, reply ].filter( Boolean ).join(' → ')
 
     // Most WM items carry a top-level human summary.
     if( typeof m['summary'] === 'string' && m['summary'] ) return m['summary'] as string
@@ -36,7 +36,7 @@ export function episodeContentToText( content: unknown ): string {
     // Descriptor items nest their payload (e.g. plan: { content: { summary } }).
     const nested = m['content']
     if( typeof nested === 'string' && nested ) return nested
-    if( nested && typeof nested === 'object' ){
+    if( nested && typeof nested === 'object'){
       const nm = nested as Record<string, unknown>
       if( typeof nm['summary'] === 'string' && nm['summary'] ) return nm['summary'] as string
     }