@mindot/will 0.8.0 → 0.10.0

package/src/cognition/senses/audition.engine/engine.ts

@@ -11,16 +11,16 @@
  * ExecutiveFacet — one facet per entityId, kept alive for the session duration.
  *
  * Architecture:
- *   - External call: WillManager.ingestText() → audition.ingest(TextMessage)
+ *   - External call: WillManager.senseText() → audition.sense(TextMessage)
  *   - Percept published on bus:  senses.audition.percept
- *   - Facet reply signals:       audition.task.signal  (when master attention needed)
+ *   - Facet handoffs to the seat: executive.facet.handoff  (escalation | undertaking)
  *   - GoalManager integration:   automatic via executive.facet.progress (bus)
  *   - Chunk streaming:           via multi-subscriber chunk callbacks (transport + SSE)
  *
  * The master executive is NOT involved in replies — it learns about conversations
  * only via executive.facet.sync events published by the conversation facets.
- * Master takes initiative if it receives an audition.task.signal marked
- * requiresMasterAttention: true.
+ * It takes initiative when a facet raises an `executive.facet.handoff` — the one
+ * channel every facet type uses to hand the singular seat something it owns.
  *
  * FocusSection.outputFormat provides a custom format that re-enables [REPLY]
  * (normally gated out in facet mode) while removing PLANS (conversation
@@ -60,6 +60,7 @@ import type { ExecutiveEngine } from '#faculties/executive.engine'
 import type { ExecutiveFacetHandle, FacetDecision } from '#faculties/executive.engine/facet'
 import { DEFAULT_FACET_AWARENESS, type FocusSection } from '#faculties/executive.engine/prompt.factory'
 import type { ExecutiveOutputFull } from '#faculties/executive.engine/types'
+import { COMMUNICATE_ACTION_TYPES } from '#faculties/executive.engine/commands'
 import type { EpisodicConsolidator } from '#faculties/episodic.consolidator'
 import type { OutboxWriter } from '#stem/tracts/outbox.writer'
 import { GenerativeModel } from '#cognition/generative.model'
@@ -72,8 +73,13 @@ import type {
   SensoryInput,
   LanguagePercept,
   TextMessage,
+  Transduced,
   VoiceChunk
 } from '#senses/index'
+import { PERCEPT_SUMMARY_CAP } from '#cognition/percept.entity'
+import { validateFacetHandoff, type HandoffBody } from '#faculties/executive.engine/escalation.buffer'
+import { fnv1a } from '#agency/consequence'
+import type { OutreachResult } from '#agency/engines/motor.schema.executor'
 
 // ── Internal types ─────────────────────────────────────────────
 
@@ -82,7 +88,32 @@ interface ConversationDecision {
   reply:                  string
   /** Individual reply bubbles for display (separate SSE chunks). */
   replyBubbles:           string[]
+  /**
+   * The mind DECLARED silence — it considered speaking and chose not to.
+   *
+   * Distinct from empty bubbles, which also happens when authoring timed out, the
+   * facet budget was full, or a second pass deferred to one already in flight.
+   * Only this one is an answer; the others are the absence of one, and the
+   * executor must keep holding those.
+   */
+  withheld?:              boolean
   targetEntityId:         string
+  /**
+   * Actions this facet aimed at someone OTHER than the person it is talking to.
+   *
+   * A conversation facet is the mind talking to ONE person. When it decides mid-
+   * conversation to contact a third party ("I'll reach out to FKEM now"), it must
+   * not open that channel itself — a facet bound to Fabrice messaging FKEM is the
+   * parallel-conversation failure, and it would collide with any facet already
+   * talking to FKEM. So the intention is surfaced to the master, which is singular
+   * and owns whom the mind contacts.
+   *
+   * Before this existed, `extractDecision` read `output.actions` only to test for
+   * 'escalate' and dropped the rest: a third-party action was delivered nowhere,
+   * became no intent, competed in nothing and left no reafference — the mind said
+   * it would make contact, believed it had, and nothing ever went out.
+   */
+  outwardIntents?:        { target: string; gist?: string; reasoning?: string }[]
   newGoals?:              ExecutiveOutputFull['newGoals']
   goalsToAbandon?:        ExecutiveOutputFull['goalsToAbandon']
   newBeliefs?:            ExecutiveOutputFull['newBeliefs']
@@ -114,12 +145,52 @@ interface CoalesceWindow {
 }
 
 
+/**
+ * Split a facet's actions into the ones aimed at the person it is talking to
+ * (delivered as the reply, which the [REPLY_TEXT] block already carries) and the
+ * ones aimed at someone else (returned here, for the master to own).
+ *
+ * "Aimed at this person" is matched against both the bound keid and the name the
+ * facet was given for them, because a mind writes whichever it is looking at —
+ * the trace shows it using `discord:1019…` and `Fabrice` interchangeably within a
+ * single decision. Anything else — including a name the mind has heard but never
+ * bound to anyone — is outward, and gets carried rather than dropped: whether it
+ * can be reached at all is the master's problem to notice, not this partition's.
+ */
+export function partitionOutwardIntents(
+  actions:     ExecutiveOutputFull['actions'] | undefined,
+  boundKeid:   string,
+  boundName:   string,
+): { target: string; gist?: string; reasoning?: string }[] {
+  const mine = new Set( [ boundKeid, boundName ].map( s => s.trim().toLowerCase() ).filter( Boolean ) )
+  const out: { target: string; gist?: string; reasoning?: string }[] = []
+
+  for( const action of actions ?? [] ){
+    if( !COMMUNICATE_ACTION_TYPES.has( action.type.toLowerCase() ) ) continue
+
+    const args   = ( action.args && typeof action.args === 'object' ? action.args : {} ) as Record<string, unknown>
+    const target = [ action.target, args['to'], args['recipient'], args['target'] ]
+      .find( v => typeof v === 'string' && v.trim().length > 0 ) as string | undefined
+
+    // No addressee named at all ⇒ it meant the person in front of it; the
+    // [REPLY_TEXT] block is already that reply.
+    if( !target || mine.has( target.trim().toLowerCase() ) ) continue
+
+    const gist = [ args['content'], args['message'], args['text'], args['body'] ]
+      .find( v => typeof v === 'string' && v.trim().length > 0 ) as string | undefined
+
+    out.push({ target: target.trim(), ...( gist ? { gist } : {} ), ...( action.reasoning ? { reasoning: action.reasoning } : {} ) })
+  }
+
+  return out
+}
+
 // ── Conversation output format ─────────────────────────────────
 // Two-step format: JSON first (private reasoning), then [REPLY_TEXT] (streamed to client).
 // [REPLY_TEXT] is plain prose — no JSON wrapper, no targetEntityId needed.
 // The facet is entity-scoped so the recipient is always the speakerEntityId.
 
-const CONVERSATION_OUTPUT_FORMAT = `\
+export const CONVERSATION_OUTPUT_FORMAT = `\
 ## Response Format (REQUIRED)
 
 Step 1 — JSON object (my private reasoning, optionally in a \`\`\`json code block):
@@ -145,25 +216,56 @@ Start a new paragraph (blank line) to send a separate chat bubble.
 Write [REPLY_TEXT] AFTER the closing \`\`\`. This is the only part the speaker sees — keep it grounded, present.
 Separate multiple messages with a blank line for natural conversational pauses (like separate texts).
 
+## Saying nothing
+Silence is a real choice and it is available to me: if I have nothing to say right now — I am
+waiting on them, or speaking again would only repeat myself — I write a [NO_MESSAGE] block
+instead of a [REPLY_TEXT] one, and I put my reason inside it:
+
+[NO_MESSAGE]
+Nothing new to add — I am waiting on their answer to what I already asked.
+[/NO_MESSAGE]
+
+That is recorded and NEVER sent. Anything between the [REPLY_TEXT] markers IS SENT, so a line
+like "[no message this cycle — waiting for their reply]" does not describe my silence to
+myself, it delivers that sentence to them. If I write both blocks, the silence wins.
+
+## Reaching someone who is not in this conversation
+[REPLY_TEXT] is delivered TO THE PERSON I AM TALKING TO, and to nobody else. It has an
+audience, not just a reader. So words meant for a third party do not become a message to
+that third party by being about them — they are handed to the speaker, who reads something
+addressed to someone else, while the person it was actually for never hears it.
+
+To reach someone else I name them in an action:
+
+{"type": "reach-out", "target": "<their name or id as it appears under '## People I Know'>",
+ "args": {"content": "what I want to say to them"}}
+
+I am one conversation of a mind that is having several. Opening a channel is not mine to
+do — that action hands the intention to the part of me that owns whom I contact. It is a
+decision, not a delivery: at the moment I write it nothing has reached anyone, and it may
+yet come to nothing. So I never tell the person in front of me that I have contacted
+someone, or that a message is on its way. The most I can truthfully say is that I mean to.
+I keep [REPLY_TEXT] for the person in front of me.
+
 ## When to use GOALS_NEW (almost always)
 If the speaker requests, mentions, or implies something I should follow through on — embed [GOALS_NEW] in my reasoning.
-This tracks intent across future cycles without requiring master attention.
+This tracks intent across future cycles on its own.
 
 ## When to use the escalate action (rare — only for multi-step tasks)
-Use \`{"type": "escalate", "reasoning": "...", "expectedOutcome": "..."}\` in actions ONLY when the request genuinely requires my master consciousness to create a plan:
+Use \`{"type": "escalate", "reasoning": "...", "expectedOutcome": "..."}\` in actions ONLY when the request genuinely needs a plan I carry out over time rather than an answer I can give now:
 - The task involves multiple steps across future cycles ("build me X", "monitor Y", "set up Z")
 - The request changes my active goal priorities in a significant way
 - I need to coordinate something beyond a single reply
 
-**The "reasoning" field on the escalate action becomes the task description the master sees.**
+**The "reasoning" field on the escalate action becomes the description of the work I pick up.**
 Make it concrete — describe WHAT needs to happen, not just that I am escalating.
 Good: type=escalate, reasoning="User wants weekly mood summaries by email every Monday. Needs: data aggregation, schedule, email delivery.", expectedOutcome="Weekly email delivered."
 Bad:  type=escalate, reasoning="Escalating because this is complex."
 
 When I escalate:
 1. STILL include a [REPLY_TEXT] that acknowledges the request (e.g. "Got it — I'm on it.")
-2. The master will create and execute the plan in the background
-3. Do NOT include a [PLANS] block — plan creation is the master's domain only
+2. I form and carry out the plan away from this conversation, over the cycles that follow
+3. Do NOT include a [PLANS] block — the planning happens there, not here
 
 For simple, single-exchange requests (questions, opinions, short tasks) — do NOT escalate. Just reply.`
 
@@ -270,6 +372,33 @@ export class AuditionEngine extends BaseSenseEngine {
    * other percept uses. Wired to `stateManager.setEntity` in assembleMind().
    */
   private _memorySink: (( entity: MemoryEntity ) => void) | null = null
+  /**
+   * Sim tick of the most recent facet decision — the only deterministic clock this
+   * off-tick engine has. Stamped from `FacetDecision.tick`, and used to key the
+   * conversation records it writes into state.
+   */
+  /**
+   * Audition does NOT lay down a percept trace (SIGNAL_BOUNDARY P0, step 3).
+   *
+   * Every other sense does, and a host implementing a new one gets it by
+   * default. This is the grandfathered exception, and the reason is measurement
+   * rather than principle: audition is the only live sense, and switching it on
+   * routes every inbound message to five consumers it has never reached —
+   * `action.selector`'s rupture gate (where a fresh high-salience exafferent
+   * percept can preempt an awaiting intent), working memory, the executive
+   * prompt, novelty, and reafference credit. On a deployed Will that is not a
+   * tweak; it is a different mind, and it deserves a measured rollout rather
+   * than a line in a refactor.
+   *
+   * Audition is not trace-less meanwhile: it writes `conversation.received`
+   * through its own sink, which is what SocialPerception reads. That record is
+   * social — sourceKeid, directedAtSelf, action:'communication' — and is NOT
+   * the generic percept the other senses now write. Two different traces for
+   * two different readers; this flag turns off only the second.
+   */
+  protected readonly tracesPercepts = false
+
+  private _lastDecisionTick = 0
   /** Speaker attachment strength accessor (0–1) — weights salience by relationship. */
   private _getAttachmentScore: (( entityId: string ) => number) | null = null
   /** Active-goal topic text accessor — for salience topic-overlap. */
@@ -278,6 +407,8 @@ export class AuditionEngine extends BaseSenseEngine {
   private _inflightInbound = new Map<string, string>()
   /** In-flight thread per entity — stamps chunk envelopes with the current threadId. */
   private _inflightThread = new Map<string, string>()
+  /** Targets with an outreach being composed right now — see authorOutreach. */
+  private _outreachInFlight = new Set<string>()
 
   // ── Assembly wiring ─────────────────────────────────────────
 
@@ -331,11 +462,11 @@ export class AuditionEngine extends BaseSenseEngine {
 
   // ── CognitiveEngine ─────────────────────────────────────────
 
-  /** Override: audition adds the master-escalation signal to the base percept schema. */
+  /** Override: audition adds the facet→master handoff to the base percept schema. */
   publishes(): CognitiveEventSchema[] {
     return [
-      { type: 'senses.audition.percept', version: 1, validate: () => null },
-      { type: 'audition.task.signal',    version: 1, validate: () => null }
+      { type: 'senses.audition.percept',   version: 1, validate: () => null },
+      { type: 'executive.facet.handoff',   version: 1, validate: validateFacetHandoff },
     ]
   }
   // subscribes() and onCognitiveEvent() inherit the base no-ops (ingest-driven).
@@ -477,7 +608,7 @@ export class AuditionEngine extends BaseSenseEngine {
     const salience = this._model.observe(`audition.${entityId}`, langEnergy ).salience
 
     // ── Percept ────────────────────────────────────────────────
-    const percept: LanguagePercept = {
+    const transduced: Transduced<LanguagePercept> = {
       domain: 'audition',
       channel: msg.kind,
       content,
@@ -485,6 +616,10 @@ export class AuditionEngine extends BaseSenseEngine {
       speakerEntityId: entityId,
       threadId,
       digest: this._digests.getDigest( threadId ),
+      // What a heard turn amounts to, for readers that do not know this is
+      // audition. Bounded, because `summary` renders into the executive prompt
+      // and a pasted essay would take the whole percept budget.
+      summary: `${ speakerName } said: ${ content }`.slice( 0, PERCEPT_SUMMARY_CAP ),
       salience,
       // Arrival metadata for an EXTERNAL inbound message (network/RPC boundary):
       // no sim clock in scope here and the value is not replayed — wallClock() is
@@ -495,7 +630,7 @@ export class AuditionEngine extends BaseSenseEngine {
 
     // Publish to CognitiveBus — AttentionAllocator et al. can react.
     // publishPercept() (base) is the single emit chokepoint on senses.<domain>.percept.
-    this.publishPercept( percept )
+    const percept = this.publishPercept<LanguagePercept>( transduced, msg )
 
     // ── Update digest with inbound turn ───────────────────────
     this._digests.append( threadId, 'user', content )
@@ -506,6 +641,16 @@ export class AuditionEngine extends BaseSenseEngine {
     this._inflightInbound.set( entityId, content )
     this._inflightThread.set( entityId, threadId )
 
+    // Someone spoke to us — record it in state so SOCIAL COGNITION can see it.
+    // Until this, an inbound message existed only on the bus and inside a facet:
+    // it created no entity, so SocialPerception (whose whole job is to notice
+    // people acting toward us) had nothing to scan, never published
+    // `interaction.occurred`, and every consumer of that event — reputation,
+    // affect, theory-of-mind, attachment, frustration — learned nothing from any
+    // conversation the Will ever had. A Will could hold 27 exchanges with someone
+    // and still carry familiarity 0, valence 0 for them.
+    this._writeReceived( entityId, speakerName, content, threadId )
+
     // ── Route to facet, then block the entity queue until the turn resolves ──
     // The turn deferred must be armed BEFORE routing because a synchronous facet
     // (e.g. a test mock) can fire its decision during report().
@@ -550,6 +695,16 @@ export class AuditionEngine extends BaseSenseEngine {
     this._turnDone.get( entityId )?.()
   }
 
+  /**
+   * True while a turn with this person is still resolving — they spoke and the
+   * reply has not landed yet. The agency asks before delivering a self-initiated
+   * message (see OutreachAuthor.isSpeakingTo), so one mind does not reach one
+   * person down two paths in the same tick.
+   */
+  isSpeakingTo( entityId: string ): boolean {
+    return this._turnDone.has( entityId )
+  }
+
   // ── Facet lifecycle ─────────────────────────────────────────
 
   private async _routeToFacet( percept: LanguagePercept, speakerName: string ): Promise<boolean> {
@@ -561,7 +716,10 @@ export class AuditionEngine extends BaseSenseEngine {
     let handle = this._facets.get( percept.speakerEntityId )
     if( !handle ){
       // New conversation session — try to spawn a facet.
-      const result = this._executiveEngine.spawnFacet('conversation')
+      // Keyed by speaker: one thread of attention per person. The supervisor now
+      // owns that guarantee (and carries the thread's reasoning across a reap),
+      // so a re-spawn after an idle gap resumes rather than starting cold.
+      const result = this._executiveEngine.spawnFacet('conversation', `conversation:${percept.speakerEntityId}`)
       if( result.attention === 'full' || !result.handle ){
         logger.warn(
           `[audition-engine] Executive attention full — ` +
@@ -691,6 +849,11 @@ export class AuditionEngine extends BaseSenseEngine {
       awareness:         [ ...DEFAULT_FACET_AWARENESS, 'plans' ],
       awarenessEntityId: percept.speakerEntityId,
 
+      // Who this facet is with — reported to the master on every facet sync so the
+      // singular seat knows whose conversations these are, not just how many.
+      subjectEntityId:   percept.speakerEntityId,
+      subjectName:       speakerName,
+
       instructions: [
         'I am in a live conversation with this person. I respond as myself.',
         'I stay grounded in my real memories and feelings — I do not invent experiences I have no record of.',
@@ -704,15 +867,28 @@ export class AuditionEngine extends BaseSenseEngine {
       // paragraphs (double-newline separated) become separate reply bubbles.
       extractDecision: ( raw: unknown ): ConversationDecision => {
         const output = raw as ExecutiveOutputFull
-        const rawReply = output.replyText?.trim() ?? ''
+        // A declared silence suppresses the words and NOTHING else — the goals,
+        // beliefs and entity updates below are things the mind worked out from
+        // what it heard, and they are true whether or not it answers. Discarding
+        // them with the reply would make choosing silence cost the mind its
+        // learning, which is a reason not to choose it.
+        const silent   = output.noMessage !== undefined
+        if( silent )
+          logger.info(`[audition-engine] chose silence toward ${ speakerName ?? percept.speakerEntityId }: ${ output.noMessage!.slice( 0, 120 ) }`)
+        const rawReply = silent ? '' : ( output.replyText?.trim() ?? '')
         const bubbles  = rawReply.split( /\n{2,}/ )
                                   .map( b => b.trim() )
                                   .filter( Boolean )
 
+        const outwardIntents = partitionOutwardIntents(
+          output.actions, percept.speakerEntityId, speakerName,
+        )
+
         return {
           reply:                   bubbles.join('\n'),
           replyBubbles:            bubbles,
           targetEntityId:          percept.speakerEntityId,
+          ...( outwardIntents.length > 0 ? { outwardIntents } : {} ),
           newGoals:                output.newGoals,
           goalsToAbandon:          output.goalsToAbandon,
           newBeliefs:              output.newBeliefs,
@@ -734,33 +910,97 @@ export class AuditionEngine extends BaseSenseEngine {
    * (MotorSchemaExecutor) to deliver through the proactive communicate path; empty
    * when no executive is attached or the facet budget is full (caller then awaits).
    */
-  async authorOutreach( entityId: string, entityName: string, gist?: string ): Promise<string[]> {
-    if( !this._executiveEngine ) return []
-    const spawned = this._executiveEngine.spawnFacet('outreach')
-    if( spawned.attention === 'full' || !spawned.handle ){
-      logger.warn(`[audition-engine] facet budget full — cannot author outreach to ${ entityId }`)
-      return []
+  async authorOutreach( entityId: string, entityName: string, gist?: string ): Promise<OutreachResult> {
+    if( !this._executiveEngine ) return { bubbles: [] }
+
+    // One authoring pass per person at a time.
+    //
+    // This was unguarded, and the agency can hold more than one intent toward the
+    // same target at once (two undertakings, or an undertaking plus a self-initiated
+    // reach). Each one spawned its own transient facet, each facet independently
+    // composed a message, and both were delivered — the same question asked twice,
+    // reworded, seconds apart. The executor's idempotence was keyed by INTENT id,
+    // which cannot see that two intents mean one conversation.
+    //
+    // A concurrent second call returns empty rather than waiting: its intent stays
+    // 'awaiting' and comes back round once this pass has landed and satiation has
+    // had a chance to read it, which is the outcome we want anyway.
+    if( this._outreachInFlight.has( entityId ) ){
+      logger.info(`[audition-engine] already composing an outreach to ${ entityId } — not opening a second`)
+      return { bubbles: [] }
     }
-    const handle = spawned.handle
 
-    handle.setFocus({
+    // Already talking to them? Then this is not a second thread — it is a thing to
+    // say in the one that is open, and it must be said BY that thread.
+    //
+    // A transient facet composing in parallel cannot see the live conversation: not
+    // the thread digest, not what was said two minutes ago, not the thinking the
+    // open facet has been doing about this person. So the mind asked the same
+    // question it had already asked, in different words, while the answer was
+    // sitting in a thread it was not reading. Routing through the open facet costs
+    // nothing extra — the focus rides on the REPORT (see FacetReport.focus), so the
+    // conversation's own standing focus is never touched and the next inbound turn
+    // resumes exactly where it was.
+    const openThread = this._executiveEngine.facetFor(`conversation:${ entityId }`)
+    const handle     = openThread ?? ( () => {
+      // Nobody home — a transient authoring facet, deliberately NOT supervisor-keyed:
+      // it is exactly what the mind can most afford to evict under pressure, and a
+      // key would move it into the protected tier alongside live conversations.
+      const spawned = this._executiveEngine!.spawnFacet('outreach')
+      if( spawned.attention === 'full' || !spawned.handle ){
+        logger.warn(`[audition-engine] facet budget full — cannot author outreach to ${ entityId }`)
+        return undefined
+      }
+      return spawned.handle
+    } )()
+
+    if( !handle ) return { bubbles: [] }
+
+    if( openThread )
+      logger.info(`[audition-engine] composing outreach to ${ entityId } inside the open conversation (${ openThread.facetId })`)
+
+    // What we have already said to each other, when there IS an open thread. Without
+    // it the mind opens with a question it asked four minutes ago.
+    const digest = openThread ? this._digests.getDigest( this._inflightThread.get( entityId ) ?? entityId ) : ''
+
+    const outreachFocus: FocusSection = ({
       title:    'Reaching out',
       function: 'outreach',
       content: [
-        `I have decided, on my own initiative, to reach out to ${ entityName } (id: ${ entityId }).`,
-        'No one prompted this — I am choosing to make contact now.',
+        openThread
+          ? `I am already in conversation with ${ entityName } (id: ${ entityId }), and there is something I have decided to say to them now — unprompted, not an answer to anything they asked.`
+          : `I have decided, on my own initiative, to reach out to ${ entityName } (id: ${ entityId }).`,
+        openThread
+          ? 'This continues that conversation. I do not re-introduce myself and I do not ask again for something already answered above.'
+          : 'No one prompted this — I am choosing to make contact now.',
+        digest,
         gist ? `What is on my mind: ${ gist }` : '',
+        // The gist is what the MASTER framed, and the master was not talking to
+        // them — so it refers to people in the third person, including sometimes
+        // the very person about to read it. Observed live: "Fabrice says the
+        // server issue is fixed now and he should look into the logs", addressed
+        // TO him. The words are mine to choose; the gist is only what I mean.
+        gist ? `That is my sense of it, not my words to them — I am speaking to ${ entityName } directly, so I say it the way I would say it to their face.` : '',
       ].filter( Boolean ).join('\n'),
       recallQuery:       gist ?? entityName,
       awareness:         [ ...DEFAULT_FACET_AWARENESS, 'plans' ],
       awarenessEntityId: entityId,
+      subjectEntityId:   entityId,
+      subjectName:       entityName,
       instructions:
         'Considering who I am, my goals, and how I feel, I say what I genuinely want to say to ' +
         'them now. I speak as myself; I stay grounded in my real memories — I do not invent experiences ' +
         'I have no record of.',
       outputFormat: CONVERSATION_OUTPUT_FORMAT,
       extractDecision: ( raw: unknown ): ConversationDecision => {
-        const output   = raw as ExecutiveOutputFull
+        const output = raw as ExecutiveOutputFull
+        // A declared silence beats anything else in the response. Unprompted
+        // speech is the one case where saying nothing must be cheaper than
+        // saying something — nobody is waiting on this.
+        if( output.noMessage !== undefined ){
+          logger.info(`[audition-engine] chose not to reach out to ${ entityName }: ${ output.noMessage.slice( 0, 120 ) }`)
+          return { reply: '', replyBubbles: [], withheld: true, targetEntityId: entityId, requiresMasterAttention: false }
+        }
         const rawReply = output.replyText?.trim() ?? ''
         const bubbles  = rawReply.split( /\n{2,}/ ).map( b => b.trim() ).filter( Boolean )
         return { reply: bubbles.join('\n'), replyBubbles: bubbles, targetEntityId: entityId, requiresMasterAttention: false }
@@ -770,24 +1010,59 @@ export class AuditionEngine extends BaseSenseEngine {
     // report() only QUEUES the facet's reasoning; the authored bubbles arrive LATER
     // via the subscription. So wait for the DECISION (not report's resolution), with
     // a safety timeout, then tear the transient facet down.
-    const bubbles = await new Promise<string[]>( resolve => {
-      let settled = false
-      let unsub:  () => void = () => {}
-      let timer:  ReturnType<typeof setTimeout>
-      const done = ( b: string[] ): void => { if( settled ) return; settled = true; clearTimeout( timer ); unsub(); resolve( b ) }
-      timer = setTimeout(
-        () => { logger.warn(`[audition-engine] outreach authoring timed out for ${ entityId }`); done( [] ) },
-        60_000,   // generous: the facet LLM authors in ~8–18s
-      )
-      unsub = handle.subscribe( d => done( ( d.decision as ConversationDecision ).replyBubbles ?? [] ) )
-      Promise.resolve( handle.report({ type: 'outreach', payload: { entityId, gist } }) ).catch( err => {
-        logger.warn(`[audition-engine] outreach report failed for ${ entityId }: ${ ( err as Error ).message }`)
-        done( [] )
+    this._outreachInFlight.add( entityId )
+    try {
+      const authored = await new Promise<OutreachResult>( resolve => {
+        let settled = false
+        let unsub:  () => void = () => {}
+        let timer:  ReturnType<typeof setTimeout>
+        const done = ( r: OutreachResult ): void => { if( settled ) return; settled = true; clearTimeout( timer ); unsub(); resolve( r ) }
+        timer = setTimeout(
+          () => { logger.warn(`[audition-engine] outreach authoring timed out for ${ entityId }`); done( { bubbles: [] } ) },
+          60_000,   // generous: the facet LLM authors in ~8–18s
+        )
+        // ONLY this report's decision. Sharing a live conversation facet means its
+        // ordinary reply decisions arrive on the same subscription, and resolving
+        // on one of those would hand the human's reply back as if the mind had
+        // composed it unprompted — and deliver it twice.
+        unsub = handle.subscribe( d => {
+          if( d.respondingToType !== 'outreach') return
+          const decision = d.decision as ConversationDecision
+          // A facet reasoned and its decision arrived — `answered`, whatever it
+          // holds. That is what separates an empty ANSWER from the empty every
+          // other exit on this method returns, and it is the only place on the
+          // method that can honestly say so.
+          done( {
+            bubbles:  decision.replyBubbles ?? [],
+            withheld: decision.withheld === true,
+            answered: true,
+          } )
+        } )
+        // The focus rides the REPORT, so a shared conversation facet keeps its own
+        // standing focus and its next inbound turn resumes untouched.
+        Promise.resolve( handle.report({ type: 'outreach', payload: { entityId, gist }, focus: outreachFocus }) ).catch( err => {
+          logger.warn(`[audition-engine] outreach report failed for ${ entityId }: ${ ( err as Error ).message }`)
+          done( { bubbles: [] } )
+        } )
       } )
-    } )
 
-    handle.destroy()
-    return bubbles
+      // Only tear down what we opened. Destroying a borrowed conversation facet
+      // would end the conversation as a side effect of speaking in it.
+      if( !openThread ) handle.destroy()
+      return authored
+    }
+    catch( err ){
+      // A facet that throws is a pass that produced no words — the same outcome as
+      // the timeout, and the caller's contract is already "empty means I could not
+      // author". Letting it escape would reject inside MotorSchemaExecutor's
+      // fire-and-forget authoring chain instead.
+      logger.warn(`[audition-engine] outreach authoring failed for ${ entityId }: ${ ( err as Error ).message }`)
+      return { bubbles: [] }
+    }
+    // finally{} on every path — the timeout resolves empty rather than throwing, but
+    // a destroy() or report() that throws must not leave this person permanently
+    // un-reachable by leaving the guard set.
+    finally { this._outreachInFlight.delete( entityId ) }
   }
 
   // ── Conversation memory (Section 5) ─────────────────────────
@@ -801,6 +1076,116 @@ export class AuditionEngine extends BaseSenseEngine {
    * (Section 1.2) routes ingest through the tick loop. The entity carries no
    * wall-clock timestamp — `setEntity` stamps createdAt/tick from the sim clock.
    */
+  /**
+   * The inbound as a social signal in state — mirror of `conversation.sent`.
+   *
+   * Shaped for `SocialPerception._scanSocialSignals`, which reads `sourceKeid` for
+   * who acted and `directedAtSelf` for whether it was aimed at us. Valence is left
+   * UNSET on purpose: the words have not been appraised yet, and guessing a number
+   * here would feed reputation and affect a sentiment nobody measured. Absent, the
+   * scanner falls back to its neutral default, so the Will learns *that* someone
+   * engaged (familiarity, recency, reliability) without inventing how it felt.
+   */
+  /**
+   * A durable, deterministic id for a conversation record.
+   *
+   * `<prefix>-<entity>-<tick>-<hash of the words>`. Every part earns its place:
+   *   • entity — whose conversation this is;
+   *   • tick   — WHEN, from the sim clock, which resumes from the snapshot and so
+   *              keeps rising across restarts;
+   *   • hash   — which utterance, so two things said to one person on one tick stay
+   *              two records.
+   *
+   * What it replaces was `<prefix>-<entity>-<N>` with N a process-local counter.
+   * It restarted at 1 on every boot, so each session OVERWROTE the previous
+   * session's records of the same person — a mind that had spoken with someone
+   * across four restarts held one session's worth of evidence that it ever had.
+   * Found by diffing a live snapshot against the Discord transcript it came from:
+   * `conv-sent-reply-discord:1019…-1` held that morning's greeting, and every
+   * earlier conversation keyed to the same id was simply gone.
+   *
+   * No wallClock: these ids live in state, and a wall-clock id makes the recorded
+   * and replayed runs diverge (R2).
+   */
+  private _sentKey( prefix: string, entityId: string, words: string ): string {
+    return `${ prefix }-${ entityId }-${ this._lastDecisionTick }-${ fnv1a( words ) }`
+  }
+
+  private _writeReceived( entityId: string, speakerName: string | undefined, content: string, threadId: string ): void {
+    if( !this._memorySink ) return
+    // Never wallClock(): this entity LIVES IN STATE, so a wall-clock id makes the
+    // recorded and replayed runs diverge (R2). Observed as a replay consuming 17 of
+    // 18 recorded completions — different ids meant different percepts meant a
+    // different executive firing schedule.
+    //
+    // But nor a process-local counter, which is what this was. `conv-received-<id>-N`
+    // restarted at N=1 on every boot, so each session silently OVERWROTE the last
+    // session's records of the same person. A mind that had spoken with someone
+    // across four restarts held one session's worth of evidence that it ever had.
+    // See _sentKey.
+    this._memorySink({
+      id:   this._sentKey('conv-received', entityId, content ),
+      type: 'conversation.received',
+      metadata: {
+        sourceKeid:     entityId,
+        sourceName:     speakerName,
+        directedAtSelf: true,          // an inbound turn is addressed to us by definition
+        action:         'communication',
+        preview:        content.slice( 0, 140 ),
+        chars:          content.length,
+        ...( threadId ? { threadId } : {} ),
+      },
+    })
+  }
+
+  /**
+   * Record that the mind SPOKE to someone, mirroring `_writeReceived`.
+   *
+   * Only ProactiveCommunicator wrote `conversation.sent`, so a reply — which is
+   * most of what a Will says — left no durable trace of having spoken. Everything
+   * that asks "have I already said something to them?" was therefore blind to
+   * conversation: satiation could not damp repeating a relay delivered as a reply,
+   * and an undertaking discharged inside a conversation stayed forever unkept,
+   * which is exactly how the same message went out again and again.
+   *
+   * Speaking is speaking, whichever path carried it.
+   */
+  private _writeSent(
+    entityId:   string,
+    entityName: string | undefined,
+    bubbles:    string[],
+    /**
+     * Outbox ids for these bubbles — the ONLY thing that lets a later delivery
+     * ack find this record (`OutboxController.confirmDelivery` correlates on
+     * `outboxMessageIds`, there is no other key).
+     *
+     * Omitted, this record could never be marked delivered. Every reply the mind
+     * ever made carried `delivered` unset, forever — so a mind asking itself "did
+     * that land?" found no answer for anything it had SAID, while the answer was
+     * recorded faithfully for everything it had initiated. Silence read exactly
+     * like failure, and it re-sent. The proactive path stored these from the
+     * start; the reply path was simply never given them.
+     */
+    outboxMessageIds?: string[],
+  ): void {
+    if( !this._memorySink || bubbles.length === 0 ) return
+    this._memorySink({
+      id:   this._sentKey('conv-sent-reply', entityId, bubbles.join('\n') ),
+      type: 'conversation.sent',
+      metadata: {
+        targetEntityId:   entityId,
+        targetEntityName: entityName,
+        messageCount:     bubbles.length,
+        preview:          bubbles[0]?.slice( 0, 100 ) ?? '',
+        effectorName:     'text',
+        source:           'audition-facet',
+        tick:             this._lastDecisionTick,
+        delivered:        false,
+        ...( outboxMessageIds?.length ? { outboxMessageIds } : {} ),
+      },
+    })
+  }
+
   private _persistExchangeMemory( entityId: string, threadId: string, reply: string, confidence: number, entityName?: string ): void {
     const inbound = this._inflightInbound.get( entityId ) ?? ''
     this._inflightInbound.delete( entityId )
@@ -832,6 +1217,19 @@ export class AuditionEngine extends BaseSenseEngine {
     // facet's spawn-time thread — correct for an entity that spans threads (§2).
     const threadId = this._inflightThread.get( entityId ) ?? ''
 
+    // The sim tick this was reasoned at — the only deterministic clock an off-tick
+    // engine has, and what the conversation-record ids are keyed on.
+    this._lastDecisionTick = decision.tick ?? this._lastDecisionTick
+
+    // An outreach composed INSIDE this conversation (authorOutreach borrowing the
+    // open facet) lands here too, because the session subscription is facet-wide.
+    // Its words belong to `authorOutreach`, which returns them to the agency for
+    // delivery through the proactive path; delivering them here as well would send
+    // the same message twice and answer a turn nobody took. `_endTurn` is not
+    // called either — an outreach is not a turn, and releasing the queue here would
+    // let the next inbound start while a real turn was still in flight.
+    if( decision.respondingToType === 'outreach') return
+
     // finally{} releases the entity's serial turn queue on EVERY exit path —
     // reply delivered, reply suppressed, or escalation only. Without this a
     // suppressed-reply early-return would stall the queue until the safety timeout.
@@ -875,6 +1273,8 @@ export class AuditionEngine extends BaseSenseEngine {
             pushToOutbox: !viaTransport,
           })
 
+          this._writeSent( entityId, d.targetEntityId, d.replyBubbles, ids )
+
           if( viaTransport )
             logger.info(
               `[audition-engine] Reply emitted via transport for ${entityId} ` +
@@ -892,22 +1292,61 @@ export class AuditionEngine extends BaseSenseEngine {
           )
       }
 
-      // ── Master escalation signal ──────────────────────────────
-      // Published when the facet emits an 'escalate' action type.
-      // Master executive subscribes to this and queues it as a PendingMessage.
-      if( d.requiresMasterAttention && this._bus )
-        this._bus.publish({
-          type: 'audition.task.signal',
+      // ── Outward intentions ────────────────────────────────────
+      // The facet decided, mid-conversation, to say something to someone ELSE.
+      // It does not do that itself (see ConversationDecision.outwardIntents) — it
+      // hands the intention to the master, which is singular and owns whom the
+      // mind contacts. The master perceives it as an undertaking it made and
+      // decides whether it still means it; nothing here forces the contact.
+      // `executive.facet.handoff` is the ONE channel every facet type uses to hand
+      // the master something. It replaced `audition.task.signal`, which was named
+      // and typed for this engine alone — see EscalationBuffer.
+      const handoff = ( body: HandoffBody ): void => {
+        this._bus?.publish({
+          type: 'executive.facet.handoff',
           version: 1,
           sourceEngine: this.name,
           salience: 0.9,
           payload: {
-            entityId,
+            facetId:         decision.facetId,
+            subjectEntityId: entityId,
+            ...( d.targetEntityId ? { subjectName: d.targetEntityId } : {} ),
             threadId,
-            reasoning: decision.reasoning,
-            confidence: decision.confidence
+            confidence:      decision.confidence,
+            // No `tick` — this engine runs off-tick and has no honest sim clock of
+            // its own. The master stamps it from the tick the handoff ARRIVES on,
+            // which is within one tick of when it was formed and, crucially, is a
+            // real clock reading rather than the last time the master happened to run.
+            body,
           }
         })
+      }
+
+      if( d.outwardIntents?.length )
+        for( const intent of d.outwardIntents ){
+          logger.info(
+            `[audition-engine] Outward intent from ${entityId}'s facet → ${intent.target} ` +
+            `(handing to master; the facet does not open that channel itself)`
+          )
+          handoff({
+            kind:      'undertaking',
+            // The commitment in the mind's own words. A contact is one KIND of
+            // promise, not the only kind the tract can carry — see
+            // UndertakingHandoff. This producer only makes contact-shaped ones,
+            // because a facet declares an outward intent by naming a
+            // communicate action; anything else it means to follow through on
+            // goes through [GOALS_NEW], which the format already asks for.
+            what:      `reach ${ intent.target }`,
+            target:    intent.target,
+            reasoning: intent.reasoning ?? '',
+            ...( intent.gist ? { gist: intent.gist } : {} ),
+          })
+        }
+
+      // ── Master escalation signal ──────────────────────────────
+      // Published when the facet emits an 'escalate' action type.
+      if( d.requiresMasterAttention )
+        handoff({ kind: 'escalation', reasoning: decision.reasoning })
     }
     finally {
       // Release the entity's turn queue so the next message can be processed.