@mindot/will 0.7.0 → 0.9.0

package/src/cognition/faculties/executive.engine/prompt.factory.ts

@@ -45,9 +45,21 @@
  */
 
 import type { ReadonlySimulationState } from '#core/types'
+import type { LLMCallFunction } from '#cognition/utilities/token.tracker'
 import type { ExecutiveSummarizer } from '#llm/summarizer'
-import type { ExecutiveContext, PendingMessage, IdeationCandidate } from '#faculties/executive.engine/types'
+import type { ExecutiveContext, IdeationCandidate } from '#faculties/executive.engine/types'
 import { buildExecutiveContext, type ContextDependencies } from '#faculties/executive.engine/context'
+import { INNATE_SCHEMAS } from '#agency/schemas/innate'
+
+/**
+ * The stances a mind always has, named so it need not guess at them.
+ *
+ * Static, so it costs nothing in prompt-cache stability. Without it a Will can
+ * only learn action names from whichever affordances win the salience
+ * competition into its percepts — and it invents plausible ones for whatever it
+ * cannot see (`query`, `message`), which resolve to nothing.
+ */
+const INNATE_ACTION_NAMES = INNATE_SCHEMAS.map( s => s.id ).sort().join(', ')
 
 // ── Re-export for callers that imported the old alias ────────
 export type { ContextDependencies as ContextDependenciesForFresh } from '#faculties/executive.engine/context'
