@mindot/will 0.8.0 → 0.10.0

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

@@ -47,8 +47,19 @@
 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'
@@ -105,6 +116,100 @@ export function traitEmphasis( value: number ): TraitEmphasis | null {
 // low" yet "above my norm" (low overall, but high for me lately).
 const TRAIT_NORM_BAND = 0.12  // deviation from personal baseline to read as above/below my norm
 
+/**
+ * One percept, as the mind reads it: the engine's LABEL, and beneath it the
+ * EVIDENCE the host actually sent.
+ *
+ * The whole line is one unit on purpose. Rendering the label and the data
+ * separately let a mutation that dropped the data from the call site pass every
+ * test — the data renderer stayed correct while the prompt stopped showing it,
+ * which is exactly the state this fix exists to leave behind. Same lesson as
+ * `temporalLine`.
+ */
+export function perceptLine(
+  p: { category: string; summary: string; salience: number; data?: unknown },
+): string {
+  return `- [${ p.category }] ${ p.summary } (salience: ${ p.salience.toFixed( 2 ) })${ perceptData( p.data ) }`
+}
+
+/**
+ * One working-memory item, as the mind reads it — label, then evidence.
+ *
+ * A sibling of `perceptLine` and a unit for the same reason: rendering the data
+ * inline let a mutation that dropped it pass every test. A percept entity is
+ * swept after 2 ticks and the executive fires on its own schedule, so MEMORY is
+ * often where a mind actually meets an observation — dropping the evidence here
+ * loses it just as completely as never storing it, one step later.
+ */
+export function ruminationLine(
+  w: { type: string; summary: string; activation: number; data?: unknown },
+): string {
+  return `- [${ w.type }] ${ w.summary } (activation: ${ w.activation.toFixed( 2 ) })${ perceptData( w.data ) }`
+}
+
+/**
+ * A percept's own data, rendered under its label — what the host actually sent.
+ *
+ * The label is the engine's words about the signal; this is the evidence. A mind
+ * that only ever sees labels is being handed conclusions, and the whole job of a
+ * mind is to make meaning by connecting pieces of information it can see.
+ *
+ * Indented on its own line rather than inlined: it can be long, and a host is
+ * explicitly not asked to keep it short — what it sent is what it sent.
+ */
+function perceptData( data: unknown ): string {
+  if( data === undefined || data === null ) return ''
+  if( typeof data === 'string') return data.length > 0 ? `\n    ${ data }` : ''
+
+  try {
+    // A host's own `summary`, when it offered one, is already the label on the
+    // line above. Repeating it underneath is noise, and noise in a percept is
+    // not free — it is read every tick the percept is alive. NOT reshaping: the
+    // stored data keeps every field, this only declines to print one twice.
+    const shown = Array.isArray( data )
+      ? data
+      : Object.fromEntries( Object.entries( data as Record<string, unknown> ).filter( ( [ k ] ) => k !== 'summary') )
+    const json = JSON.stringify( shown )
+    return json === '{}' || json === '[]' ? '' : `\n    ${ json }`
+  }
+  catch { return '' }
+}
+
+/**
+ * What a phase of the cycle is CALLED, in the words a mind would use.
+ *
+ * NOT the clock. The hour this is computed from is the oscillator's own — free-
+ * running from the tick unless a host entrains it — so it is what the BODY
+ * reads, which is a different claim from what time it is. A jet-lagged body
+ * says night at noon and is not lying; it is reporting itself.
+ *
+ * The prompt used to render the raw hour beside this, and the two disagreed on
+ * every tick of every Will ever run (`Time: 12.0h (night)`). The hour is gone
+ * from the prompt entirely now: it is a fact about the world, and a fact about
+ * the world is something a mind goes and gets — see the `check-time` schema.
+ */
+export function temporalLine( timeOfDay: number, circadian: number ): string {
+  return `Body rhythm: it feels like ${ labelForHour( timeOfDay ) } to me`
+       + ` (my own cycle, not a clock — I use \`check-time\` to find out the actual hour).`
+       + ` Circadian phase: ${ circadian.toFixed( 2 ) }.`
+}
+
+/**
+ * The label, from the hour. Kept separate from `temporalLine` only so the bands
+ * are readable; nothing outside this file should need it.
+ */
+export function labelForHour( h: number ): string {
+  const hour = ( ( h % 24 ) + 24 ) % 24
+  return hour <  2 ? 'deep night'
+       : hour <  5 ? 'late night'
+       : hour <  8 ? 'early morning'
+       : hour < 11 ? 'morning'
+       : hour < 14 ? 'midday'
+       : hour < 17 ? 'afternoon'
+       : hour < 21 ? 'evening'
+       : 'night'
+}
+
 export function normEmphasis( value: number, mean: number ): 'above' | 'below' | null {
   const d = value - mean
   if( d >=  TRAIT_NORM_BAND ) return 'above'
@@ -190,6 +295,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.
@@ -208,7 +325,6 @@ export interface PromptBuildOptions {
   state:                ReadonlySimulationState
   qualityModulation:    number
   epistemicUncertainty: number
-  pendingMessages?:     PendingMessage[]
   focus:                FocusSection
   deps:                 PromptDependencies
   /** Optional: Recent action types for diversity tracking */
@@ -240,6 +356,23 @@ 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
+    /** What the mind worked out in that thread — its own reasoning, come back. */
+    concluded?: string
+    /** Commitments it made there toward someone NOT in the thread. */
+    promised?: Array<{ what: string; target?: string; gist?: string; tick: number }>
+  }[]
 }
 
 // ── PromptFactory ────────────────────────────────────────────
@@ -325,17 +458,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
@@ -348,32 +500,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.
 
@@ -475,7 +631,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 ───────────────────────────────────────────
@@ -558,16 +718,6 @@ completionType guide:
     const timeOfDay     = context.worldState.timeOfDay
     const threatLevel   = context.worldState.threatLevel
 
-    // Map raw circadian phase (0–1) to a human-readable label for full temporal awareness.
-    // 0 = midnight, 0.5 = noon, 1 = midnight.
-    const phaseLabel = circadian < 0.083 ? 'deep night'
-                     : circadian < 0.208 ? 'late night'
-                     : circadian < 0.333 ? 'early morning'
-                     : circadian < 0.458 ? 'morning'
-                     : circadian < 0.583 ? 'midday'
-                     : circadian < 0.708 ? 'afternoon'
-                     : circadian < 0.833 ? 'evening'
-                     : 'night'
 
     const energyGuidance = this._buildEnergyGuidance( energy )
     const stressGuidance = this._buildStressGuidance( stress )
@@ -618,7 +768,7 @@ completionType guide:
 Energy: ${energy.toFixed( 1 )}/100
 Sleep Pressure: ${sleepPressure.toFixed( 1 )}/100
 Stress: ${stress.toFixed( 1 )}/100${threatLine}
-Time: ${timeOfDay.toFixed( 1 )}h (${phaseLabel}, circadian: ${circadian.toFixed( 2 )})
+${temporalLine( timeOfDay, circadian )}
 Cognitive capacity:${capacityNote}
 Epistemic uncertainty: ${( epistemicUncertainty * 100 ).toFixed( 0 )}%${uncertaintyLabel}
 Tick: ${state.tick}
@@ -655,8 +805,15 @@ 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'}`
+      ? `## Percepts (What I Notice)\n${context.percepts.slice( 0, 10 ).map( perceptLine ).join('\n') || 'Nothing notable'}`
       : ''
 
     // Host abilities afforded right now + what each is for. Framed as
@@ -669,7 +826,7 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       : ''
 
     const ruminationsBlock = has('ruminations')
-      ? `## Active Ruminations (retrieved memories & thoughts)\n${context.workingMemory.map( w => `- [${w.type}] ${w.summary} (activation: ${w.activation.toFixed( 2 )})`).join('\n') || 'Nothing actively held in mind'}`
+      ? `## Active Ruminations (retrieved memories & thoughts)\n${context.workingMemory.map( ruminationLine ).join('\n') || 'Nothing actively held in mind'}`
       : ''
 
     const memoriesBlock = has('memories')
@@ -693,10 +850,64 @@ 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.
+    // WHAT I worked out there, not only WHO I am with.
+    //
+    // `executive.facet.sync` has always carried the facet's full reasoning and the
+    // master discarded it, so the return leg of the loop was empty: my thinking
+    // went down to a facet as "What I've Been Turning Over" and came back as a
+    // name. A facet is this same mind with a focus — reading back what it worked
+    // out is not a report from a subordinate, it is remembering where my attention
+    // has been. First person throughout, for that reason.
+    //
+    // A promise made in one thread to someone NOT in it is stated as the plain
+    // fact it is. There is deliberately no instruction about it: whether to keep
+    // it, drop it, or make a goal of it is mine to decide, and I have a whole
+    // faculty for that.
+    const conversationsBlock = ( options.mode !== 'facet' && options.activeConversations?.length )
+      ? `## In Conversation Now\n${options.activeConversations.map( c => {
+          const who       = `- ${c.name ?? 'someone'} (id: ${c.entityId})`
+          const concluded = c.concluded ? `\n    What I worked out there: ${c.concluded.trim()}` : ''
+          const promised  = ( c.promised ?? [] ).map( p =>
+            `\n    I said there that I would ${p.what}${ p.gist ? ` — about: "${p.gist}"` : '' }`
+            + `, at tick ${p.tick}.`
+            // Only a CONTACT can be mistaken for already done by having been
+            // said, which is the confusion this clause exists to break. A
+            // promise about work carries no such ambiguity and gets no lecture.
+            + ( p.target ? ' Saying it in that thread did not send it.' : '')
+          ).join('')
+          return `${who}${concluded}${promised}`
+        } ).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.
@@ -718,6 +929,7 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       plansBlock,
       actionDiversity.trim(),
       recentOutcomesBlock,
+      spokenBlock,
       perceptsBlock,
       abilitiesBlock,
       ruminationsBlock,
@@ -725,6 +937,7 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       memoriesBlock,
       beliefsBlock,
       socialBlock,
+      conversationsBlock,
       focusBlock,
       identityNudge.trim(),
       ideationBlock,
@@ -899,6 +1112,13 @@ Rest and sleep RESTORE energy. All other actions CONSUME energy. Do not let ener
    */
 
 
+  /**
+   * What the mind has been CHOOSING lately — action types, for the variety
+   * check. Not a history of what happened: nothing here says an act landed.
+   * Retitled from `## Recent Actions` at P3 for exactly that reason (see
+   * `_buildRecentOutcomesSection`) — it sat beside a real history under a name
+   * that claimed to be one.
+   */
   private static _buildActionDiversitySection( recentActionTypes: string[] ): string {
     if( recentActionTypes.length === 0 ) return ''
 
@@ -908,14 +1128,27 @@ Rest and sleep RESTORE energy. All other actions CONSUME energy. Do not let ener
       ? `\n⚠️ **Action variety alert**: "${recent.filter( t => t === 'reflect' || t === 'observe').join('", "')}" dominated my last ${recent.length} cycles. Choose something DIFFERENT this cycle — e.g. learn, express_emotion, explore, communicate, set_goal, or rest.`
       : ''
 
-    return `## Recent Actions (last ${recent.length})
+    return `## What I Have Been Choosing (last ${recent.length})
 ${recent.map( ( t, i ) => `${i + 1}. ${t}`).join(' → ')}${warning}
 
 `
   }
 
   /**
-   * Render the recent action outcomes section — closes the Act→Confirm→Perceive loop.
+   * Render what became of what the mind did — closes the Act→Confirm→Sense loop.
+   *
+   * NAMED FOR WHAT IT RENDERS (SIGNAL_BOUNDARY P3). It was `## Recent Action
+   * Outcomes`, which named the `action.outcome` BUS EVENT — a different shape
+   * this section never touches. It renders `action.record` entities: what became
+   * of acts the mind actually took. Meanwhile the section two above it,
+   * `## Recent Actions`, listed action TYPES THE MIND CHOSE — a list of
+   * intentions wearing the name of a history, directly beside a history.
+   *
+   * A mind that cannot tell those two apart cannot tell an intention from an
+   * act, and one live COO could not: asked "have you completed that?", she said
+   * "Yes — it's done", having posted nothing and having no effectors at all. The
+   * section titles are the mind's own labels for its own memory; they are not
+   * decoration.
    * Shows the executive what it tried, whether it landed, and if anything timed out.
    * Only rendered when there are status-bearing action records in state.
    */
@@ -957,6 +1190,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,
@@ -966,6 +1249,9 @@ ${recent.map( ( t, i ) => `${i + 1}. ${t}`).join(' → ')}${warning}
     const STATUS_BADGE: Record<string, string> = {
       completed:    '✓',
       failed:       '✗',
+      // Not a failure. I formed it and chose not to complete it — reading that
+      // back as ✗ is how a mind learns it is bad at something it decided against.
+      withheld:     '⊘ chose not to',
       awaiting_host: '⏳',
       timed_out:    '⏱ TIMED OUT',
     }
@@ -978,12 +1264,19 @@ ${recent.map( ( t, i ) => `${i + 1}. ${t}`).join(' → ')}${warning}
       return `- ${badge} **${a.type}** (tick ${a.tick}, ${age} ticks ago${planCtx})${outcome}`
     } )
 
-    const hasTimeout = recentActions.some( a => a.status === 'timed_out')
-    const timeoutNote = hasTimeout
-      ? '\n⚠️ **One or more actions timed out** — my body dispatched them but received no confirmation. Check if the external handler is working, or choose a different approach.'
+    // A note that can actually fire. The one here before keyed on a `timed_out`
+    // status nothing produces — and it sat inside a section that had never
+    // rendered at all, so neither could ever have been seen.
+    const failed = recentActions.filter( a => a.status === 'failed').length
+    const didNotLand = failed > 0
+      ? `\n⚠️ **${ failed } of these did not land** — my body attempted them and they did not complete.`
       : ''
+    // Invariant, and identical on every branch: this is the sentence that makes
+    // the section load-bearing rather than decorative, and a mind must not get a
+    // differently-worded version of it depending on how its week went.
+    const note = `${ didNotLand }\nThis is what I HAVE done, not what I meant to do. If something I intended is not on this list, it did not happen.`
 
-    return `## Recent Action Outcomes\n${lines.join('\n')}${timeoutNote}\n\n`
+    return `## What Became Of What I Did\n${lines.join('\n')}${note}\n\n`
   }
 
   /**