@mindot/will 0.8.0 → 0.9.0

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

@@ -59,6 +59,18 @@ export interface ExecutiveOutputFull {
     name?:    string
     learned?: string[]
     feeling?: number
+    /**
+     * "This is the same someone as that" — another keid I now believe is this
+     * same referent, fusing two of my records into one.
+     *
+     * The mind's own verdict on an identity, and it may do what the recognition
+     * heuristic will not: absorb an ESTABLISHED relationship. The heuristic is
+     * right to refuse — fusing two real people who share a name would take one of
+     * them's whole history — but the mind has evidence a name-match does not,
+     * usually because somebody just told it. Without this, the same human
+     * well-established on two channels stayed two people permanently.
+     */
+    sameAs?:  string
   }>
   newGoals?: Array<{
     description: string
@@ -70,6 +82,8 @@ export interface ExecutiveOutputFull {
   goalsToAbandon?: Array<{ goalId: string; reason: string }>
   goalsToReprioritize?: Array<{ goalId: string; newPriority: number; reason: string }>
   selfObservations?: string[]
+  /** Compound actions the mind is naming as single skills (see ProposedSkill). */
+  newSkills?: ProposedSkill[]
   /**
    * Plain-text reply from a conversation facet — populated by parseResponse()
    * from the [REPLY_TEXT]...[/REPLY_TEXT] block.
@@ -77,6 +91,11 @@ export interface ExecutiveOutputFull {
    * Paragraphs (double-newline separated) map to separate reply bubbles.
    */
   replyText?: string
+  /**
+   * Set when the facet declared it is NOT speaking this cycle, carrying why.
+   * Present ⇒ nothing is sent, whatever else the response contains.
+   */
+  noMessage?: string
   /**
    * @deprecated Legacy JSON reply format — no longer emitted by conversation facets.
    * Kept for backward compatibility with any tests/tooling that inspect parsed output.
@@ -287,6 +306,33 @@ export interface ExecutiveContext {
     /** planId if this action came from a plan step */
     planId?: string
   }>
+  /**
+   * What the mind has said to people lately, and who has answered.
+   *
+   * The one thing it could never see about itself. `conversation.sent` has been in
+   * state since the beginning — 57 records on the Will this was found on — and
+   * reached no prompt at all, so the sole evidence of having spoken was a `✓
+   * reach-out` line under Recent Action Outcomes: no words, no person, and a tick
+   * mark asserting it had worked. That is why the same question went out eleven
+   * times in two and a half minutes; from the inside each one was the first.
+   *
+   * Newest first. Answered turns are kept alongside open ones deliberately — "I
+   * asked and they replied" and "I asked and heard nothing" only mean anything
+   * against each other.
+   */
+  spokenTurns: Array<{
+    /** Who it was said to, by name where the mind knows one. */
+    target:  string
+    /** The opening words — enough to recognise a thing already said. */
+    preview: string
+    /** Ticks since it was said. */
+    age:     number
+    /** Unset while still in the air; the mind is told which. */
+    answered: boolean
+    /** What they said back, when they did. The fact of an answer without its
+     *  content is worse than silence — it invites acting as though it is known. */
+    answeredWith?: string
+  }>
   /** Behavioral disposition loaded from PMA at session start — stable per session. */
   behavioralDisposition?: {
     riskTolerance:   number
@@ -309,6 +355,10 @@ export interface ExecutiveContext {
    * Omitted when the Will knows no one.
    */
   knownEntities?: Array<{
+    /** Where this referent is reachable, and how each place has gone. */
+    handles?: Array<{ keid: string; kind: string; answeredAgo?: number }>
+    /** Names of referents this one may be the same as — an unsettled identity. */
+    mayBeSameAs?: string[]
     keid:            string
     kind:            'sentient' | 'thing'
     name?:           string
@@ -336,6 +386,25 @@ export interface ExecutiveContext {
 
 // ── Pending message ──────────────────────────────────────────
 
+/**
+ * A compound action the mind names as one thing it does — "when I do A then B,
+ * that is <name>". Registered into the SchemaRepertoire as a composite, after
+ * which it competes as a single affordance and can proceduralize into a habit.
+ *
+ * This is the creation seam for the instrumental→habitual gradient. Before it,
+ * `agency.composite.proposed` was subscribed by ReafferenceEngine — whose handler
+ * is the only caller of `registerComposite()` anywhere — and published by nothing,
+ * so no Will could ever hold a skill beyond the innate floor (#114).
+ */
+export interface ProposedSkill {
+  /** What the mind calls it. Becomes the schema id. */
+  id: string
+  /** The sub-schemas it is made of, in order. Two or more, or it is not compound. */
+  composedOf: string[]
+  tags?: string[]
+  cost?: number
+}
+
 export interface PendingMessage {
   id: string
   content: string

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,
       })
     }
   }
@@ -852,11 +887,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 +918,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 +928,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 +1069,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,