@mindot/will 0.4.0 → 0.6.0

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

@@ -254,12 +254,12 @@ export class PersonaConsolidator implements SimulationEngine, CognitiveEngine {
     switch( e.type ){
       case 'confidence.calibrated': {
         const p = e.payload as { calibrationBias?: number }
-        if( typeof p.calibrationBias === 'number' ) this._latestCalibrationBias = p.calibrationBias
+        if( typeof p.calibrationBias === 'number') this._latestCalibrationBias = p.calibrationBias
         break
       }
       case 'bias.detected': {
         const p = e.payload as { newCount?: number; types?: string[] }
-        if( typeof p.newCount === 'number' ) this._latestBiasNovelty = p.newCount
+        if( typeof p.newCount === 'number') this._latestBiasNovelty = p.newCount
         const types = Array.isArray( p.types ) ? p.types : []
         this._latestBeliefBiasNovelty = types.filter( t => BELIEF_BIAS_TYPES.has( t ) ).length
         this._latestMemoryBiasNovelty = types.filter( t => MEMORY_BIAS_TYPES.has( t ) ).length
@@ -267,13 +267,13 @@ export class PersonaConsolidator implements SimulationEngine, CognitiveEngine {
       }
       case 'self_model.updated': {
         const p = e.payload as { changeMagnitude?: number }
-        if( typeof p.changeMagnitude === 'number' ) this._latestSelfModelChange = p.changeMagnitude
+        if( typeof p.changeMagnitude === 'number') this._latestSelfModelChange = p.changeMagnitude
         break
       }
       case 'introspection.insight': {
         // significance = how substantive this introspection was (biases + lessons surfaced).
         const p = e.payload as { significance?: number }
-        if( typeof p.significance === 'number' ) this._latestInsightSignificance = p.significance
+        if( typeof p.significance === 'number') this._latestInsightSignificance = p.significance
         break
       }
     }
@@ -293,13 +293,13 @@ export class PersonaConsolidator implements SimulationEngine, CognitiveEngine {
 
   restore( snap: Record<string, unknown> ): void {
     if( !snap ) return
-    if( typeof snap.lastConsolidationTick  === 'number' ) this._lastConsolidationTick  = snap.lastConsolidationTick
-    if( typeof snap.latestCalibrationBias  === 'number' ) this._latestCalibrationBias  = snap.latestCalibrationBias
-    if( typeof snap.latestBiasNovelty      === 'number' ) this._latestBiasNovelty      = snap.latestBiasNovelty
-    if( typeof snap.latestBeliefBiasNovelty === 'number' ) this._latestBeliefBiasNovelty = snap.latestBeliefBiasNovelty
-    if( typeof snap.latestMemoryBiasNovelty === 'number' ) this._latestMemoryBiasNovelty = snap.latestMemoryBiasNovelty
-    if( typeof snap.latestSelfModelChange  === 'number' ) this._latestSelfModelChange  = snap.latestSelfModelChange
-    if( typeof snap.latestInsightSignificance === 'number' ) this._latestInsightSignificance = snap.latestInsightSignificance
+    if( typeof snap.lastConsolidationTick  === 'number') this._lastConsolidationTick  = snap.lastConsolidationTick
+    if( typeof snap.latestCalibrationBias  === 'number') this._latestCalibrationBias  = snap.latestCalibrationBias
+    if( typeof snap.latestBiasNovelty      === 'number') this._latestBiasNovelty      = snap.latestBiasNovelty
+    if( typeof snap.latestBeliefBiasNovelty === 'number') this._latestBeliefBiasNovelty = snap.latestBeliefBiasNovelty
+    if( typeof snap.latestMemoryBiasNovelty === 'number') this._latestMemoryBiasNovelty = snap.latestMemoryBiasNovelty
+    if( typeof snap.latestSelfModelChange  === 'number') this._latestSelfModelChange  = snap.latestSelfModelChange
+    if( typeof snap.latestInsightSignificance === 'number') this._latestInsightSignificance = snap.latestInsightSignificance
   }
 
   async react(
@@ -383,7 +383,7 @@ export class PersonaConsolidator implements SimulationEngine, CognitiveEngine {
     // Self-model traits (developed from the Will's own behaviour) that shape grit.
     // Above-baseline deviation only — pushes grit up when persistence is demonstrated;
     // decay returns to the seeded baseline when the behaviour stops.
-    const traits     = ( state.entities.get( 'identity-self' )?.metadata?.traits ?? {} ) as Record<string, number>
+    const traits     = ( state.entities.get('identity-self')?.metadata?.traits ?? {} ) as Record<string, number>
     const persistDev = Math.max( 0, ( traits[ 'persistence' ] ?? PERSISTENCE_BASELINE ) - PERSISTENCE_BASELINE )
     const resilDev   = Math.max( 0, ( traits[ 'resilience' ]  ?? PERSISTENCE_BASELINE ) - PERSISTENCE_BASELINE )
     const conscDev   = Math.max( 0, ( traits[ 'conscientiousness' ] ?? PERSISTENCE_BASELINE ) - PERSISTENCE_BASELINE )

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

@@ -196,7 +196,7 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
       case 'executive.prediction.formed': {
         const p = e.payload as { predictedDomains: string[]; confidence: number }
         if( p.predictedDomains.includes('planning') )
-          this._model.setPrecision( 'planning.plans', 1.0 + p.confidence * 0.5 )
+          this._model.setPrecision('planning.plans', 1.0 + p.confidence * 0.5 )
         break
       }
 
@@ -217,15 +217,15 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
         // (observed live: 8 authorings for one goal, zero completions).
         // Deterministic: stores iterate in insertion order; first match wins.
         if( !p.planId || !p.stepId ){
-          if( !p.actionType || typeof p.success !== 'boolean' ) return
+          if( !p.actionType || typeof p.success !== 'boolean') return
           for( const plan of this._store.all() ){
-            if( plan.status !== 'executing' ) continue
+            if( plan.status !== 'executing') continue
             const step = plan.steps.find( s => s.status === 'active' && s.action === p.actionType )
             if( !step ) continue
-            logger.info( `[planning] conscious-enaction credit: ${plan.id}/${step.id}=${step.action} (no provenance on outcome)` )
+            logger.info(`[planning] conscious-enaction credit: ${plan.id}/${step.id}=${step.action} (no provenance on outcome)`)
             this._onStepOutcome( plan.id, step.id, {
               success: p.success,
-              description: p.description ?? ( p.success ? 'Completed' : 'Failed' ),
+              description: p.description ?? ( p.success ? 'Completed' : 'Failed'),
               outcomeQuality: p.outcomeQuality,
             } )
             return   // credit exactly one step per outcome
@@ -236,18 +236,18 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
 
         this._onStepOutcome( p.planId, p.stepId, {
           success: p.success,
-          description: p.description ?? ( p.success ? 'Completed' : 'Failed' ),
+          description: p.description ?? ( p.success ? 'Completed' : 'Failed'),
           outcomeQuality: p.outcomeQuality,
         } )
         break
       }
 
       case 'goal.achieved':
-        this._cancelPlansForGoal( ( e.payload as { goalId?: string } ).goalId, 'goal achieved' )
+        this._cancelPlansForGoal( ( e.payload as { goalId?: string } ).goalId, 'goal achieved')
         break
 
       case 'goal.abandoned':
-        this._cancelPlansForGoal( ( e.payload as { goalId?: string } ).goalId, 'goal abandoned' )
+        this._cancelPlansForGoal( ( e.payload as { goalId?: string } ).goalId, 'goal abandoned')
         break
     }
   }
@@ -276,14 +276,14 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
           planId:             plan.id,
           goalId:             plan.goalId,
           reason,
-          completedSteps:     plan.steps.filter( s => s.status === 'completed' ).length,
+          completedSteps:     plan.steps.filter( s => s.status === 'completed').length,
           totalSteps:         plan.steps.length,
           requestingEntityId: plan.requestingEntityId,
           requestingThreadId: plan.requestingThreadId,
         }
       } )
 
-      logger.info( `[planning] plan ${plan.id} cancelled — ${reason} (goal ${goalId})` )
+      logger.info(`[planning] plan ${plan.id} cancelled — ${reason} (goal ${goalId})`)
     }
   }
 