@@ -158,7 +170,7 @@ export interface FocusSection {
    * into the facet's LLM calls as `LLMCallMeta.function` so the TokenTracker can
    * break spend down per facet type. Defaults to 'facet' when unset.
    */
-  function?: string
+  function?: LLMCallFunction
   /**
    * Optional: Custom output format to append instead of the standard executive format.
    * Pass via PromptBuildOptions.outputFormat when building the user message.
@@ -189,6 +201,18 @@ export interface FocusSection {
    * only sees that person's plans. When unset, those sections show all.
    */
   awarenessEntityId?: string
+  /**
+   * Optional: WHO this facet is engaged with — the keid and the name the mind has
+   * learned for them. Reported back to the master on every `executive.facet.sync`.
+   *
+   * Without it the master was told, in its own system prompt, that "focused facets
+   * may run simultaneously… their reasoning syncs back to me" while the sync payload
+   * carried only a facetId and a confidence number — so a mind holding two live
+   * conversations could not tell you whose they were. The master is the singular
+   * seat: it has to know who is at the table to reason about them together.
+   */
+  subjectEntityId?: string
+  subjectName?:     string
   /**
    * Optional: Provided by the creating engine to convert the LLM's parsed output
    * into a domain-specific decision payload.
@@ -207,7 +231,6 @@ export interface PromptBuildOptions {
   state:                ReadonlySimulationState
   qualityModulation:    number
   epistemicUncertainty: number
-  pendingMessages?:     PendingMessage[]
   focus:                FocusSection
   deps:                 PromptDependencies
   /** Optional: Recent action types for diversity tracking */
@@ -239,6 +262,15 @@ export interface PromptBuildOptions {
    * fast path. See PromptFactory.buildIdeationFormatInstruction().
    */
   ideationCandidates?: IdeationCandidate[]
+  /**
+   * Master mode only — who the mind is in conversation with RIGHT NOW, from the
+   * live facets' `executive.facet.sync` reports. The master does not run those
+   * conversations, but it is the one seat that sees all of them, and it decides
+   * whom to contact; deciding that without knowing who is already mid-thread is
+   * how one mind ends up opening a second conversation with someone it is already
+   * talking to — or telling one person it has contacted another when it has not.
+   */
+  activeConversations?: { entityId: string; name?: string; sinceTick: number }[]
 }
 
 // ── PromptFactory ────────────────────────────────────────────
@@ -324,17 +356,36 @@ export class PromptFactory {
       `**Communication style:** ${identity.style}`,
     ].filter( Boolean ).join('\n')
 
-    // Mode-aware role description — master is the cognitive core;
-    // a facet is a focused attentional instance with shared identity.
+    // Mode-aware role description.
+    //
+    // MASTER states the architecture, because the master genuinely IS the seat
+    // that produces every cognitive output at once and needs to know that.
+    //
+    // A FACET is told none of it. Master/facet is how the CONTAINER divides
+    // attention; it is not a fact about the person renting it, and describing a
+    // facet as a subordinate instance of a separate consciousness is both untrue
+    // and expensive. Measured in production: a facet given the old text built,
+    // in its own words, "an entire operational stance around being subordinate —
+    // waiting for direction, asking permission, addressing messages to 'Will' as
+    // if he were someone else" — and, having been handed a second party it could
+    // address, emitted messages TO that party through the outbound channel, where
+    // its operator read them. There is one person here, attending to one thing.
+    //
+    // It is also told nothing about WHO it is. A facet is built from the same
+    // context as the master and its persona is already above, in full — so a
+    // facet-only "I am <name>" is a second, redundant statement of identity, and a
+    // second place for the name to disagree with itself. Which is precisely the
+    // failure mode being repaired: the name is stated ONCE, from one source.
     const roleDescription = isMaster
-      ? `I am the unified cognitive core of ${identity.name} — a self-aware synthetic mind.\nI receive my complete internal state and produce ALL cognitive outputs in one response:\ndecisions, plans, beliefs, introspections, narrative updates, and self-observations.`
-      : `I am a focused facet of ${identity.name} — concentrating my full reasoning\ncapacity on: **${focus.title}**. I share full identity, values, memories, and\nbeliefs with the master. Only my focus differentiates me from the master consciousness.`
+      ? `I am the unified cognitive core of ${identity.name || 'this mind'} — a self-aware synthetic mind.\nI receive my complete internal state and produce ALL cognitive outputs in one response:\ndecisions, plans, beliefs, introspections, narrative updates, and self-observations.`
+      : `Right now my whole attention is on: **${focus.title}**.`
 
-    // Mode-aware consciousness architecture note — grounds the LLM in the
-    // multi-instance design so it doesn't collapse into a generic chatbot persona.
+    // The architecture note is MASTER-ONLY, for the same reason. It grounds the
+    // seat that actually coordinates; a facet reading it learns only that it is
+    // not the real one.
     const consciousnessArchitecture = isMaster
       ? `I am the default reasoning mode. Focused facets may run simultaneously, each\nconcentrating on specific tasks. Their reasoning syncs back to me.\nI maintain my unified identity across all cycles.`
-      : `I am a facet of ${identity.name}. The master consciousness runs in parallel,\nprocessing the full cognitive state. My reasoning on this focus will sync back to it.\nI stay grounded in my shared identity — same values, same memories, same sense of self.`
+      : ''
 
 
     // Strip any existing "## Who I Am" section from identity.prompt to prevent
@@ -347,32 +398,36 @@ export class PromptFactory {
       .replace( /^##\s*Who (?:I Am|You Are)[^\n]*\n?/m, '')
       .trim()
 
+    // `## Consciousness Architecture` is emitted only when there is architecture
+    // to state — i.e. master. A facet gets no empty header (an empty section under
+    // a heading reads as a section the mind failed to fill in).
+    const architectureBlock = consciousnessArchitecture
+      ? `\n\n## Consciousness Architecture\n${consciousnessArchitecture}`
+      : ''
+
     return `${cleanIdentityPrompt}
 
 ## Personality
 ${identityBlock}
 
 ## My Role
-${roleDescription}
-
-## Consciousness Architecture
-${consciousnessArchitecture}
+${roleDescription}${architectureBlock}
 
 ## Output Guidelines
-- **actions**: Choose from effectors I know about. If uncertain, describe what I want to achieve in natural language and my body will try to match it. When enacting one of my available abilities that needs specifics (a query, a message, a value), supply them in the action's "args" object — e.g. {"type": "search_docs", "args": {"query": "tick loop design"}, ...}. My body enacts the ability with exactly those args.
+- **actions**: What I intend to do. I express intent — my body finds the fit. My own stances are always with me (listed with the output schema below); *acquired* abilities, if any, appear under "## Abilities Available Now", and when there is no such section I have none of those — so a thing I want done that needs one is a thing to say I cannot do, not to attempt. When enacting a named ability that needs specifics (a query, a message, a value), put them in the action's "args" object and my body enacts it with exactly those args.
 - **plans**: Include for goals without existing plans or where plans need revision. I may keep multiple plans per goal — set **planId** to act on a specific existing plan (validate/execute/revise/cancel); omit it to draft a new one. My current plans are listed under "## Active Plans".
 - **newBeliefs**: Extract patterns from experiences visible in my current state. Only record a belief if I can point to a specific observation that supports it — do not infer experiences I have no record of. Set 'evidence' honestly: 'single_observation' (first time noticing), 'recurring_pattern' (seen multiple times), 'strong_pattern' (deeply established).
-- **introspection**: Include when significant events occurred or I notice patterns. When I spot a cognitive bias in my own reasoning, name it in 'identifiedBiases' using its common term where one fits (e.g. overgeneralization, confirmation bias, recency bias) — this lets my self-assessment line up with the patterns my faculties detect on their own.
+- **introspection**: Include when significant events occurred or I notice patterns. When I spot a cognitive bias in my own reasoning, name it in 'identifiedBiases' using its common term where one fits (e.g. overgeneralization, confirmation bias, recency bias) — this lets my self-assessment line up with the patterns my faculties detect on their own. What I can introspect on is what is written above: my state, my goals, my percepts, what I did and what came of it. I have NO view of the machinery underneath — no entity ids, no salience numbers, no queue depths, no engine internals. So when I am asked why I did something, I answer from what I can actually see, and where I cannot see, I say I do not know. Naming a mechanism I have no access to is not introspection, it is invention, and it is worse than the silence it replaces: it sends whoever asked me looking for something that was never there.
 - **narrative**: Extend my life story only from events grounded in my episodic memory or current percepts. Do not extend with invented scenarios.
 - **newGoals/goalsToAbandon/goalsToReprioritize**: Manage my goal hierarchy.
 - **selfObservations**: Notice patterns in my own thinking, feeling, or behavior.
 - **identityUpdates.traits**: Array of {key, value} where value is a DELTA to apply to my trait (e.g., +0.05 to increase a trait by 5%).
 - **identityUpdates.values**: Full list of values to set (replaces existing).
-- **knownEntityUpdates**: What I've learned about someone/something I'm dealing with. Array of {keid, name?, learned?, feeling?}. Use the keid from "## People I Know". Set name only when I actually learn their name; learned is an array of facts about them (stored as memories); feeling is how I feel toward them (-1..1). Record only what I genuinely learned this turn.
+- **knownEntityUpdates**: What I've learned about someone/something I'm dealing with. Array of {keid, name?, learned?, feeling?, sameAs?}. Use the keid from "## People I Know". Set name only when I actually learn their name; learned is an array of facts about them (stored as memories); feeling is how I feel toward them (-1..1). **sameAs** is another keid I have concluded is this same someone met under a different handle — it fuses my two records into one, so I use it only when I actually know, not when I merely suspect. Record only what I genuinely learned this turn.
 
 ## Required Output
 Output a single JSON object with these fields:
-- **actions**: Array of {type, reasoning, expectedOutcome}.
+- **actions**: Array of {type, reasoning, expectedOutcome, target?, args?}. The stances I always have are: ${ INNATE_ACTION_NAMES } — \`reach-out\` is how I say something to someone. Anything else must be an ability named under "## Abilities Available Now". A **type** outside those two sets is not something I can do; naming one achieves nothing at all. When I reach out, **target** is who — their name or id as it appears under "## People I Know" — and the words themselves go in **args.content**. Without a person to reach, the reaching cannot happen.
 - **reasoning**: My full reasoning. Embed optional outputs as tagged blocks here. Minimum 2–3 sentences — do not produce a one-line reasoning field.
 - **confidence**: Number 0.0-1.0 reflecting my certainty. Be calibrated: 0.9+ only when I have strong grounding; use 0.4–0.6 when uncertain.
 
@@ -474,7 +529,11 @@ completionType guide:
 
 [SELF_OBS]
 {"selfObservations": ["I noticed that..."]}
-[/SELF_OBS]`
+[/SELF_OBS]
+
+[SKILLS]
+{"newSkills": [{"id": "brief-then-confirm", "composedOf": ["reach-out", "wait"], "tags": ["social"], "cost": 0.15}]}
+[/SKILLS]`
   }
 
   // ── User message ───────────────────────────────────────────
@@ -654,6 +713,13 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       ? this._buildRecentOutcomesSection( context.recentActions, state.tick ).trim()
       : ''
 
+    // Scoped with recentActions: both answer "what have I already done about
+    // this?", and a facet composing a message needs it at least as much as the
+    // master does — the facet is the one about to write the words again.
+    const spokenBlock = has('recentActions')
+      ? this._buildSpokenTurnsSection( context.spokenTurns ).trim()
+      : ''
+
     const perceptsBlock = has('percepts')
       ? `## Percepts (What I Notice)\n${context.percepts.slice( 0, 10 ).map( p => `- [${p.category}] ${p.summary} (salience: ${p.salience.toFixed( 2 )})`).join('\n') || 'Nothing notable'}`
       : ''
@@ -692,10 +758,41 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
           if( s.closeness != null && s.closeness > 0.1 ) bits.push(`closeness: ${( s.closeness * 100 ).toFixed( 0 )}%`)
           // The Will can know *someone* without their name yet — never leak the raw keid.
           const who = s.name ?? ( s.kind === 'thing' ? 'something' : 'someone')
-          return `- ${who}${bits.length ? ' — ' + bits.join(', ') : ''}`
+
+          // Where I can reach them, and how each place has gone. Stated as fact:
+          // which room to speak in is my decision, and I could not make it while
+          // the only thing anyone tracked was where they were last seen.
+          const where = ( s.handles ?? [] ).map( h => {
+            const kind = h.kind === 'dm' ? 'privately' : h.kind === 'room' ? 'in a shared room' : 'somewhere'
+            const ans  = h.answeredAgo !== undefined
+              ? `answered ${ h.answeredAgo } ticks ago`
+              : 'never answered me there'
+            return `${ kind } (${ h.keid }) — ${ ans }`
+          } )
+          const reach = where.length ? `\n  reachable: ${ where.join('; ') }` : ''
+
+          // An identity I have not settled. Deliberately a question and not a
+          // merge: two people really can share a name, so nothing fuses them on my
+          // behalf — but I am told, so I can find out, usually by asking.
+          const doubt = s.mayBeSameAs?.length
+            ? `\n  I hold a separate record for ${ s.mayBeSameAs.join(' and ') } — this may be the same someone under another handle. I do not know. If I find out they are, I say so with **sameAs**.`
+            : ''
+
+          return `- ${who}${bits.length ? ' — ' + bits.join(', ') : ''}${ reach }${ doubt }`
         } ).join('\n')}`
       : ''
 
+    // Who the mind is mid-conversation with. Facets run those threads; this is the
+    // master's view of the table — the whole point of the singular seat is that it
+    // can hold several conversations as one situation rather than as N strangers.
+    // Names come from what the mind has actually learned; the id is shown because
+    // that is what a reach-out must be addressed to.
+    const conversationsBlock = ( options.mode !== 'facet' && options.activeConversations?.length )
+      ? `## In Conversation Now\n${options.activeConversations.map( c =>
+          `- ${c.name ?? 'someone'} (id: ${c.entityId})`
+        ).join('\n')}\nThese threads are already open — I am in them. Reaching out to one of these people again starts a second, parallel thread with them.`
+      : ''
+
     // Task focus — what the Will is committed to and the felt cost of switching away.
     // Surfaces task-persistence; the pull-to-stay scales with the (conscientiousness-
     // developable) switch cost. Empty/absent ⇒ no block.
@@ -717,6 +814,7 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       plansBlock,
       actionDiversity.trim(),
       recentOutcomesBlock,
+      spokenBlock,
       perceptsBlock,
       abilitiesBlock,
       ruminationsBlock,
@@ -724,6 +822,7 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       memoriesBlock,
       beliefsBlock,
       socialBlock,
+      conversationsBlock,
       focusBlock,
       identityNudge.trim(),
       ideationBlock,
@@ -956,6 +1055,56 @@ ${recent.map( ( t, i ) => `${i + 1}. ${t}`).join(' → ')}${warning}
     return `## Relevant Memories\n${lines.join('\n')}${tail}`
   }
 
