@mindot/will 0.4.0 → 0.6.0

package/src/cognition/faculties/exteroception.ts

@@ -31,6 +31,11 @@ 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 {
+  CONSEQUENCE_TYPE, ATTENUATION, CORRESPONDENCE_ATTENUATION,
+  liveConsequences, matchConsequenceText, matchConsequenceEntity,
+} from '#agency/consequence'
+import { REVOCATION_TYPE } from '#agency/revocation'
 
 export interface ExteroceptionConfig {
   /** Maximum percepts to produce per tick */
@@ -50,6 +55,12 @@ interface RawPercept {
   salience: number
   category: string
   summary: string
+  /** Text the corollary-discharge matcher inspects (entity content ≻ description ≻ summary). */
+  matchText?: string
+  /** Felt valence carried with the percept (affect→percept seam, registry #5). */
+  valence?: number
+  /** Where that valence came from — per-entity appraisal, or ambient mood. */
+  valenceSource?: 'entity' | 'ambient'
 }
 
 // Skip internal entities — they're not external percepts.
@@ -65,6 +76,11 @@ const internalTypes = new Set([
   'theory_of_mind', 'reputation', 'episodic_memory',
   // Internal state entities written by our own engines — not external events
   'affect.blends', 'executive.summary',
+  // The agency's own forward-model records (EXAFFERENCE P1/P2): perceiving our
+  // expected-consequence descriptors would be a self-noise loop.
+  CONSEQUENCE_TYPE,
+  // The agency's own revocation tombstones (EXAFFERENCE P4) — internal bookkeeping.
+  REVOCATION_TYPE,
 ])
 
 export class Exteroception implements SimulationEngine, CognitiveEngine {
@@ -101,10 +117,10 @@ export class Exteroception 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('perception') )
-        this._model.setPrecision( 'percept.rate', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('percept.rate', 1.0 + p.confidence * 0.5 )
     }
   }
 
@@ -125,19 +141,46 @@ export class Exteroception implements SimulationEngine, CognitiveEngine {
     // Cap percepts per tick
     const capped = rawPercepts.slice( 0, this._maxPerceptsPerTick )
 
+    // Corollary discharge (EXAFFERENCE P2): everything this engine perceives is
+    // world-ingress afference — split it. A percept matching a live expected-
+    // consequence descriptor is *reafferent* (our own action's sensory footprint:
+    // the channel echo, a quote-back) and its salience is attenuated, not zeroed;
+    // everything else is *exafferent* — the world moved on its own. Endogenous
+    // percepts (working memory, escalations) are created elsewhere and stay
+    // untagged: they are neither.
+    const consequences = liveConsequences( state.entities, tick )
+
     // Convert raw percepts to entities
     for( let i = 0; i < capped.length; i++ ){
       const rp = capped[i]!
 
+      const textHit = consequences.length > 0 && rp.matchText
+        ? matchConsequenceText( consequences, rp.matchText )
+        : null
+      // ACP-P1 (entity correspondence): when the text path misses, a change on
+      // exactly the entity a live external descriptor targets is still our
+      // footprint — claimed at gentler attenuation (we're less certain).
+      const entityHit = !textHit && consequences.length > 0
+        ? matchConsequenceEntity( consequences, rp.entityId, rp.changeType )
+        : null
+      const hit = textHit ?? entityHit
+      const salience = textHit ? rp.salience * ATTENUATION
+        : entityHit ? rp.salience * CORRESPONDENCE_ATTENUATION
+        : rp.salience
+
       const perceptEntity = {
         id: `percept-${tick}-${i}`,
         type: 'percept',
         metadata: {
           entityId: rp.entityId,
           changeType: rp.changeType,
-          salience: rp.salience,
+          salience,
           category: rp.category,
           summary: rp.summary,
+          provenance: hit ? 'reafferent' : 'exafferent',
+          ...( hit ? { sourceIntentId: hit.intentId } : {} ),
+          // affect→percept seam (registry #5): what this percept FEELS like
+          ...( rp.valence !== undefined ? { valence: rp.valence, valenceSource: rp.valenceSource } : {} ),
           tick,
         },
       }
@@ -151,7 +194,7 @@ export class Exteroception implements SimulationEngine, CognitiveEngine {
           source: this.name,
           payload: {
             entityId: rp.entityId,
-            salience: rp.salience,
+            salience,
             category: rp.category,
             summary: rp.summary,
           },
@@ -171,7 +214,7 @@ export class Exteroception implements SimulationEngine, CognitiveEngine {
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus && capped.length > 0 ){
-      const predErr = this._model.observe( 'percept.rate', capped.length )
+      const predErr = this._model.observe('percept.rate', capped.length )
       if( !predErr.gated )
         _bus.publish({ type: 'percept.batch.ingested', version: 1, sourceEngine: this.name, salience: Math.max( 0.2, predErr.salience ), payload: { count: capped.length } })
     }
@@ -220,6 +263,8 @@ private _scanWorld( state: ReadonlySimulationState ): RawPercept[] {
           salience: this._computeSalience( entity, 'appeared', state.time ),
           category: entity.type,
           summary: this._summarizeEntity( entity, 'appeared'),
+          matchText: this._matchText( entity ),
+          ...this._valenceOf( id, state ),
         })
       }
       else if( entity.updatedAt > previousVersion ){
@@ -229,6 +274,8 @@ private _scanWorld( state: ReadonlySimulationState ): RawPercept[] {
           salience: this._computeSalience( entity, 'modified', state.time ),
           category: entity.type,
           summary: this._summarizeEntity( entity, 'modified'),
+          matchText: this._matchText( entity ),
+          ...this._valenceOf( id, state ),
         })
       }
 