@@ -344,7 +344,7 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
 
     // 5. Metrics
     const executingPlans = Array.from( this._store.all() )
-                                .filter( p => p.status === 'executing' || p.status === 'ready' )
+                                .filter( p => p.status === 'executing' || p.status === 'ready')
 
     commands.metrics!.push(
       [ 'planning.total_plans',     this._store.size ],
@@ -352,17 +352,17 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
       [ 'planning.active_facets',    this._supervisor.activeFacetCount ],
       // Supervision distribution — how the mind corrects course mid-execution. The
       // raw signal the planning-quality eval harness reads (replan/abandon rates etc).
-      [ 'planning.supervision.replan',   this._supervisor.supervisionCount( 'replan' ) ],
-      [ 'planning.supervision.retry',    this._supervisor.supervisionCount( 'retry' ) ],
-      [ 'planning.supervision.skip',     this._supervisor.supervisionCount( 'skip' ) ],
-      [ 'planning.supervision.escalate', this._supervisor.supervisionCount( 'escalate' ) ],
-      [ 'planning.supervision.abandon',  this._supervisor.supervisionCount( 'abandon' ) ],
+      [ 'planning.supervision.replan',   this._supervisor.supervisionCount('replan') ],
+      [ 'planning.supervision.retry',    this._supervisor.supervisionCount('retry') ],
+      [ 'planning.supervision.skip',     this._supervisor.supervisionCount('skip') ],
+      [ 'planning.supervision.escalate', this._supervisor.supervisionCount('escalate') ],
+      [ 'planning.supervision.abandon',  this._supervisor.supervisionCount('abandon') ],
     )
 
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus && this._store.size > 0 ){
-      const predErr = this._model.observe( 'planning.plans', this._store.size )
+      const predErr = this._model.observe('planning.plans', this._store.size )
       if( !predErr.gated )
         _bus.publish( {
           type: 'planning.plan.created', version: 1, sourceEngine: this.name,
@@ -385,10 +385,10 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
    * dispositions, no wall-clock, no RNG.
    */
   private _readConfigFromState( state: ReadonlySimulationState ): void {
-    const p = readEffectiveParams( state, 'engine-config-planning' )
-    if( typeof p.maxStepRetries         === 'number' ) this._dispositions.maxStepRetries         = p.maxStepRetries
-    if( typeof p.surpriseOutcomeQuality === 'number' ) this._dispositions.surpriseOutcomeQuality = p.surpriseOutcomeQuality
-    if( typeof p.planBiasGain           === 'number' ) this._dispositions.planBiasGain           = p.planBiasGain
+    const p = readEffectiveParams( state, 'engine-config-planning')
+    if( typeof p.maxStepRetries         === 'number') this._dispositions.maxStepRetries         = p.maxStepRetries
+    if( typeof p.surpriseOutcomeQuality === 'number') this._dispositions.surpriseOutcomeQuality = p.surpriseOutcomeQuality
+    if( typeof p.planBiasGain           === 'number') this._dispositions.planBiasGain           = p.planBiasGain
   }
 
   // ── Plan ingestion ─────────────────────────────────────────
@@ -427,24 +427,24 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
             break
           }
 
-          this._createPlan( planData, tick, 'draft' )
+          this._createPlan( planData, tick, 'draft')
           break
         }
 
         case 'validate': {
           if( !existingPlan ){
-            this._createPlan( planData, tick, 'validated' )
+            this._createPlan( planData, tick, 'validated')
             break
           }
 
           existingPlan.status = 'validated'
-          logger.info( `[planning] plan ${existingPlan.id} validated` )
+          logger.info(`[planning] plan ${existingPlan.id} validated`)
           break
         }
 
         case 'execute': {
           if( !existingPlan ){
-            const newPlan = this._createPlan( planData, tick, 'approved' )
+            const newPlan = this._createPlan( planData, tick, 'approved')
             newPlan.status = 'ready'
             // Infer supervision (emergent tier): important/uncertain plans start
             // deliberate (a facet supervises from the first step); else automatic.
@@ -470,7 +470,7 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
         }
 
         case 'revise': {
-          if( !existingPlan ){ this._createPlan( planData, tick, 'revised' ); break }
+          if( !existingPlan ){ this._createPlan( planData, tick, 'revised'); break }
 
           existingPlan.steps = planData.steps.map( ( s, i ) => ( {
             id: `step-${i}`,
@@ -505,7 +505,7 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
           this._store.markTerminal( existingPlan.id, this._lastTick )
           this._supervisor.cleanupFacet( existingPlan.id )
 
-          logger.info( `[planning] plan ${existingPlan.id} cancelled` )
+          logger.info(`[planning] plan ${existingPlan.id} cancelled`)
           break
         }
       }
@@ -565,9 +565,9 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
 
   private _executePlans(): void {
     for( const plan of this._store.all() ){
-      if( plan.status !== 'ready' && plan.status !== 'executing' ) continue
+      if( plan.status !== 'ready' && plan.status !== 'executing') continue
 
-      if( plan.status === 'ready' ){
+      if( plan.status === 'ready'){
         plan.status = 'executing'
 
         // Emit plan.started so the activity stream knows execution has begun.
@@ -592,14 +592,14 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
           this._activateStep( plan, step )
 
       // Check for plan completion
-      const allDone   = plan.steps.every( s => s.status === 'completed' || s.status === 'skipped' )
-      const anyFailed = plan.steps.some( s => s.status === 'failed' )
+      const allDone   = plan.steps.every( s => s.status === 'completed' || s.status === 'skipped')
+      const anyFailed = plan.steps.some( s => s.status === 'failed')
 
       if( allDone && !anyFailed )
         this._onPlanCompleted( plan )
 
-      else if( anyFailed && plan.executionTier === 'automatic' )
-        this._onPlanFailed( plan, 'One or more steps failed' )
+      else if( anyFailed && plan.executionTier === 'automatic')
+        this._onPlanFailed( plan, 'One or more steps failed')
     }
   }
 
@@ -638,7 +638,7 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
       totalSteps:  plan.steps.length,
     } as any)
 
-    logger.info( `[planning] step active: ${plan.id}/${step.id}=${step.action} (biasing the field)` )
+    logger.info(`[planning] step active: ${plan.id}/${step.id}=${step.action} (biasing the field)`)
   }
 
   // ── Step outcome handling ──────────────────────────────────
@@ -661,8 +661,8 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
     // already moved past — and re-running supervision below could re-spawn the facet
     // we just tore down. The enaction itself still happened (and still taught the
     // repertoire via reafference); the plan simply no longer cares.
-    if( plan.status !== 'executing' ){
-      logger.info( `[planning] ignoring late step outcome ${planId}/${stepId} — plan is ${plan.status}, not executing` )
+    if( plan.status !== 'executing'){
+      logger.info(`[planning] ignoring late step outcome ${planId}/${stepId} — plan is ${plan.status}, not executing`)
       return
     }
 
@@ -688,7 +688,7 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
         success:            outcome.success,
         outcomeQuality:     outcome.outcomeQuality,
         description:        outcome.description.slice( 0, 300 ),
-        completedSteps:     plan.steps.filter( s => s.status === 'completed' || s.status === 'skipped' ).length,
+        completedSteps:     plan.steps.filter( s => s.status === 'completed' || s.status === 'skipped').length,
         totalSteps:         plan.steps.length,
         requestingEntityId: plan.requestingEntityId,
         requestingThreadId: plan.requestingThreadId,
@@ -704,7 +704,7 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
       success:        outcome.success,
       outcomeQuality: outcome.outcomeQuality,
       description:    outcome.description.slice( 0, 300 ),
-      completedSteps: plan.steps.filter( s => s.status === 'completed' || s.status === 'skipped' ).length,
+      completedSteps: plan.steps.filter( s => s.status === 'completed' || s.status === 'skipped').length,
       totalSteps:     plan.steps.length,
     } as any)
 
@@ -714,15 +714,15 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
     // extension point for more triggers.
     if( plan.executionTier !== 'deliberate' && this._supervisor.shouldEscalate( plan, step, outcome ) ){
       plan.executionTier = 'deliberate'
-      logger.info( `[planning] plan ${planId} escalated to deliberate (surprise on ${stepId})` )
+      logger.info(`[planning] plan ${planId} escalated to deliberate (surprise on ${stepId})`)
       this._supervisor.activateFacet( plan, false )   // lazy spawn; the step report below follows
     }
 
-    if( plan.executionTier === 'deliberate' ){
+    if( plan.executionTier === 'deliberate'){
       const reported = this._supervisor.reportToFacet( plan, step, outcome )
       if( !reported ){
         // attention saturated / spawn failed → activateFacet downgraded to automatic
-        logger.warn( `[planning] no facet to supervise plan ${planId}; continuing automatically` )
+        logger.warn(`[planning] no facet to supervise plan ${planId}; continuing automatically`)
         this._executePlans()
       }
     }
@@ -742,15 +742,15 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
       payload: {
         planId:             plan.id,
         goalId:             plan.goalId,
-        completedSteps:     plan.steps.filter( s => s.status === 'completed' ).length,
-        skippedSteps:       plan.steps.filter( s => s.status === 'skipped' ).map( s => s.id ),
+        completedSteps:     plan.steps.filter( s => s.status === 'completed').length,
+        skippedSteps:       plan.steps.filter( s => s.status === 'skipped').map( s => s.id ),
         totalSteps:         plan.steps.length,
         requestingEntityId: plan.requestingEntityId,
         requestingThreadId: plan.requestingThreadId,
       }
     } )
 
-    logger.info( `[planning] plan completed: ${plan.id} → goal ${plan.goalId}` )
+    logger.info(`[planning] plan completed: ${plan.id} → goal ${plan.goalId}`)
   }
 
   private _onPlanFailed( plan: Plan, reason: string ): void {
@@ -766,15 +766,15 @@ export class PlanningEngine implements SimulationEngine, CognitiveEngine {
         planId:             plan.id,
         goalId:             plan.goalId,
         reason,
-        completedSteps:     plan.steps.filter( s => s.status === 'completed' ).length,
-        skippedSteps:       plan.steps.filter( s => s.status === 'skipped' ).map( s => s.id ),
+        completedSteps:     plan.steps.filter( s => s.status === 'completed').length,
+        skippedSteps:       plan.steps.filter( s => s.status === 'skipped').map( s => s.id ),
         totalSteps:         plan.steps.length,
         requestingEntityId: plan.requestingEntityId,
         requestingThreadId: plan.requestingThreadId,
       }
     } )
 
