@mindot/will 0.8.0 → 0.10.0

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

@@ -71,6 +71,21 @@ const DRIVE_TAGS = new Set([ 'energy', 'sleep', 'stress', 'survival', 'wellbeing
 // conscientiousness-developable baseSwitchCost, #28). Recomputed fresh each tick from
 // basePriority — never accumulates. This is what makes the focus mechanically "stick":
 // the focused goal stays top for goal selection, the executive, and planning.
+/**
+ * Schema ids and effector names that mean "the mind said something to someone".
+ *
+ * `reach-out` is the innate schema; `text`/`talk`/`gesture`/`broadcast` are the
+ * effectors it resolves to. Both spellings appear as an `action.outcome`'s
+ * `actionType` depending on which path emitted it, and only the second set was
+ * ever recognised here. Mirrors `COMM_SCHEMAS` in agency/execution.primitives.
+ */
+const COMMUNICATIVE_SCHEMAS = new Set([
+  'reach-out', 'reach_out', 'communicate', 'talk', 'text', 'broadcast', 'gesture',
+])
+
+/** Progress an action goal gains when the person it concerns actually answers. */
+const ANSWER_PROGRESS_STEP = 0.12
+
 const FOCUS_COMMITMENT_RAMP = 30   // ticks of focus to reach full commitment weight
 const COMMITMENT_GAIN       = 0.3  // scales switchCost × commitment × plan-sunk-cost
 const MAX_COMMITMENT_BOOST  = 0.2  // cap — a clearly higher-priority goal still wins
@@ -88,6 +103,10 @@ export interface GoalState {
   activatedAt: Tick
   deadline?: Tick
   tags: string[]
+  /** Why this goal was abandoned, when it was. Set only on status 'abandoned'.
+   *  The reason used to be pushed onto `tags`, which threw once the goal had
+   *  been rehydrated from a deep-frozen state entity. */
+  abandonedReason?: string
   /** Snapshot of memory.beliefs_total when this goal was activated.
    *  Used to compute epistemic progress: (currentBeliefs - baseline) / threshold. */
   beliefsAtActivation: number
@@ -199,6 +218,7 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
       'executive.facet.progress',
       'plan.completed',
       'action.outcome',   // 4.1: advance action-type goals when matching outcomes fire
+      'social.responsiveness',   // somebody answered — the only progress a message can make
     ]
   }
   publishes(): CognitiveEventSchema[] {
@@ -298,6 +318,13 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
         this._nudgeActionGoals( p.domain, p.actionType, p.outcomeQuality )
         break
       }
+      // A communicative act only advances a goal once somebody answers it. The
+      // send itself is not progress — see _nudgeActionGoals.
+      case 'social.responsiveness': {
+        const p = e.payload as { keid: string; answered: boolean }
+        if( p.answered === true && p.keid ) this._nudgeAnsweredGoals( p.keid )
+        break
+      }
     }
   }
 