@@ -268,6 +315,53 @@ private _scanWorld( state: ReadonlySimulationState ): RawPercept[] {
    * Generate a meaningful summary for an entity.
    * Instead of "New percept: percept-54-0", produce something useful.
    */
+  /**
+   * The text the corollary-discharge matcher inspects for this entity — its
+   * content (a message body) over its description over its summary. Where our
+   * own delivered words would surface if the world echoes them back.
+   */
+  /**
+   * The affect→percept valence seam (registry #5). A percept carries how the
+   * mind *feels* about what it is a percept OF, resolved most-specific-first:
+   *
+   *   1. the KnownEntityTracker's dossier for this entity (`ke-<id>.valence`) —
+   *      a real per-entity felt valence, the honest signal;
+   *   2. otherwise the ambient `affect.valence` — the felt tone at perception
+   *      time. Weaker evidence, so it is tagged `'ambient'` and consumers
+   *      weight it down (mood is context, not appraisal of this thing).
+   *
+   * Absent both, no valence is stamped and every consumer keeps its
+   * pre-seam behaviour.
+   */
+  /** Spread-friendly form of `_valenceFor` for percept construction. */
+  private _valenceOf( entityId: string, state: ReadonlySimulationState ):
+    { valence?: number; valenceSource?: 'entity' | 'ambient' } {
+    const v = this._valenceFor( entityId, state )
+    return v ? { valence: v.valence, valenceSource: v.source } : {}
+  }
+
+  private _valenceFor( entityId: string, state: ReadonlySimulationState ):
+    { valence: number; source: 'entity' | 'ambient' } | undefined {
+    const dossier = state.entities.get(`ke-${ entityId }`)
+    const felt = dossier?.metadata?.['valence']
+    if( typeof felt === 'number' && Number.isFinite( felt ) )
+      return { valence: felt, source: 'entity' }
+
+    const ambient = state.metrics.get('affect.valence')
+    if( typeof ambient === 'number' && Number.isFinite( ambient ) )
+      return { valence: ambient, source: 'ambient' }
+
+    return undefined
+  }
+
+  private _matchText( entity: Readonly<SimulationEntity> ): string | undefined {
+    const m = entity.metadata as Record<string, unknown> | undefined
+    const content     = typeof m?.['content']     === 'string' ? m['content']     as string : undefined
+    const description = typeof m?.['description'] === 'string' ? m['description'] as string : undefined
+    const summary     = typeof m?.['summary']     === 'string' ? m['summary']     as string : undefined
+    return content ?? description ?? summary
+  }
+
   private _summarizeEntity(
     entity: Readonly<SimulationEntity>,
     changeType: string

package/src/cognition/faculties/forgetting.curve.ts

@@ -94,10 +94,10 @@ export class ForgettingCurve 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( 'memory.decay_rate', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('memory.decay_rate', 1.0 + p.confidence * 0.5 )
     }
   }
 
@@ -189,7 +189,7 @@ export class ForgettingCurve implements SimulationEngine, CognitiveEngine {
     // Phase C: publish cognitive event
     const _bus = this._bus
     if( _bus && decayedCount > 0 )
-      _bus.publish({ type: 'memory.decay.applied', version: 1, sourceEngine: this.name, salience: this._model.observe( 'memory.decay_rate', decayedCount ).salience, payload: { decayed: decayedCount } })
+      _bus.publish({ type: 'memory.decay.applied', version: 1, sourceEngine: this.name, salience: this._model.observe('memory.decay_rate', decayedCount ).salience, payload: { decayed: decayedCount } })
 
     return { commands }
   }

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

@@ -100,20 +100,20 @@ export class FrustrationEvaluator 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('affect') )
-        this._model.setPrecision( 'emotion.frustration', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('emotion.frustration', 1.0 + p.confidence * 0.5 )
       this._cachedConfidence = p.confidence
     }
 
