@mindot/will 0.8.0 → 0.9.0

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

@@ -53,6 +53,18 @@ export interface FacetReport {
   contextId?: string
   /** Optional dynamic instructions to append to the user message */
   instructions?: string
+  /**
+   * Attend to something else for THIS report only, leaving the facet's standing
+   * focus untouched.
+   *
+   * A facet's focus was a single mutable field, so anything that wanted a live
+   * facet to consider one different thing had to `setFocus()` first — clobbering
+   * whatever the facet was already set up for, and racing with any report already
+   * queued behind it. That is why a self-initiated message to someone the mind was
+   * ALREADY talking to had to be composed by a separate, transient facet that could
+   * not see the live conversation at all.
+   */
+  focus?: FocusSection
 }
 
 export interface FacetDecision {
@@ -63,6 +75,16 @@ export interface FacetDecision {
   decision: unknown
   reasoning: string
   confidence: number
+  /**
+   * Sim tick this decision was reasoned at.
+   *
+   * The facet has always known it and never passed it on, so a subscriber writing
+   * state in response had no deterministic clock and reached for a process-local
+   * counter instead — which resets on restart and collides. Never wall-clock: this
+   * reaches ids that live in state, and a wall-clock id makes recorded and replayed
+   * runs diverge (R2).
+   */
+  tick: number
 }
 
 export type FacetEventListener = ( decision: FacetDecision ) => void
@@ -134,6 +156,19 @@ export class ExecutiveFacet {
   private _facetReasoningHistory: string[] = []
   private _masterSyncHistory: string[] = []
 
+  /**
+   * This facet's own prior reasoning, for the supervisor to carry to whichever
+   * facet takes over the same keyed thread. Continuity belongs to the thread, not
+   * to the instance holding it: a facet reaped mid-conversation used to take the
+   * mind's private thinking about that person with it.
+   */
+  get reasoningHistory(): string[] { return [ ...this._facetReasoningHistory ] }
+
+  /** Resume a thread's reasoning on spawn (supervisor-only; see FacetSpawnDeps.key). */
+  restoreReasoningHistory( history: string[] ): void {
+    this._facetReasoningHistory = [ ...history ]
+  }
+
   /** Confidence of this facet's *previous* decision — a dual-process gate signal. */
   private _lastConfidence = 0.5
 
@@ -260,9 +295,7 @@ export class ExecutiveFacet {
   private _launchReason( report: FacetReport ): void {
     this._inflight++
     this._reason( report )
-      .catch( err =>
-        logger.error(`[executive.facet] ${this.facetId} reasoning error:`, err )
-      )
+      .catch( err => logger.error(`[executive.facet] ${this.facetId} reasoning error:`, err ) )
       .finally( () => {
         this._inflight--
         this.markActive( ( this._currentStateRef?.tick as number ) ?? this._lastActiveTick )
@@ -322,9 +355,14 @@ export class ExecutiveFacet {
 
     logger.info(`[executive.facet] ${this.facetId} synced from master (tick=${payload.tick})`)
 
-    // Store master's latest reasoning for context in next report()
+    // Store the wider reasoning for context in the next report().
+    //
+    // Rendered in the FIRST PERSON and with no mention of a "master": this is the
+    // same mind's thinking arriving from where the rest of its attention has been,
+    // not a report from a superior. Naming it "Master sync" gave the facet a second
+    // party to address — and it addressed it, out loud, on the outbound channel.
     if( payload.reasoning )
-      this._masterSyncHistory.push(`[Master sync — tick ${payload.tick}] ${payload.reasoning.slice( 0, 400 )}`)
+      this._masterSyncHistory.push(`[tick ${payload.tick}] ${payload.reasoning.slice( 0, 400 )}`)
 
     // Keep only last 5 sync entries
     if( this._masterSyncHistory.length > 5 )
@@ -338,7 +376,11 @@ export class ExecutiveFacet {
     if( !this._currentStateRef )
       throw new Error(`[executive.facet] ${this.facetId} no state reference available`)
 
-    if( !this._currentFocus )
+    // This report's focus: its own if it carried one, else the facet's standing
+    // one. A per-report focus never mutates `_currentFocus`, so a live thread can
+    // be asked to attend to one different thing and come straight back.
+    const reportFocus = report.focus ?? this._currentFocus
+    if( !reportFocus )
       throw new Error(`[executive.facet] ${this.facetId} no focus set. Call setFocus() before report().`)
 
     const currentState = this._currentStateRef
@@ -346,7 +388,7 @@ export class ExecutiveFacet {
     // Build fresh context from current state
     // A focus may supply a recall query (e.g. the live conversation message) to
     // drive the single "## Relevant Memories" section — one recall surface (§5).
-    const execContext = await PromptFactory.buildFreshContext( this._contextDeps, currentState, this._currentFocus?.recallQuery )
+    const execContext = await PromptFactory.buildFreshContext( this._contextDeps, currentState, reportFocus.recallQuery )
 
     const qualityModulation = PromptFactory.computeQualityModulation( currentState )
     const epistemicUncertainty = PromptFactory.computeEpistemicUncertainty( execContext, currentState )
@@ -355,10 +397,10 @@ export class ExecutiveFacet {
     // the appropriate content via setFocus()
     const focus: FocusSection = this._masterSyncHistory.length > 0
             ? {
-                ...this._currentFocus,
-                content: `${this._currentFocus.content}\n\n## Master Consciousness Updates\n${this._masterSyncHistory.join('\n')}`
+                ...reportFocus,
+                content: `${reportFocus.content}\n\n## What I've Been Turning Over\n${this._masterSyncHistory.join('\n')}`
               }
-            : this._currentFocus
+            : reportFocus
 
     // Build system prompt using PromptFactory — same schema as master, [REPLY] gated out.
     const systemPrompt = PromptFactory.buildSystemPrompt( {
@@ -377,7 +419,7 @@ export class ExecutiveFacet {
     // isn't cold on each cycle. Injected before the caller's instructions so the
     // caller content always comes last (highest recency bias from the LLM).
     const continuityBlock = this._facetReasoningHistory.length > 0
-      ? `## My Prior Reasoning (this facet)\n${this._facetReasoningHistory.join('\n')}`
+      ? `## Where My Thinking Had Got To\n${this._facetReasoningHistory.join('\n')}`
       : ''
 
     const reportContent = [
@@ -399,7 +441,7 @@ export class ExecutiveFacet {
       stressLoad:        currentState.metrics.get('stress.load') ?? 0,
       // A facet's "stakes-bearing moment" is a live message awaiting reply (conversation
       // facets set focus.recallQuery to it); planning/other facets rely on uncertainty.
-      hasPendingMessage: !!this._currentFocus?.recallQuery,
+      hasPendingMessage: !!reportFocus.recallQuery,
     }, deliberateThreshold )
 
     let ideationCandidates: IdeationCandidate[] | undefined
@@ -410,7 +452,6 @@ export class ExecutiveFacet {
         state: currentState,
         qualityModulation,
         epistemicUncertainty,
-        pendingMessages: [],
         focus,
         deps: this._promptDeps,
         recentActionTypes: [],
@@ -424,7 +465,14 @@ export class ExecutiveFacet {
         ideationUserMessage,
         tick: currentState.tick,
         proposeTemperature,
-        meta: { category: 'executive', attribute: 'facet', function: this._currentFocus?.function ?? 'ideation', scope: this.facetId, demand: processSelection.effortScore },
+        meta: {
+          category: 'executive',
+          attribute: 'facet',
+          process: 'ideation',
+          function: reportFocus.function ?? '-',
+          scope: this.facetId,
+          demand: processSelection.effortScore
+        },
       } )
       logger.info(
         `[executive.facet] ${this.facetId} ◆ deliberate propose tick=${currentState.tick}  ` +
@@ -437,7 +485,6 @@ export class ExecutiveFacet {
       state: currentState,
       qualityModulation,
       epistemicUncertainty,
-      pendingMessages: [],
       focus,
       deps: this._promptDeps,
       recentActionTypes: [],
@@ -471,11 +518,12 @@ export class ExecutiveFacet {
       const facetMeta: LLMCallMeta = {
         category:  'executive',
         attribute: 'facet',
+        process: 'decision',
         // A focus that declares no function is making its decision call, the
         // facet's analogue of master's 'decision'. This previously fell back to
         // 'facet' — an *attribute* value, which quietly created a bogus bucket
         // in the by-function cost breakdown. The typed axes caught it.
-        function:  this._currentFocus?.function ?? 'decision',
+        function:  reportFocus.function ?? '-',
         scope:     this.facetId,
         demand:    processSelection.effortScore,
       }
@@ -555,7 +603,8 @@ export class ExecutiveFacet {
       respondingToType: report.type,
       decision: this._extractDecisionPayload( output, focus ),
       reasoning: output.reasoning,
-      confidence: output.confidence
+      confidence: output.confidence,
+      tick: currentState.tick as unknown as number
     }
 
     // Promote subscriber-visible fields from the decision object to the event payload
@@ -566,7 +615,7 @@ export class ExecutiveFacet {
       ? decision.decision as Record<string, unknown>
       : {}
 
-    this._bus.publish( {
+    this._bus.publish({
       type: 'executive.facet.progress',
       version: 1,
       sourceEngine: `executive-facet-${this.facetId}`,
@@ -587,7 +636,7 @@ export class ExecutiveFacet {
         contextId:        report.contextId,
         tick:             currentState.tick
       }
-    } )
+    })
 
     // Conscious learning about others — route name/feeling to known.entity.tracker (the
     // dossier owner) the same way the master does, so routine (un-escalated) conversation
@@ -595,15 +644,17 @@ export class ExecutiveFacet {
     const keUpdates = dec[ 'knownEntityUpdates' ] as ExecutiveOutputFull['knownEntityUpdates'] | undefined
     if( keUpdates )
       for( const u of keUpdates )
-        if( u.keid && u.keid !== 'agent-self' && ( u.name || u.feeling != null ) )
-          this._bus.publish( {
-            type: 'known.entity.learned', version: 1,
+        if( u.keid && u.keid !== 'agent-self' && ( u.name || u.feeling != null || u.sameAs ) )
+          this._bus.publish({
+            type: 'known.entity.learned',
+            version: 1,
             sourceEngine: `executive-facet-${this.facetId}`,
-            salience: 0.5, payload: { keid: u.keid, name: u.name, feeling: u.feeling }
-          } )
+            salience: u.sameAs ? 0.7 : 0.5,
+            payload: { keid: u.keid, name: u.name, feeling: u.feeling, sameAs: u.sameAs }
+          })
 
     // Sync back to master
-    this._bus.publish( {
+    this._bus.publish({
       type: 'executive.facet.sync',
       version: 1,
       sourceEngine: `executive-facet-${this.facetId}`,
@@ -613,9 +664,13 @@ export class ExecutiveFacet {
         reasoning: output.reasoning,
         confidence: output.confidence,
         actionTypes: output.actions.map( a => a.type ),
+        // WHO this facet is engaged with (FocusSection.subject*). The master keeps
+        // the singular seat, so it needs the person, not just the facet number.
+        ...( focus.subjectEntityId ? { subjectEntityId: focus.subjectEntityId } : {} ),
+        ...( focus.subjectName     ? { subjectName:     focus.subjectName     } : {} ),
         tick: currentState.tick
       }
-    } )
+    })
 
     // Notify all listeners (PlanningEngine, AuditionEngine, etc.).
     //

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

@@ -2,7 +2,6 @@
 // src/cognition/faculties/executive.engine/gating.ts
 // ─────────────────────────────────────────────────────────────
 
-import type { PendingMessage } from '#faculties/executive.engine/types'
 import type { Tick, ReadonlySimulationState } from '#core/types'
 import type { GenerativeModel } from '#cognition/generative.model'
 import {
@@ -11,23 +10,28 @@ import {
 } from '#faculties/executive.engine/config'
 import type { CognitiveEvent } from '#cognition/bus'
 
-function hasPendingInstructions( state: ReadonlySimulationState, pendingMessages: PendingMessage[] ): boolean {
-  for( const entity of state.entities.values() ){
+/**
+ * Something in the world is loud enough to wake a resting mind.
+ *
+ * Percept salience is the whole test now. Two other wake sources used to sit here
+ * and neither could ever fire: an unprocessed `communication` entity (a type
+ * nothing has ever written) and a non-empty pending-message queue (never pushed
+ * to, and the current design forbids it — inbound reaches a facet, and the master
+ * learns of it through `executive.facet.handoff` → a high-salience percept, which
+ * this catches). Both removed with the queue itself (#114).
+ */
+function hasPendingInstructions( state: ReadonlySimulationState ): boolean {
+  for( const entity of state.entities.values() )
     if( entity.type === 'percept' || entity.type === 'percept.social'){
       const salience = (entity.metadata?.salience as number) ?? 0
       if( salience > 0.7 ) return true
     }
 
-    if( entity.type === 'communication' && !entity.metadata?.processedByExecutive )
-      return true
-  }
-
-  return pendingMessages.length > 0
+  return false
 }
 
 export interface GatingDependencies {
   generativeModel: GenerativeModel
-  pendingMessages: PendingMessage[]
   hasPendingWork: boolean
 }
 
@@ -110,7 +114,7 @@ export function evaluateGating(
   if( isResting > 0 || isSleeping > 0 ){
     const
     significantEvent = novelty > 0.8,
-    hasPending = hasPendingInstructions( state, deps.pendingMessages )
+    hasPending = hasPendingInstructions( state )
 
     if( significantEvent || hasPending )
       return {
@@ -142,10 +146,6 @@ export function evaluateGating(
   if( energy < 15 )
     return { shouldActivate: true, reason: 'energy_critical', cleanedBuffer }
 
-  // ── Pending messages — always fire ────────────────────────
-  if( deps.pendingMessages.length > 0 )
-    return { shouldActivate: true, reason: 'pending_message', cleanedBuffer }
-
   // ── Normal interval scheduling ────────────────────────────
   if( tick - gs.lastExecutiveTick >= gs.executiveInterval ){
     // Prediction-error gating — uses GenerativeModel.observe() which returns { gated }

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

@@ -3,7 +3,7 @@
 // ─────────────────────────────────────────────────────────────
 
 import { logger } from '#core/logger'
-import { REPLY_TEXT_TAG } from '#llm/wire.contracts'
+import { REPLY_TEXT_TAG, NO_MESSAGE_TAG, NO_MESSAGE_OPEN } from '#llm/wire.contracts'
 import type { ReadonlySimulationState } from '#core/types'
 import type { ExecutiveOutputFull, ExecutiveOutputMinimal, IdeationCandidate, IdeationOutput } from '#faculties/executive.engine/types'
 
@@ -68,6 +68,18 @@ export function parseResponse(
   const replyText = extractTextBlock( responseText, REPLY_TEXT_TAG )
   if( replyText ) full.replyText = replyText
 
+  // A declared decision not to speak. Its own field rather than an empty
+  // replyText, because "I chose silence" and "the facet produced nothing" are
+  // different events: one is a decision worth recording, the other a failure worth
+  // noticing, and collapsing them hides both.
+  // Presence of the MARKER is the decision — not the content, which may legitimately
+  // be empty. `extractTextBlock` returns null for an absent tag AND for a present
+  // but empty one, so it cannot tell them apart; testing it for undefined (as this
+  // first did) is true in every case and made the mind mute on every path. The
+  // integration suite caught it; a live boot would have caught it as total silence.
+  if( responseText.includes( NO_MESSAGE_OPEN ) )
+    full.noMessage = extractTextBlock( responseText, NO_MESSAGE_TAG ) ?? '(no reason given)'
+
   return full
 }
 
@@ -193,6 +205,7 @@ function parseTaggedBlocks(
     'GOALS_REPRIORITIZE',
     'EFFECTORS',
     'SELF_OBS',
+    'SKILLS',
   ],
   found = taggedTypes.filter( t => text.includes(`[${t}]`) )
   if( found.length > 0 ){
@@ -299,6 +312,13 @@ function parseTaggedBlocks(
   }
   catch { /* ignore */ }
 
+  // Named compound skills — the creation seam for learned composites (#114).
+  try {
+    const skillsData = parseJsonBlock('SKILLS') as { newSkills?: ExecutiveOutputFull['newSkills'] } | null
+    if( skillsData?.newSkills ) full.newSkills = skillsData.newSkills
+  }
+  catch { /* ignore */ }
+
   // [ACK] and legacy [REPLY] blocks are no longer emitted by any engine.
   // [ACK]   — removed with the legacy master communication path (Phase 13.8).
   // [REPLY] — replaced by [REPLY_TEXT] plain-text block in conversation facets.

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'
@@ -190,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.
@@ -208,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 */
@@ -240,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 ────────────────────────────────────────────
@@ -325,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
@@ -348,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.
 
@@ -475,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 ───────────────────────────────────────────
@@ -655,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'}`
       : ''
@@ -693,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.
@@ -718,6 +814,7 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       plansBlock,
       actionDiversity.trim(),
       recentOutcomesBlock,
+      spokenBlock,
       perceptsBlock,
       abilitiesBlock,
       ruminationsBlock,
@@ -725,6 +822,7 @@ Dominance: ${context.affect.dominance.toFixed( 2 )}${context.affect.blends.lengt
       memoriesBlock,
       beliefsBlock,
       socialBlock,
+      conversationsBlock,
       focusBlock,
       identityNudge.trim(),
       ideationBlock,
@@ -957,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,