@mindot/will 0.7.0 → 0.9.0

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

@@ -13,14 +13,14 @@
  * Architecture:
  *   - External call: WillManager.ingestText() → audition.ingest(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'
@@ -74,6 +75,8 @@ import type {
   TextMessage,
   VoiceChunk
 } from '#senses/index'
+import { validateFacetHandoff, type HandoffBody } from '#faculties/executive.engine/escalation.buffer'
+import { fnv1a } from '#agency/consequence'
 
 // ── Internal types ─────────────────────────────────────────────
 
@@ -83,6 +86,22 @@ interface ConversationDecision {
   /** Individual reply bubbles for display (separate SSE chunks). */
   replyBubbles:           string[]
   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,6 +133,46 @@ 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.
@@ -145,25 +204,38 @@ 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.
+
 ## 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 +342,12 @@ 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.
+   */
+  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 +356,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 +411,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).
@@ -506,6 +586,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().
@@ -561,7 +651,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 +784,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 +802,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,
@@ -736,31 +847,95 @@ export class AuditionEngine extends BaseSenseEngine {
    */
   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 }`)
+
+    // 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 []
     }
-    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 []
+
+    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: [], 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 +945,50 @@ 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 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
+        )
+        // 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
+          done( ( d.decision as ConversationDecision ).replyBubbles ?? [] )
+        } )
+        // 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( [] )
+        } )
       } )
-    } )
 
-    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 bubbles
+    }
+    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 []
+    }
+    // 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 +1002,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 +1143,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 +1199,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 +1218,54 @@ 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',
+            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.

package/src/cognition/senses/base.sense.engine.ts

@@ -20,7 +20,7 @@
  * domains (see §6 cross-modal note).
  *
  * - `AuditionEngine` extends this and overrides `publishes()`/`snapshot()` for its
- *   extra `audition.task.signal` schema and session snapshot.
+ *   extra `executive.facet.handoff` schema and session snapshot.
  * - The four shell engines extend `ShellSenseEngine` (below) and are ~6 lines each.
  */