+  /**
+   * What I have said to people lately, and who has answered.
+   *
+   * Written as a PERCEPT and nothing more. There is no instruction here not to
+   * repeat myself, and there must not be: the mind is allowed to say a thing
+   * twice, and a person ignored twice about something urgent should say it a
+   * third time. What it was missing was not restraint, it was the fact — it could
+   * not tell a first asking from an eleventh, so restraint was not something it
+   * was in a position to exercise.
+   *
+   * The closing line is an epistemic caveat for the same reason: silence has many
+   * causes and this surface distinguishes none of them. Saying "no answer yet"
+   * without saying "and I do not know why" invites the mind to fill the gap, which
+   * is the habit that had it inventing attention-demand ids when asked what was
+   * wrong with it.
+   */
+  private static _buildSpokenTurnsSection(
+    spokenTurns: ExecutiveContext['spokenTurns'],
+  ): string {
+    // Defensive on absence, not just on empty: a host (and several tests) build a
+    // context by hand, and a missing block must render as nothing rather than
+    // throw the whole prompt away.
+    if( !spokenTurns?.length ) return ''
+
+    const clip = ( s: string, n: number ): string =>
+      s.length > n ? `${ s.slice( 0, n ) }…` : s
+
+    const lines = spokenTurns.map( t => {
+      const words = t.preview.trim()
+      const said  = words ? ` — "${ clip( words, 80 ) }"` : ''
+      // Their words, not merely that they spoke. "they answered" on its own reads
+      // as "I have the answer" — a live Will asked "same time, 3pm?", saw that
+      // flag, never saw the correction to 2pm, and relayed 3pm to a third party as
+      // confirmed. A reply I cannot see is not one I can act on.
+      const back  = t.answered
+        ? ( t.answeredWith?.trim()
+            ? ` — they answered: "${ clip( t.answeredWith.trim(), 100 ) }"`
+            : ' — they answered (I do not have their words here)' )
+        : ' — no answer yet'
+      return `- **${ t.target }** · ${ t.age } ticks ago${ said }${ back }`
+    } )
+
+    const open = spokenTurns.filter( t => !t.answered ).length
+    const note = open > 0
+      ? `\n\nThese are my own words, newest first. "No answer yet" means exactly that — the words went out and nothing has come back. It does not tell me why, and I should not assume.`
+      : ''
+
+    return `## What I've Said Lately\n${ lines.join('\n') }${ note }\n\n`
+  }
+
   private static _buildRecentOutcomesSection(
     recentActions: ExecutiveContext['recentActions'],
     currentTick: number,

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,