-    logger.info( `[planning] plan failed: ${plan.id} — ${reason}` )
+    logger.info(`[planning] plan failed: ${plan.id} — ${reason}`)
   }
 
   // ── Recall descriptors (awareness Stage 2) ─────────────────

package/src/cognition/faculties/planning.engine/plan.frontier.ts

@@ -19,11 +19,11 @@ export function computeReadySet( plan: Plan ): PlanStep[] {
   const ready: PlanStep[] = []
 
   for( const step of plan.steps ){
-    if( step.status !== 'pending' ) continue
+    if( step.status !== 'pending') continue
 
     const allPrereqsSatisfied = step.prerequisites.every( prereqId => {
       const prereqStep = plan.steps.find( s => s.id === prereqId )
-      return prereqStep && ( prereqStep.status === 'completed' || prereqStep.status === 'skipped' )
+      return prereqStep && ( prereqStep.status === 'completed' || prereqStep.status === 'skipped')
     } )
 
     allPrereqsSatisfied && ready.push( step )
@@ -52,17 +52,17 @@ export function projectFrontier(
 ): void {
   // Clear the previous tick's priors — they are transient.
   for( const [ id, e ] of state.entities )
-    if( e.type === 'plan.prior' ) commands.delete!.push( id )
+    if( e.type === 'plan.prior') commands.delete!.push( id )
 
   for( const plan of plans ){
-    if( plan.status !== 'executing' ) continue
+    if( plan.status !== 'executing') continue
 
     // Channel A: conscientiousness develops `planBiasGain` UP, so a conscientious
     // Will pushes its plan's frontier harder against competing impulses.
     const strength = clamp01( ( 0.5 * goalPriority( plan.goalId ) + 0.5 * plan.confidence ) * biasGain )
 
     for( const step of plan.steps ){
-      if( step.status !== 'active' ) continue
+      if( step.status !== 'active') continue
       commands.set!.push({
         // tick in the id (like the affordance field) so this tick's fresh prior
         // never collides with last tick's cleared one in the same command batch.

package/src/cognition/faculties/planning.engine/plan.store.ts

@@ -24,7 +24,7 @@ export function planShapeKey(
   steps: ReadonlyArray<{ action: string; prerequisites?: readonly string[] }>,
 ): string {
   return steps
-    .map( s => `${ s.action }${ ( s.prerequisites?.length ?? 0 ) > 0 ? `<${ s.prerequisites!.length }` : '' }` )
+    .map( s => `${ s.action }${ ( s.prerequisites?.length ?? 0 ) > 0 ? `<${ s.prerequisites!.length }` : '' }`)
     .join('>')
 }
 

package/src/cognition/faculties/planning.engine/plan.supervision.ts

@@ -106,9 +106,9 @@ export class PlanSupervisor {
 
     try {
       const { attention, handle: facet } = this._executiveEngine.spawnFacet('supervision')
-      if( !facet || attention === 'full' ){
+      if( !facet || attention === 'full'){
         plan.executionTier = 'automatic'
-        logger.info( `[planning] attention full — plan ${plan.id} stays automatic (no facet)` )
+        logger.info(`[planning] attention full — plan ${plan.id} stays automatic (no facet)`)
         return
       }
 
@@ -125,7 +125,7 @@ export class PlanSupervisor {
       // facet whose report() silently no-ops. (P2)
       facet.onReaped( () => {
         this._activeFacets.delete( plan.id )
-        if( plan.status === 'executing' || plan.status === 'ready' )
+        if( plan.status === 'executing' || plan.status === 'ready')
           plan.executionTier = 'automatic'
         logger.info(
           `[planning] facet for plan ${plan.id} reaped — degraded to automatic`
@@ -138,7 +138,7 @@ export class PlanSupervisor {
         const initialReport: FacetReport = {
           type: 'plan.initialized',
           contextId: plan.id,
-          instructions: this._buildDecisionGuidance( 'plan.initialized', undefined ),
+          instructions: this._buildDecisionGuidance('plan.initialized', undefined ),
           payload: {
             planId: plan.id,
             goalId: plan.goalId,
@@ -150,10 +150,10 @@ export class PlanSupervisor {
         facet.report( initialReport )
       }
 
-      logger.info( `[planning] facet activated: plan=${plan.id} facetId=${facet.facetId}` )
+      logger.info(`[planning] facet activated: plan=${plan.id} facetId=${facet.facetId}`)
     }
     catch( err ){
-      logger.error( `[planning] facet failed for plan ${plan.id}:`, err )
+      logger.error(`[planning] facet failed for plan ${plan.id}:`, err )
       plan.executionTier = 'automatic'
     }
   }
@@ -188,7 +188,7 @@ export class PlanSupervisor {
                      s.status === 'failed'     ? '✗' :
                      s.status === 'active'     ? '→' : '○'
       return `${marker} [${s.id}] ${s.action}: ${s.description}`
-    } ).join( '\n' )
+    } ).join('\n')
 
     const completedCount = plan.steps.filter(
       s => s.status === 'completed' || s.status === 'skipped'
@@ -302,9 +302,9 @@ export class PlanSupervisor {
     const facet = this._activeFacets.get( plan.id )
     if( !facet ) return false
 
-    const allDone   = plan.steps.every( s => s.status === 'completed' || s.status === 'skipped' )
-    const anyFailed = plan.steps.some( s => s.status === 'failed' )
-    const pendingCount = plan.steps.filter( s => s.status !== 'completed' && s.status !== 'skipped' ).length
+    const allDone   = plan.steps.every( s => s.status === 'completed' || s.status === 'skipped')
+    const anyFailed = plan.steps.some( s => s.status === 'failed')
+    const pendingCount = plan.steps.filter( s => s.status !== 'completed' && s.status !== 'skipped').length
 
     let statusType: string
     if( allDone && !anyFailed )      statusType = 'plan_completed'
@@ -350,8 +350,8 @@ export class PlanSupervisor {
         prerequisites: s.prerequisites,
       } ) ),
       totalSteps: plan.steps.length,
-      completedSteps: plan.steps.filter( s => s.status === 'completed' || s.status === 'skipped' ).length,
-      skippedSteps: plan.steps.filter( s => s.status === 'skipped' ).map( s => s.id ),
+      completedSteps: plan.steps.filter( s => s.status === 'completed' || s.status === 'skipped').length,
+      skippedSteps: plan.steps.filter( s => s.status === 'skipped').map( s => s.id ),
       executionTier: plan.executionTier
     }
   }
@@ -385,14 +385,14 @@ export class PlanSupervisor {
         break
 
       case 'skip': {
-        const failedStep = plan.steps.find( s => s.status === 'failed' )
+        const failedStep = plan.steps.find( s => s.status === 'failed')
         if( failedStep ) failedStep.status = 'skipped'
         this._host.executePlans()
         break
       }
 
       case 'abandon': {
-        this._host.planFailed( plan, `Facet abandoned: ${decision.reasoning.slice( 0, 100 )}` )
+        this._host.planFailed( plan, `Facet abandoned: ${decision.reasoning.slice( 0, 100 )}`)
         this.cleanupFacet( plan.id )
         break
       }
@@ -410,7 +410,7 @@ export class PlanSupervisor {
             status: 'pending' as const,
           } ) )
 
-          logger.info( `[planning] plan ${plan.id} replanned (${plan.steps.length} steps)` )
+          logger.info(`[planning] plan ${plan.id} replanned (${plan.steps.length} steps)`)
 
           // Surface: the mind rewrote the plan mid-flight — a course-correction the
           // master should be aware of (mirrors plan.escalated). Only fires when steps
@@ -443,10 +443,10 @@ export class PlanSupervisor {
         // re-activates it on the frontier; capped per step so a stuck step can't loop forever.
         let retried = 0
         for( const s of plan.steps ){
-          if( s.status !== 'failed' ) continue
+          if( s.status !== 'failed') continue
           const n = s.retries ?? 0
           if( n >= this._dispositions.maxStepRetries ){
-            logger.info( `[planning] step ${s.id} retry exhausted (${n}/${this._dispositions.maxStepRetries}); left failed` )
+            logger.info(`[planning] step ${s.id} retry exhausted (${n}/${this._dispositions.maxStepRetries}); left failed`)
             continue
           }
           s.retries = n + 1
@@ -454,7 +454,7 @@ export class PlanSupervisor {
           s.outcome = undefined
           retried++
         }
-        logger.info( `[planning] plan ${plan.id} retrying ${retried} step(s)` )
+        logger.info(`[planning] plan ${plan.id} retrying ${retried} step(s)`)
         this._host.executePlans()
         break
       }
@@ -464,7 +464,7 @@ export class PlanSupervisor {
         // Free the facet's attention while held.
         plan.status = 'paused'
         this.cleanupFacet( plan.id )
-        logger.info( `[planning] plan ${plan.id} paused by facet` )
+        logger.info(`[planning] plan ${plan.id} paused by facet`)
         break
       }
 
@@ -485,7 +485,7 @@ export class PlanSupervisor {
             requestingThreadId: plan.requestingThreadId,
           }
         } )
-        logger.info( `[planning] plan ${plan.id} escalated to master` )
+        logger.info(`[planning] plan ${plan.id} escalated to master`)
         break
       }
     }

package/src/cognition/faculties/reputation.tracker.ts

@@ -97,12 +97,12 @@ export class ReputationTracker 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( 'reputation.tracked', 1.0 + p.confidence * 0.5 )
+        this._model.setPrecision('reputation.tracked', 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 }
       this._pendingInteractions.push( p )
     }
@@ -124,7 +124,7 @@ export class ReputationTracker implements SimulationEngine, CognitiveEngine {
     // agent's cooperativeness is refreshed each tick as base ⊕ persona-prior. An agreeable
     // Will develops a larger step — it extends benefit-of-the-doubt and credits cooperation
     // more readily (the trust facet).
-    this._trustGrowthStep = readEffectiveParams( state, 'engine-config-reputation' ).trustGrowthStep ?? this._trustGrowthStep
+    this._trustGrowthStep = readEffectiveParams( state, 'engine-config-reputation').trustGrowthStep ?? this._trustGrowthStep
 
     // Rehydrate _reputations from persisted state on the first tick after
     // construction / snapshot restore. Without this, every session restart
@@ -213,7 +213,7 @@ export class ReputationTracker implements SimulationEngine, CognitiveEngine {
     // Phase C + F: publish cognitive event — gated by prediction error
     const _bus = this._bus
     if( _bus && this._reputations.size > 0 ){
-      const predErr = this._model.observe( 'reputation.tracked', this._reputations.size )
+      const predErr = this._model.observe('reputation.tracked', this._reputations.size )
       if( !predErr.gated )
         _bus.publish({ type: 'reputation.updated', version: 1, sourceEngine: this.name, salience: Math.max( 0.2, predErr.salience ), payload: { trackedAgents: this._reputations.size } })
     }
@@ -240,7 +240,7 @@ export class ReputationTracker implements SimulationEngine, CognitiveEngine {
    */
   private _restoreFromState( state: ReadonlySimulationState ): void {
     for( const entity of state.entities.values() ){
-      if( entity.type !== 'reputation' ) continue
+      if( entity.type !== 'reputation') continue
       const m = entity.metadata ?? {}
       const keid = m['keid'] as string | undefined
       if( !keid ) continue

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

@@ -148,7 +148,7 @@ export class RewardEvaluator implements SimulationEngine, CognitiveEngine {
           this._cachedSocialReward = Math.min( 1, Math.max( 0,
             this._cachedSocialReward + contribution * this._socialWarmthBoost
           ))
-          this._model.observe( 'reward.social', this._cachedSocialReward )
+          this._model.observe('reward.social', this._cachedSocialReward )
         }
         break
       }
@@ -161,7 +161,7 @@ export class RewardEvaluator implements SimulationEngine, CognitiveEngine {
         const priority = p.priority ?? 0.5
         this._cachedGoalReward     = Math.min( 1, this._cachedGoalReward + priority * 0.9 )
         this._goalsCompletedRecently = Math.min( 2, this._goalsCompletedRecently + 1 )
-        this._model.observe( 'reward.goal', this._cachedGoalReward )
+        this._model.observe('reward.goal', this._cachedGoalReward )
         break
       }
 
@@ -185,7 +185,7 @@ export class RewardEvaluator 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-reward' )
+    const p = readEffectiveParams( state, 'engine-config-reward')
     if( p.goalWeight      != null ) this._goalWeight      = p.goalWeight
     if( p.socialWeight    != null ) this._socialWeight    = p.socialWeight
     if( p.resourceWeight  != null ) this._resourceWeight  = p.resourceWeight
@@ -289,7 +289,7 @@ export class RewardEvaluator implements SimulationEngine, CognitiveEngine {
       // workspace, a fully-expected reward goes quiet (dopamine-RPE analogue),
       // precision-modulated (set on 'reward.value'). observe() runs every tick so
       // the baseline tracks; the one value is reused across the reward events.
-      const rewardSalience = this._model.observe( 'reward.value', rewardLevel ).salience
+      const rewardSalience = this._model.observe('reward.value', rewardLevel ).salience
 
       if( joy > 0.5 )
         _bus.publish({ type: 'emotion.joy.peak', version: 1, sourceEngine: this.name, salience: rewardSalience, payload: { joy } })