@@ -565,8 +592,11 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
     const goal = this._goals.get( goalId )
     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)}`)
+      // On its own field, not pushed onto `tags`. A goal rehydrated from a state
+      // entity holds that entity's deep-frozen arrays by reference, so the push
+      // threw and the goal stayed active forever — still competing for salience,
+      // with the rest of the deferred-effects flush for that tick lost with it.
+      if( reason ) goal.abandonedReason = reason.slice( 0, 200 )
 
       this._sessionLogger?.write({
         type:        'goal.abandoned',
@@ -618,13 +648,18 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
         progress:            ( meta.progress              as number )   ?? 0,
         status,
         parentGoalId:        meta.parentGoalId as string | undefined,
-        subGoals:            ( meta.subGoals              as string[] ) ?? [],
+        // COPY, never adopt. `meta` belongs to a state entity, and the state
+        // manager deep-freezes those — adopting the array by reference gives the
+        // goal a frozen `tags`/`subGoals`, and the next push (abandonGoal, or
+        // addGoal appending to a parent) throws TypeError mid-tick.
+        subGoals:            [ ...( ( meta.subGoals as string[] ) ?? [] ) ],
         activatedAt:         ( meta.activatedAt as Tick ) ?? tick,
         deadline:            meta.deadline as Tick | undefined,
-        tags:                ( meta.tags                  as string[] ) ?? [],
+        tags:                [ ...( ( meta.tags     as string[] ) ?? [] ) ],
         beliefsAtActivation: ( meta.beliefsAtActivation   as number )   ?? this._currentBeliefCount,
         completionType:      ( meta.completionType as GoalState['completionType'] ) ?? 'epistemic',
         completionCondition: meta.completionCondition as string | undefined,
+        abandonedReason:     meta.abandonedReason as string | undefined,
       })
     }
   }
@@ -658,7 +693,12 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
                             .find( g => {
                               return g.tags.includes( mapping.tags[0]! )
                                       && g.tags.includes( mapping.tags[1]! )
-                                      && g.status === 'active'
+                                      // `pending` counts as existing. It did not, and a
+                                      // goal demoted for capacity therefore stopped
+                                      // blocking its own respawn — the drive minted a
+                                      // fresh copy every time its threshold was crossed.
+                                      // Measured: 92 identical copies of one goal.
+                                      && ( g.status === 'active' || g.status === 'pending')
                             })
 
       // Never spawn a goal that is *already satisfied* — it would complete on its
@@ -685,7 +725,9 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
         // Dedup by the referent (keid: tag) when present, else by description.
         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 ) )
+          // Same rule as the drive path: a waiting goal still exists.
+          ( g.status === 'active' || g.status === 'pending')
+          && ( keidTag ? g.tags.includes( keidTag ) : g.description === desc ) )
 
         // Don't spawn a goal that's already satisfied (born-done guard — see _activateFromDrives).
         if( !existing && !this._isConditionMet( cCond, state ) )
@@ -770,6 +812,32 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
     return 0
   }
 
+  /**
+   * Reconcile the active set to capacity — in BOTH directions.
+   *
+   * Demotion alone made `pending` a one-way door, and a mind fell through it.
+   * Nothing in this file promoted a goal back (the only other write of `'active'`
+   * is `pending_verification`'s, a different status), so a goal demoted for
+   * capacity was demoted for good. Worse, `pending` is excluded from every other
+   * mechanism that could have retired it: it is not in `getActiveGoals()`, not
+   * progress-updated, not reachable by the patience/grit sweep (which skips any
+   * status but `'active'`) — yet it IS re-persisted every tick and rehydrated on
+   * every restore. Inert and immortal at once.
+   *
+   * Measured on a live COO: 96 goal entities, of which **83 pending, 0 active**,
+   * and 92 of the 96 the same drive-spawned goal. `activeGoalCount` sat at 0, so
+   * `goalless_crisis` fired every 20 ticks forever while she carried 83 goals —
+   * and the `goal` term, the joint-largest weight in the affordance competition,
+   * contributed nothing to any choice she made.
+   *
+   * Promotion also restores GC reachability, which is the quieter half of the
+   * fix: an over-patient stale goal can only be abandoned while it is active.
+   *
+   * `activatedAt` is deliberately NOT refreshed on promotion. Refreshing it would
+   * let a goal cycle demote→promote and reset its own patience each time, making
+   * it unretirable — the immortality this fix exists to end, reintroduced by the
+   * back door. A goal's age is when it was taken up, not when it last got a slot.
+   */
   private _resolveConflicts(): void {
     const active = this.getActiveGoals()
 
@@ -778,6 +846,21 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
       const lowest = active.pop()
       if( lowest ) lowest.status = 'pending'
     }
+
+    // ...and take the best waiting goals back up when there is room. Only ever
+    // reached when UNDER capacity, so this cannot undo the demotion above:
+    // the loop leaves the set at exactly capacity, and this one starts below it.
+    if( active.length >= this._maxActiveGoals ) return
+
+    const waiting = Array.from( this._goals.values() )
+                         .filter( g => g.status === 'pending')
+                         .sort( ( a, b ) => b.priority - a.priority )
+
+    for( const goal of waiting ){
+      if( active.length >= this._maxActiveGoals ) break
+      goal.status = 'active'
+      active.push( goal )
+    }
   }
 
   // ── Internal: progress ───────────────────────────────────
@@ -852,11 +935,26 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
     const dLow = domain.toLowerCase()
     const aLow = actionType.toLowerCase()
 
-    // Communication actions — 'talk' and 'text' are always treated as
-    // matching the 'communication' and 'reply' tag families so goals created
-    // in response to incoming messages get their progress nudged.
-    const isCommunicationAction = aLow === 'talk' || aLow === 'text'
-                                || dLow === 'communication'
+    // A communicative act makes NO progress by being sent.
+    //
+    // This is the whole shape of the repetition failure, seen from the goal side.
+    // `action.outcome` for a message fires the moment the outbox accepts it, with
+    // `outcomeQuality` describing the delivery — so crediting it here would have a
+    // goal like "get a clear answer to one operational question" complete itself
+    // after nine unanswered messages, and the mind would be right to keep sending
+    // because sending was visibly working.
+    //
+    // The answer is progress. It arrives later, through `social.responsiveness`,
+    // and lands in _nudgeAnsweredGoals.
+    //
+    // (Before this the question was moot in the worst way: `actionType` for an
+    // outreach is the SCHEMA id, `reach-out`, and the old test looked only for
+    // 'talk'/'text', so no communicative act ever reached a goal at all. Measured
+    // on a live Will: 8 goals, 28 reach-outs, and `lastActionAttemptTick` unset on
+    // every single goal. The bridge was not miscalibrated, it was disconnected —
+    // which is why fixing the match alone would have turned a silent failure into
+    // a loud one.)
+    if( COMMUNICATIVE_SCHEMAS.has( aLow ) || dLow === 'communication') return
 
     for( const goal of this._goals.values() ){
       if( goal.status !== 'active' && goal.status !== 'blocked') continue
@@ -868,9 +966,7 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
             || t === aLow
             || dLow.includes( t ) || t.includes( dLow )
             || aLow.includes( t ) || t.includes( aLow )
-      }) || ( isCommunicationAction && goal.tags.some( t =>
-        t === 'communication' || t === 'reply' || t === 'conversation'
-      ) )
+      })
 
       if( hasMatch ){
         goal.progress = Math.min( 1, goal.progress + outcomeQuality * 0.12 )
@@ -880,6 +976,33 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
     }
   }
 
+  /**
+   * Somebody answered. Advance the action goals that were about reaching them.
+   *
+   * Linked the way every other goal→person link in the system is linked: the
+   * `keid:<id>` tag (selection.scoring's `collectGoalTargets` reads the same one
+   * to lift a reach-out's goal relevance) or `requestingEntityId`, set when a
+   * conversation escalation created the goal. Nothing here guesses from wording.
+   *
+   * Unmatched by design: a goal with no link to this person gets nothing, even if
+   * it is tagged 'communication'. Being answered by one person is not progress on
+   * wanting to talk to another.
+   */
+  private _nudgeAnsweredGoals( keid: string ): void {
+    const tag = `keid:${ keid }`.toLowerCase()
+
+    for( const goal of this._goals.values() ){
+      if( goal.status !== 'active' && goal.status !== 'blocked') continue
+      if( goal.completionType !== 'action') continue
+      if( goal.requestingEntityId !== keid
+        && !goal.tags.some( t => t.toLowerCase() === tag ) ) continue
+
+      goal.progress              = Math.min( 1, goal.progress + ANSWER_PROGRESS_STEP )
+      goal.lastActionAttemptTick = this._currentTick
+      goal.lastActionType        = 'answered'
+    }
+  }
+
   /** True when a metric completionCondition (e.g. "emotion.boredom < 40") is already met. */
   private _isConditionMet( condition: string | undefined, state: ReadonlySimulationState ): boolean {
     if( !condition ) return false
@@ -994,9 +1117,14 @@ export class GoalManager implements SimulationEngine, CognitiveEngine {
           progress:             goal.progress,
           status:               goal.status,
           parentGoalId:         goal.parentGoalId,
-          subGoals:             goal.subGoals,
+          // COPY on the way out too. The state manager deep-freezes what it
+          // stores, so handing it these arrays by reference freezes the
+          // manager's OWN copies — a goal created this session, never
+          // rehydrated, still ends up with an unpushable `tags`.
+          subGoals:             [ ...goal.subGoals ],
           deadline:             goal.deadline,
-          tags:                 goal.tags,
+          tags:                 [ ...goal.tags ],
+          abandonedReason:      goal.abandonedReason,
           beliefsAtActivation:  goal.beliefsAtActivation,
           completionType:       goal.completionType,
           completionCondition:  goal.completionCondition,