-    if( e.type === 'goal.blocked' ){
+    if( e.type === 'goal.blocked'){
       const p = e.payload as { goalId: string; ticksStuck: number; priority: number }
       this._blockedGoals.set( p.goalId, { ticksStuck: p.ticksStuck, priority: p.priority, refreshedAt: this._reactCount } )
       this._goalBlockedCounts.set( p.goalId, ( this._goalBlockedCounts.get( p.goalId ) ?? 0 ) + 1 )
     }
 
-    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.directedAtSelf && p.valence < -0.5 )
         this._unfairnessSignal = Math.min( 1, this._unfairnessSignal + 0.3 )
@@ -137,7 +137,7 @@ export class FrustrationEvaluator implements SimulationEngine, CognitiveEngine {
     // steady affect develops a lower build-rate here, so it stays even-keeled longer —
     // distinct from resilience's frustrationTolerance (how much is *tolerated*). Pure +
     // deterministic; falls back to the constructor default when no seed/prior is present.
-    const frustrationCfg   = readEffectiveParams( state, 'engine-config-frustration' )
+    const frustrationCfg   = readEffectiveParams( state, 'engine-config-frustration')
     const irritabilityRate = frustrationCfg.irritabilityRate ?? this._irritabilityRate
 
     // Channel A (agreeableness — "yielding in conflict"): how strongly provocation
@@ -236,7 +236,7 @@ export class FrustrationEvaluator implements SimulationEngine, CognitiveEngine {
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus && frustration > 0.5 ){
-      const predErr = this._model.observe( 'emotion.frustration', frustration )
+      const predErr = this._model.observe('emotion.frustration', frustration )
       if( !predErr.gated )
         _bus.publish({ type: 'emotion.frustration.elevated', version: 1, sourceEngine: this.name, salience: Math.min(1, frustration), payload: { frustration } })
     }

package/src/cognition/faculties/goal.manager.ts

@@ -223,7 +223,7 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
         break
       case 'belief.updated':
         // Salience model only — authoritative count always read from state.metrics.
-        this._model.observe( 'belief.count', ( e.payload as Record<string,number> )['total'] ?? 0 )
+        this._model.observe('belief.count', ( e.payload as Record<string,number> )['total'] ?? 0 )
         break
       case 'executive.goal.proposed':
         // Track that executive proposed goals — prioritize executive-sourced goals slightly higher
@@ -272,7 +272,7 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
           
         if( payload.goalId && payload.goalProgress !== undefined ){
           const goal = this._goals.get( payload.goalId )
-          if( goal?.status === 'active' ){
+          if( goal?.status === 'active'){
             goal.progress = Math.max( goal.progress, payload.goalProgress )  // forward-only
             if( goal.progress >= 0.95 )
               goal.status = 'pending_verification'
@@ -286,7 +286,7 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
         p = e.payload as { goalId: string },
         goal = this._goals.get( p.goalId )
 
-        if( goal?.status === 'active' )
+        if( goal?.status === 'active')
           goal.status = 'pending_verification'  // queued for condition eval next tick
 
         break
@@ -392,7 +392,7 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
         type: 'goal.state.changed',
         version: 1,
         sourceEngine: this.name,
-        salience: Math.max( 0.4, this._model.observe( 'goal.active_count', activeGoals.length ).salience ),
+        salience: Math.max( 0.4, this._model.observe('goal.active_count', activeGoals.length ).salience ),
         payload: { activeCount: activeGoals.length }
       })
 
@@ -563,7 +563,7 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
    */
   abandonGoal( goalId: string, reason?: string ): void {
     const goal = this._goals.get( goalId )
-    if( goal && goal.status === 'active' ){
+    if( goal && goal.status === 'active'){
       goal.status = 'abandoned'
       // Optionally store the reason (if GoalState had a reason field; we can add it or store in tags)
       reason && goal.tags.push(`abandoned:${reason.slice(0,50)}`)
@@ -683,7 +683,7 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
         const cType   = ( m.goalCompletionType as GoalState['completionType'] ) ?? 'action'
         const cCond   = m.goalCompletionCondition as string | undefined
         // Dedup by the referent (keid: tag) when present, else by description.
-        const keidTag = tags.find( t => t.startsWith( 'keid:' ) )
+        const keidTag = tags.find( t => t.startsWith('keid:') )
         const existing = Array.from( this._goals.values() ).find( g =>
           g.status === 'active' && ( keidTag ? g.tags.includes( keidTag ) : g.description === desc ) )
 
@@ -698,10 +698,10 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
   private _updatePriorities( state: ReadonlySimulationState ): void {
     // Task-persistence: which goal the Will is focused on + how committed (task.switcher)
     // and the (developable) cost of switching away. Drives the commitment boost below.
-    const focusMeta     = state.entities.get( 'task-switch-focus' )?.metadata as Record<string, unknown> | undefined
+    const focusMeta     = state.entities.get('task-switch-focus')?.metadata as Record<string, unknown> | undefined
     const focusedGoalId = focusMeta?.goalId as string | undefined
     const focusTicks    = ( focusMeta?.focusTicks as number ) ?? 0
-    const switchCost    = state.metrics.get( 'task_switch.switch_cost' ) ?? 0
+    const switchCost    = state.metrics.get('task_switch.switch_cost') ?? 0
 
     for( const goal of this._goals.values() ){
       if( goal.status !== 'active') continue
@@ -764,7 +764,7 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
       if( e.type !== 'plan' || e.metadata?.goalId !== goalId ) continue
       const steps = ( e.metadata?.steps as Array<{ status?: string }> | undefined ) ?? []
       if( steps.length === 0 ) continue
-      const done = steps.filter( s => s.status === 'completed' || s.status === 'skipped' ).length
+      const done = steps.filter( s => s.status === 'completed' || s.status === 'skipped').length
       return done / steps.length
     }
     return 0
@@ -792,14 +792,14 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
       // (defence-in-depth beyond the already-satisfied creation guard in _activateFromDrives).
       if( goal.activatedAt === tick ) continue
 
-      if( goal.status === 'pending_verification' ){
+      if( goal.status === 'pending_verification'){
         const met = this._evaluateMetricProgress( goal, state ) >= 1
-        met ? this.completeGoal( goal.id ) : ( goal.status = 'active' )
+        met ? this.completeGoal( goal.id ) : ( goal.status = 'active')
 
         continue  // skip completionType switch entirely
       }
 
-      if( goal.status !== 'active' && goal.status !== 'blocked' ) continue
+      if( goal.status !== 'active' && goal.status !== 'blocked') continue
 
       switch( goal.completionType ){
         case 'metric':
@@ -859,8 +859,8 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
                                 || dLow === 'communication'
 
     for( const goal of this._goals.values() ){
-      if( goal.status !== 'active' && goal.status !== 'blocked' ) continue
-      if( goal.completionType !== 'action' ) continue
+      if( goal.status !== 'active' && goal.status !== 'blocked') continue
+      if( goal.completionType !== 'action') continue
 
       const hasMatch = goal.tags.some( tag => {
         const t = tag.toLowerCase()
@@ -940,7 +940,7 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
    * seeded by the PMA and developed by the metacognition cycle — not a constant.
    */
   private _readConfigFromState( state: ReadonlySimulationState ): void {
-    const p = readEffectiveParams( state, 'engine-config-goal-manager' )
+    const p = readEffectiveParams( state, 'engine-config-goal-manager')
     if( p.gritPriority         != null ) this._gritPriority         = p.gritPriority
     if( p.gritPatienceScale    != null ) this._gritPatienceScale    = p.gritPatienceScale
     if( p.frustrationTolerance != null ) this._frustrationTolerance = p.frustrationTolerance

package/src/cognition/faculties/inhibition.controller.ts

@@ -93,7 +93,7 @@ export class InhibitionController implements SimulationEngine, CognitiveEngine {
     // Effective config = base engine-config-inhibition ⊕ persona-prior (single-source).
     // The persona-consolidator raises baseInhibitionStrength when reasoning bias
     // recurs (edge 6) → more self-restraint while the bias is being worked through.
-    const p = readEffectiveParams( state, 'engine-config-inhibition' )
+    const p = readEffectiveParams( state, 'engine-config-inhibition')
     if( p.baseInhibitionStrength != null ) this._baseInhibitionStrength = p.baseInhibitionStrength
     if( p.arousalThreshold       != null ) this._arousalThreshold       = p.arousalThreshold
     if( p.maxDeferralsPerTick    != null ) this._maxDeferralsPerTick    = p.maxDeferralsPerTick
@@ -132,7 +132,7 @@ export class InhibitionController implements SimulationEngine, CognitiveEngine {
       case 'executive.prediction.formed': {
         const p = e.payload as { predictedDomains: string[]; confidence: number }
         if( p.predictedDomains.includes('executive') )
-          this._model.setPrecision( 'inhibition.strength', 1.0 + p.confidence * 0.5 )
+          this._model.setPrecision('inhibition.strength', 1.0 + p.confidence * 0.5 )
         break
       }
     }
@@ -253,7 +253,7 @@ export class InhibitionController implements SimulationEngine, CognitiveEngine {
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus && vetoedActions.length > 0 ){
-      const predErr = this._model.observe( 'inhibition.strength', inhibitionStrength )
+      const predErr = this._model.observe('inhibition.strength', inhibitionStrength )
       if( !predErr.gated )
         _bus.publish({ type: 'inhibition.vetoed', version: 1, sourceEngine: this.name, salience: 0.7, payload: { vetoedActions, inhibitionStrength } })
     }

package/src/cognition/faculties/interoception.ts

@@ -101,7 +101,7 @@ export class Interoception implements SimulationEngine, CognitiveEngine {
       case 'executive.prediction.formed': {
         const p = e.payload as { predictedDomains: string[]; confidence: number }
         if( p.predictedDomains.includes('interoception') )
-          this._model.setPrecision( 'interoception.intensity', 1.0 + p.confidence * 0.5 )
+          this._model.setPrecision('interoception.intensity', 1.0 + p.confidence * 0.5 )
         break
       }
     }
@@ -142,7 +142,7 @@ export class Interoception implements SimulationEngine, CognitiveEngine {
     // Blend of the direct circadian mood set-point and holistic homeostatic comfort.
     // Comfort dominates (0.65) because energy/sleep/stress drive moment-to-moment
     // mood more strongly than the slow-moving circadian baseline.
-    const moodBaseline = signals.find( s => s.metric === 'circadian.mood_baseline' )?.value ?? 0.5
+    const moodBaseline = signals.find( s => s.metric === 'circadian.mood_baseline')?.value ?? 0.5
     const interoMood   = moodBaseline * 0.35 + comfortLevel * 0.65
 
     // Percept entity — the unified "how I feel" snapshot
@@ -202,7 +202,7 @@ export class Interoception implements SimulationEngine, CognitiveEngine {
       _bus.publish({ type: 'interoception.state.updated', version: 1, sourceEngine: this.name, salience: Math.abs(comfortLevel - 0.5) * 0.8, payload: { comfort: comfortLevel, intensity: overallIntensity } })
     // Phase D + F: rich state-change event — gated by prediction error
     if( _bus ){
-      const predErr = this._model.observe( 'interoception.intensity', overallIntensity )
+      const predErr = this._model.observe('interoception.intensity', overallIntensity )
       if( !predErr.gated )
         _bus.publish({ type: 'interoception.state.changed', version: 1, sourceEngine: this.name, salience: predErr.salience, payload: { comfort: comfortLevel, intensity: overallIntensity } })
     }

package/src/cognition/faculties/introspection.engine.ts

@@ -183,7 +183,7 @@ export class IntrospectionEngine implements SimulationEngine, CognitiveEngine {
     // mismatched: precision set on .significance, salience read off .total).
     const _bus = this._bus
     if( _bus && introspectedThisTick )
-      _bus.publish({ type: 'introspection.insight', version: 1, sourceEngine: this.name, salience: Math.max( 0.3, this._model.observe( 'introspection.significance', significance ).salience ), payload: { total: this._introspectionHistory.length, significance } })
+      _bus.publish({ type: 'introspection.insight', version: 1, sourceEngine: this.name, salience: Math.max( 0.3, this._model.observe('introspection.significance', significance ).salience ), payload: { total: this._introspectionHistory.length, significance } })
     return { events: events.length > 0 ? events : undefined, commands }
   }
 
@@ -200,7 +200,7 @@ export class IntrospectionEngine implements SimulationEngine, CognitiveEngine {
     // that observation stays.)
     const detectedBiases: string[] = []
     for( const entity of state.entities.values() )
-      if( entity.type === 'cognitive_bias' )
+      if( entity.type === 'cognitive_bias')
         detectedBiases.push(
           ( entity.metadata?.description as string )
           ?? ( entity.metadata?.type as string )
@@ -234,7 +234,7 @@ export class IntrospectionEngine implements SimulationEngine, CognitiveEngine {
    * drift — so reading base⊕prior is safe here.)
    */
   private _readConfigFromState( state: ReadonlySimulationState ): void {
-    const p = readEffectiveParams( state, 'engine-config-introspection' )
+    const p = readEffectiveParams( state, 'engine-config-introspection')
     if( p.cooldownTicks != null )         this._cooldownTicks         = p.cooldownTicks
     if( p.significanceThreshold != null ) this._significanceThreshold = p.significanceThreshold
   }

package/src/cognition/faculties/known.entity.tracker.ts

@@ -134,7 +134,7 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
    * the curiosity pull; analytical sharpens how fast reliability judgments are revised.
    */
   private _readConfigFromState( state: ReadonlySimulationState ): void {
-    const p = readEffectiveParams( state, 'engine-config-known-entity' )
+    const p = readEffectiveParams( state, 'engine-config-known-entity')
     if( p.familiarityGrowthRate != null ) this._growthRate      = p.familiarityGrowthRate
     if( p.curiosityGain         != null ) this._curiosityGain   = p.curiosityGain
     if( p.reliabilityRate       != null ) this._reliabilityRate = p.reliabilityRate
@@ -149,17 +149,17 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
     this._model.observe( e.type, e.salience )
 
     // Conscious learning (the reasoning write-path): a learned name + felt valence.
-    if( e.type === 'known.entity.learned' ){
+    if( e.type === 'known.entity.learned'){
       const u = e.payload as { keid?: string; name?: string; feeling?: number }
-      if( u?.keid && u.keid !== 'agent-self' )
+      if( u?.keid && u.keid !== 'agent-self')
         this._pendingConscious.push({ keid: u.keid, name: u.name, feeling: u.feeling })
       return
     }
 
     // Acting on/with an entity and seeing how it went — the reliability track-record.
-    if( e.type === 'action.outcome' ){
+    if( e.type === 'action.outcome'){
       const o = e.payload as { targetEntityId?: string; success?: boolean; outcomeQuality?: number }
-      if( o?.targetEntityId && o.targetEntityId !== 'agent-self' )
+      if( o?.targetEntityId && o.targetEntityId !== 'agent-self')
         this._pendingOutcomes.push({ keid: o.targetEntityId, signal: o.success ? 1 : 0 })
       return
     }
@@ -167,7 +167,7 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
     // Otherwise a senses.<domain>.percept — bind the perceived entity (sourceEntityId).
     const p = e.payload as Percept | undefined
     const keid = p?.sourceEntityId
-    if( !keid || keid === 'agent-self' ) return
+    if( !keid || keid === 'agent-self') return
 
     // A channel-supplied display name rides on the raw input (e.g. TextMessage.speakerName).
     const raw  = p?.raw as { speakerName?: unknown } | undefined
@@ -252,7 +252,7 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
     for( const d of [ ...this._dossiers.values() ] )
       if( d.familiarity < FORGET_FLOOR && !d.name && d.resolutionConfidence < CURIOUS_RESOLUTION ){
         this._dossiers.delete( d.keid )
-        commands.delete!.push( `ke-${d.keid}` )
+        commands.delete!.push(`ke-${d.keid}`)
       }
 
     // Persist dossiers (the perceptual layer of the known-entity node).
@@ -296,7 +296,7 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
     // which only accepts [\w.] names — keids may contain ':' e.g. web:42.)
     for( const d of this._dossiers.values() ){
       if( d.familiarity < CURIOUS_FAMILIARITY ) continue          // only ones that matter
-      const skeid = d.keid.replace( /[^\w.]/g, '_' )
+      const skeid = d.keid.replace( /[^\w.]/g, '_')
       commands.metrics!.push([ `known_entity.${skeid}.resolution`, d.resolutionConfidence ])
 
       if( d.resolutionConfidence < CURIOUS_RESOLUTION )
@@ -312,12 +312,12 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
             goalCompletionCondition: `known_entity.${skeid}.resolution >= ${CURIOUS_RESOLVED}`,
           },
         })
-      else if( state.entities.has( `curiosity-${d.keid}` ) )
-        commands.delete!.push( `curiosity-${d.keid}` )            // resolved → the pull subsides
+      else if( state.entities.has(`curiosity-${d.keid}`) )
+        commands.delete!.push(`curiosity-${d.keid}`)            // resolved → the pull subsides
     }
 
     if( touched && this._bus ){
-      const predErr = this._model.observe( 'known_entity.count', this._dossiers.size )
+      const predErr = this._model.observe('known_entity.count', this._dossiers.size )
       if( !predErr.gated )
         this._bus.publish({ type: 'known.entity.updated', version: 1, sourceEngine: this.name,
           salience: Math.max( 0.2, predErr.salience ), payload: { tracked: this._dossiers.size } })
@@ -373,7 +373,7 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
 
         this._dossiers.delete( alias.keid )
         this._aliases.set( alias.keid, canon.keid )
-        commands.delete!.push( `ke-${alias.keid}` )
+        commands.delete!.push(`ke-${alias.keid}`)
         commands.set!.push({ id: `kea-${alias.keid}`, type: 'known-entity-alias',
           metadata: { aliasKeid: alias.keid, canonicalKeid: canon.keid } })
         merged = true
@@ -411,21 +411,21 @@ export class KnownEntityTracker implements SimulationEngine, CognitiveEngine {
   private _restoreFromState( state: ReadonlySimulationState ): void {
     // Recognised aliases first, so incoming references redirect to the canonical referent.
     for( const entity of state.entities.values() )
-      if( entity.type === 'known-entity-alias' ){
+      if( entity.type === 'known-entity-alias'){
         const a = entity.metadata?.['aliasKeid'] as string | undefined
         const c = entity.metadata?.['canonicalKeid'] as string | undefined
         if( a && c ) this._aliases.set( a, c )
       }
 
     for( const entity of state.entities.values() ){
-      if( entity.type !== 'known-entity' ) continue
+      if( entity.type !== 'known-entity') continue
       const m    = entity.metadata ?? {}
       const keid = m['keid'] as string | undefined
       if( !keid || this._dossiers.has( keid ) ) continue
 
       this._dossiers.set( keid, {
         keid,
-        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,

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

@@ -155,7 +155,7 @@ export class LossEvaluator implements SimulationEngine, CognitiveEngine {
 
           // Publish cognitive event — gated by prediction error
           if( sadness > 0.4 ){
-            const predErr = this._model.observe( 'emotion.sadness', sadness )
+            const predErr = this._model.observe('emotion.sadness', sadness )
             if( !predErr.gated )
               _bus.publish({ type: 'emotion.sadness.elevated', version: 1, sourceEngine: this.name, salience: Math.min(1, sadness * 1.5), payload: { sadness } })
           }
@@ -168,7 +168,7 @@ export class LossEvaluator implements SimulationEngine, CognitiveEngine {
         const p = e.payload as { predictedDomains: string[]; confidence: number }
 
         if( p.predictedDomains.includes('affect') )
-          this._model.setPrecision( 'emotion.sadness', 1.0 + p.confidence * 0.5 )
+          this._model.setPrecision('emotion.sadness', 1.0 + p.confidence * 0.5 )
 
         // Approximate goal loss from prediction confidence:
         // Low confidence in domains signals uncertain/failing goals

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

@@ -114,7 +114,7 @@ export class MoralEvaluator implements SimulationEngine, CognitiveEngine {
     // Effective config = base engine-config-moral ⊕ persona-prior. Channel A: a
     // conscientious Will develops a lower eventThreshold and so registers moral
     // self-evaluations (guilt/shame/pride) more readily — the dutifulness facet.
-    const p = readEffectiveParams( state, 'engine-config-moral' )
+    const p = readEffectiveParams( state, 'engine-config-moral')
 
     if( p.eventThreshold != null ) this._eventThreshold = p.eventThreshold
     if( p.decayRate != null ) this._decayRate = p.decayRate
@@ -150,10 +150,10 @@ export class MoralEvaluator 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('moral') )
-        this._model.setPrecision( 'emotion.guilt', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('emotion.guilt', 1.0 + p.confidence * 0.5 )
     }
   }
 
@@ -251,7 +251,7 @@ export class MoralEvaluator implements SimulationEngine, CognitiveEngine {
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus && ( guilt > 0.4 || shame > 0.4 ) ){
-      const predErr = this._model.observe( 'emotion.guilt', guilt )
+      const predErr = this._model.observe('emotion.guilt', guilt )
       if( !predErr.gated )
         _bus.publish({ type: 'emotion.guilt.elevated', version: 1, sourceEngine: this.name, salience: Math.min(1, guilt * 1.5), payload: { guilt, shame, pride } })
     }

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

@@ -81,7 +81,7 @@ export class NoveltyDetector implements SimulationEngine, CognitiveEngine {
   private _readConfigFromState( state: ReadonlySimulationState ): void {
     // Effective config = base engine-config-novelty ⊕ persona-prior. Channel A: an open
     // Will develops a lower significanceThreshold and so registers novelty more readily.
-    const p = readEffectiveParams( state, 'engine-config-novelty' )
+    const p = readEffectiveParams( state, 'engine-config-novelty')
     if( p.learningRate != null ) this._learningRate = p.learningRate
     if( p.windowSize != null ) this._windowSize = p.windowSize
     if( p.significanceThreshold != null ) this._significanceThreshold = p.significanceThreshold
@@ -93,10 +93,10 @@ export class NoveltyDetector 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('perception') )
-        this._model.setPrecision( 'novelty.score', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('novelty.score', 1.0 + p.confidence * 0.5 )
     }
   }
 
@@ -171,7 +171,7 @@ export class NoveltyDetector implements SimulationEngine, CognitiveEngine {
       _bus.publish({ type: 'perception.novelty.spike', version: 1, sourceEngine: this.name, salience: Math.min(1, overallNovelty * 2), payload: { novelty: overallNovelty } })
     // Phase D + F: rich state-change event — gated by prediction error
     if( _bus ){
-      const predErr = this._model.observe( 'novelty.score', overallNovelty )
+      const predErr = this._model.observe('novelty.score', overallNovelty )
       if( !predErr.gated )
         _bus.publish({ type: 'novelty.state.changed', version: 1, sourceEngine: this.name, salience: predErr.salience, payload: { novelty: overallNovelty, socialEvaluationThreat: state.metrics.get('social.evaluation_threat') ?? 0, activeAgents: state.metrics.get('social.active_agents') ?? 0, fearLevel: state.metrics.get('emotion.fear') ?? 0 } })
     }