switchroom 0.15.45 → 0.16.5

package/telegram-plugin/subagent-watcher.ts

@@ -42,7 +42,8 @@ import { basename, join } from 'path'
 import { homedir } from 'os'
 import { projectSubagentLine, sanitizeCwdToProjectName, detectErrorInTranscriptLine } from './session-tail.js'
 import { sanitiseToolArg } from './fleet-state.js'
-import { describeToolUse } from './tool-activity-summary.js'
+import { clipNarrative, describeToolUse } from './tool-activity-summary.js'
+import { REPLY_TOOLS, isDraftOfReply } from './narrative-dedup.js'
 import { escapeHtml, truncate } from './card-format.js'
 import { bumpSubagentActivity, recordSubagentStall, recordSubagentResume, recordSubagentEnd, reapStuckRunningRows, countRunningBackgroundSubagents } from './registry/subagents-schema.js'
 import { touchTurnActiveMarker } from './gateway/turn-active-marker.js'
@@ -158,6 +159,27 @@ export interface WorkerEntry {
    *  failed handback's "what it reported before failing" slot when the
    *  worker left no narrative result of its own. */
   errorDetail?: string
+  /**
+   * Narrative-dedup gate state (JSONL-text-narrative primitive). A
+   * `sub_agent_text` block is held here for ONE lookahead step so the next
+   * `sub_agent_tool_use` / `sub_agent_turn_end` can decide draft-then-send
+   * (SUPPRESS — it duplicates the worker's reply) vs working-narration (SHOW
+   * — fire `onProgress({latestSummary})`). Null when nothing is pending. The
+   * pure decision lives in narrative-dedup.ts; this slot is the per-entry
+   * cursor. Mirrors the gateway's `turn.pendingNarrative`.
+   */
+  pendingNarrative?: { text: string } | null
+  /**
+   * NIT 3 (sub-agent turn_end symmetry). Most-recently-seen
+   * reply/stream_reply `input.text` for this sub-agent — the actual answer a
+   * FOREGROUND sub-agent delivered. `sub_agent_turn_end` resolves a trailing
+   * `sub_agent_text` block against THIS so a draft of the just-delivered
+   * answer is suppressed the same way main-agent step 3 does (conservative
+   * dedup). Undefined for background workers that never call a reply tool —
+   * their trailing narration still SHOWs, unchanged. Mirrors the gateway's
+   * `turn.lastReplyText`.
+   */
+  lastReplyText?: string
 }
 
 export interface SubagentWatcherConfig {
@@ -503,14 +525,20 @@ interface FsLike {
  * Backfill `jsonl_agent_id` for a sub-agent row that was inserted by the
  * PreToolUse hook (keyed on tool_use_id) but didn't yet know the JSONL stem.
  *
- * Strategy: read the `agent-<id>.meta.json` sibling Claude Code writes next
- * to each sub-agent JSONL. It carries the same `{ agentType, description }`
- * pair the parent passed to the Agent() tool. We match that pair to the
- * most-recent row in `subagents` where `jsonl_agent_id IS NULL` and link them.
+ * Strategy: read the `agent-<id>.meta.json` sibling that the Claude Code
+ * binary writes next to each sub-agent JSONL. It carries `{ agentType,
+ * description, toolUseId }` where `toolUseId` is the primary key of the
+ * `subagents` row — the same `event.tool_use_id` value the pretool hook
+ * (`subagent-tracker-pretool.mjs`) uses when it inserts the DB row. We use
+ * the direct `toolUseId` lookup first (exact PK match, race-safe); fall back
+ * to the fuzzy `(agentType, description)` match only when `toolUseId` is
+ * absent (older Claude Code versions that pre-date this field in the meta).
  *
  * Edge cases:
  *   - meta.json missing or unreadable: no-op (the row stays unlinked; liveness
  *     writes from this agent's JSONL won't land, but the system stays correct).
+ *   - `toolUseId` present but no matching row (hook crashed / race): fall
+ *     through to the fuzzy match so the link is still attempted.
  *   - Multiple in-flight rows with identical (agent_type, description): the
  *     most recently started one wins (FIFO matches dispatch order in practice).
  *   - Row already linked to a different agentId: SQL `WHERE jsonl_agent_id IS
@@ -526,7 +554,7 @@ export function backfillJsonlAgentId(
   log?: (msg: string) => void,
 ): void {
   const metaPath = jsonlPath.replace(/\.jsonl$/, '.meta.json')
-  let meta: { agentType?: string; description?: string }
+  let meta: { agentType?: string; description?: string; toolUseId?: string } | null
   try {
     const raw = readFileSync(metaPath, 'utf8')
     meta = JSON.parse(raw)
@@ -534,8 +562,8 @@ export function backfillJsonlAgentId(
     log?.(`subagent-watcher: backfill skip ${agentId} — meta.json not readable at ${metaPath}`)
     return
   }
-  if (!meta.agentType && !meta.description) {
-    log?.(`subagent-watcher: backfill skip ${agentId} — meta.json has no agentType/description`)
+  if (!meta || (!meta.agentType && !meta.description && !meta.toolUseId)) {
+    log?.(`subagent-watcher: backfill skip ${agentId} — meta.json has no agentType/description/toolUseId`)
     return
   }
 
@@ -545,27 +573,51 @@ export function backfillJsonlAgentId(
     .get(agentId)
   if (already != null) return
 
-  // Find the most-recent matching unmatched row.
-  const candidate = db
-    .prepare(`
-      SELECT id FROM subagents
-      WHERE jsonl_agent_id IS NULL
-        AND agent_type IS ?
-        AND description IS ?
-      ORDER BY started_at DESC
-      LIMIT 1
-    `)
-    .get(meta.agentType ?? null, meta.description ?? null) as { id: string } | null
-
-  if (candidate == null) {
-    log?.(`subagent-watcher: backfill no candidate for ${agentId} (type=${meta.agentType} desc=${meta.description})`)
+  // Primary path (Bug 1 fix): direct PK lookup via the toolUseId Claude Code
+  // writes to meta.json. The pretool hook inserts the row with `id =
+  // event.tool_use_id`, so this is an exact match with no ambiguity — no
+  // race, no description-collision, no fuzzy-match false-negative.
+  let candidateId: string | null = null
+  if (meta.toolUseId) {
+    const direct = db
+      .prepare('SELECT id FROM subagents WHERE id = ? AND jsonl_agent_id IS NULL LIMIT 1')
+      .get(meta.toolUseId) as { id: string } | null
+    if (direct != null) {
+      candidateId = direct.id
+      log?.(`subagent-watcher: backfill direct-key match ${agentId} → ${candidateId} (toolUseId=${meta.toolUseId})`)
+    } else {
+      log?.(`subagent-watcher: backfill direct-key miss ${agentId} toolUseId=${meta.toolUseId} — falling back to fuzzy match`)
+    }
+  }
+
+  // Fallback path: fuzzy (agentType, description) match for older Claude Code
+  // versions whose meta.json predates the toolUseId field.
+  if (candidateId == null && (meta.agentType || meta.description)) {
+    const fuzzy = db
+      .prepare(`
+        SELECT id FROM subagents
+        WHERE jsonl_agent_id IS NULL
+          AND agent_type IS ?
+          AND description IS ?
+        ORDER BY started_at DESC
+        LIMIT 1
+      `)
+      .get(meta.agentType ?? null, meta.description ?? null) as { id: string } | null
+    if (fuzzy != null) {
+      candidateId = fuzzy.id
+      log?.(`subagent-watcher: backfill fuzzy match ${agentId} → ${candidateId} (type=${meta.agentType} desc=${meta.description})`)
+    }
+  }
+
+  if (candidateId == null) {
+    log?.(`subagent-watcher: backfill no candidate for ${agentId} (toolUseId=${meta.toolUseId} type=${meta.agentType} desc=${meta.description})`)
     return
   }
 
   db
     .prepare('UPDATE subagents SET jsonl_agent_id = ? WHERE id = ?')
-    .run(agentId, candidate.id)
-  log?.(`subagent-watcher: backfill linked ${agentId} → ${candidate.id}`)
+    .run(agentId, candidateId)
+  log?.(`subagent-watcher: backfill linked ${agentId} → ${candidateId}`)
 
   // Backfill parent_turn_key (gateway-side). The PreToolUse hook can't know
   // the gateway-minted Telegram turn_key (a chat+topic+turn key) — it only
@@ -588,7 +640,7 @@ export function backfillJsonlAgentId(
   try {
     const linkedRow = db
       .prepare('SELECT started_at, parent_turn_key FROM subagents WHERE id = ?')
-      .get(candidate.id) as { started_at: number; parent_turn_key: string | null } | null
+      .get(candidateId) as { started_at: number; parent_turn_key: string | null } | null
     if (linkedRow != null && linkedRow.parent_turn_key == null) {
       const turn = db
         .prepare(
@@ -600,12 +652,12 @@ export function backfillJsonlAgentId(
       if (turn?.turn_key != null) {
         db
           .prepare('UPDATE subagents SET parent_turn_key = ? WHERE id = ?')
-          .run(turn.turn_key, candidate.id)
-        log?.(`subagent-watcher: backfill parent_turn_key ${candidate.id} → ${turn.turn_key}`)
+          .run(turn.turn_key, candidateId)
+        log?.(`subagent-watcher: backfill parent_turn_key ${candidateId} → ${turn.turn_key}`)
       }
     }
   } catch (err) {
-    log?.(`subagent-watcher: parent_turn_key backfill skipped for ${candidate.id} — ${(err as Error).message}`)
+    log?.(`subagent-watcher: parent_turn_key backfill skipped for ${candidateId} — ${(err as Error).message}`)
   }
 }
 
@@ -743,6 +795,62 @@ export function readSubTail(
         if (errInfo.detail) entry.errorDetail = errInfo.detail.slice(0, SUBAGENT_RESULT_TEXT_MAX)
       }
       const events = projectSubagentLine(line, entry.agentId, startState)
+      // Narrative-dedup gate (JSONL-text-narrative primitive) — fire the
+      // narrative progress cue for a SHOWN sub_agent_text block. Identical
+      // shape to the inline #1720 onProgress below; factored out so the gate
+      // (stage-on-text, resolve-on-tool/turn_end) can replay a previously
+      // pending block exactly once. `latestSummary` carries the worker's
+      // narrative result (entry.lastResultText), never tool labels.
+      const fireNarrativeProgress = (): void => {
+        if (onProgress == null || entry.state !== 'running' || entry.historical) return
+        try {
+          onProgress({
+            agentId: entry.agentId,
+            description: entry.description,
+            latestSummary: entry.lastResultText,
+            elapsedMs: now - entry.dispatchedAt,
+            prevBucketIdx: entry.lastProgressBucketIdx,
+            setBucketIdx: (b: number) => {
+              entry.lastProgressBucketIdx = b
+            },
+            lastTool: entry.lastTool,
+            toolCount: entry.toolCount,
+          })
+        } catch (cbErr) {
+          log?.(`subagent-watcher: onProgress callback error ${entry.agentId}: ${(cbErr as Error).message}`)
+        }
+      }
+      // Resolve a pending sub-agent narrative against a lookahead event.
+      // SUPPRESS only when the pending block drafts a reply/stream_reply
+      // tool's text; otherwise SHOW (fire the cue). See narrative-dedup.ts §2b.
+      //
+      // Two lookahead shapes:
+      //   - sub_agent_tool_use: `toolName`/`toolInput` are the tool — suppress
+      //     a draft of THIS tool's reply text.
+      //   - sub_agent_turn_end: `toolName` is null. NIT 3 (turn_end symmetry):
+      //     a FOREGROUND sub-agent that called stream_reply/reply as its final
+      //     tool then emitted a trailing text block would, under the old
+      //     unconditional SHOW, surface a draft of the delivered answer. So at
+      //     turn_end we apply the SAME conservative dedup as main-agent step 3:
+      //     compare the trailing block against the worker's last reply text
+      //     (`entry.lastReplyText`) and suppress a draft. Background workers
+      //     never set lastReplyText, so their trailing narration still SHOWs.
+      const resolvePendingSubNarrative = (
+        toolName: string | null,
+        toolInput: Record<string, unknown> | undefined,
+      ): void => {
+        if (entry.pendingNarrative == null) return
+        const pending = entry.pendingNarrative
+        entry.pendingNarrative = null
+        if (toolName != null && REPLY_TOOLS.has(toolName)) {
+          const replyText = typeof toolInput?.text === 'string' ? (toolInput.text as string) : ''
+          if (isDraftOfReply(pending.text, replyText)) return // draft of the reply → SUPPRESS
+        } else if (toolName == null && entry.lastReplyText != null && entry.lastReplyText.length > 0) {
+          // turn_end path: suppress a trailing draft of the delivered answer.
+          if (isDraftOfReply(pending.text, entry.lastReplyText)) return
+        }
+        fireNarrativeProgress()
+      }
       for (const ev of events) {
         const idleSecBeforeBump = Math.round((now - entry.lastActivityAt) / 1000)
         entry.lastActivityAt = now
@@ -783,6 +891,17 @@ export function readSubTail(
           log?.(`subagent-watcher: stall cleared for ${entry.agentId} (activity resumed after ${idleSecBeforeBump}s — re-arming detection)`)
         }
         if (ev.kind === 'sub_agent_tool_use') {
+          // Narrative-dedup gate step 2: a sub_agent_text block was pending;
+          // this tool is the lookahead that decides it (SHOW unless it drafts
+          // a reply tool's text). Runs before the tool's own progress cue so
+          // a working preamble surfaces just ahead of its tool step.
+          resolvePendingSubNarrative(ev.toolName, ev.input)
+          // NIT 3: capture a foreground sub-agent's actual reply text so the
+          // turn_end path can suppress a trailing draft of it (see
+          // resolvePendingSubNarrative). Only REPLY_TOOLS carry the answer.
+          if (REPLY_TOOLS.has(ev.toolName) && typeof ev.input?.text === 'string') {
+            entry.lastReplyText = ev.input.text as string
+          }
           entry.toolCount++
           // P0 of #662: surface the most recent tool name + sanitised
           // arg so the driver's fleet-state shadow can render the
@@ -830,7 +949,7 @@ export function readSubTail(
           // set at dispatch time (from the parent Agent/Task tool_use input)
           // and must remain stable. Overwriting it with the sub-agent's first
           // narrative line caused a race-condition-dependent display (issue #352).
-          entry.lastSummaryLine = ev.text.split('\n')[0].trim().slice(0, 120)
+          entry.lastSummaryLine = clipNarrative(ev.text)
           // Retain the full text of the most recent narrative emission —
           // for a worker the final such line before turn_end IS its
           // result summary (the worker prompt asks it to "return a
@@ -841,29 +960,28 @@ export function readSubTail(
           // args or file content — consistent with the watcher's
           // "descriptions only" privacy posture.
           entry.lastResultText = ev.text.trim().slice(0, SUBAGENT_RESULT_TEXT_MAX)
-          // #1720: surface a progress cue for the gateway. Only fire
-          // while the entry is still running and not historical — a
-          // terminal entry's last narrative line is the handback
-          // payload, not a mid-flight progress nudge.
-          if (onProgress != null && entry.state === 'running' && !entry.historical) {
-            try {
-              onProgress({
-                agentId: entry.agentId,
-                description: entry.description,
-                latestSummary: entry.lastResultText,
-                elapsedMs: now - entry.dispatchedAt,
-                prevBucketIdx: entry.lastProgressBucketIdx,
-                setBucketIdx: (b: number) => {
-                  entry.lastProgressBucketIdx = b
-                },
-                lastTool: entry.lastTool,
-                toolCount: entry.toolCount,
-              })
-            } catch (cbErr) {
-              log?.(`subagent-watcher: onProgress callback error ${entry.agentId}: ${(cbErr as Error).message}`)
-            }
+          // #1720 + JSONL-text-narrative gate step 1: stage this block for
+          // one lookahead step instead of firing the progress cue
+          // immediately. A previously-pending block had nothing reply-shaped
+          // after it (pure narration) → flush it as SHOWN now; then stage
+          // THIS block. Its eventual SHOW/SUPPRESS is decided by the next
+          // sub_agent_tool_use / sub_agent_turn_end. `lastResultText` /
+          // `lastSummaryLine` above already updated unconditionally — the
+          // handback payload is independent of the progress-cue decision.
+          if (entry.pendingNarrative != null) {
+            fireNarrativeProgress() // prior pending was pure narration → SHOW
           }
+          entry.pendingNarrative = { text: ev.text }
         } else if (ev.kind === 'sub_agent_turn_end') {
+          // Narrative-dedup gate step 3: a trailing sub_agent_text block with
+          // nothing after it. SUPPRESS only when it drafts the foreground
+          // sub-agent's delivered reply (entry.lastReplyText, set above on a
+          // REPLY_TOOL tool_use) — symmetric with main-agent step 3; otherwise
+          // SHOW. Background workers never set lastReplyText, so their trailing
+          // narration still SHOWs. The worker's result is carried separately
+          // via lastResultText/onFinish, so a SHOWN trailing cue here is purely
+          // the transient liveness beat.
+          resolvePendingSubNarrative(null, undefined)
           if (entry.state === 'running') {
             entry.state = 'done'
             // Bug 2 fix (#333): mark the DB row completed via watcher's turn_end
@@ -1456,25 +1574,53 @@ export function startSubagentWatcher(config: SubagentWatcherConfig): SubagentWat
         const subagentsPath = join(projectPath, sDir, 'subagents')
         if (!fs.existsSync(subagentsPath)) continue
 
-        // Watch the subagents dir for new files if not already watching
-        if (!dirWatchers.has(subagentsPath)) {
-          try {
-            const w = fs.watch(subagentsPath, (_event, filename) => {
-              if (!filename || !filename.toString().startsWith('agent-') || !filename.toString().endsWith('.jsonl')) return
-              const filePath = join(subagentsPath, filename.toString())
-              if (!knownFiles.has(filePath)) {
-                scanSubagentsDir(subagentsPath)
-              }
-            })
-            dirWatchers.set(subagentsPath, w)
-            log?.(`subagent-watcher: watching dir ${subagentsPath}`)
-          } catch (err) {
-            log?.(`subagent-watcher: dir watch failed ${subagentsPath}: ${(err as Error).message}`)
+        // Watch a single flat subagents dir and scan its agent-*.jsonl files.
+        // Reused for both the base subagents/ dir and each workflow sub-dir.
+        const watchAndScan = (dirPath: string): void => {
+          if (!dirWatchers.has(dirPath)) {
+            try {
+              const w = fs.watch(dirPath, (_event, filename) => {
+                if (!filename || !filename.toString().startsWith('agent-') || !filename.toString().endsWith('.jsonl')) return
+                const filePath = join(dirPath, filename.toString())
+                if (!knownFiles.has(filePath)) {
+                  scanSubagentsDir(dirPath)
+                }
+              })
+              dirWatchers.set(dirPath, w)
+              log?.(`subagent-watcher: watching dir ${dirPath}`)
+            } catch (err) {
+              log?.(`subagent-watcher: dir watch failed ${dirPath}: ${(err as Error).message}`)
+            }
           }
+          scanSubagentsDir(dirPath)
         }
 
-        // Scan existing files
-        scanSubagentsDir(subagentsPath)
+        // Register the base subagents dir
+        watchAndScan(subagentsPath)
+
+        // Workflow sub-agents (spawned by the Workflow tool) write to:
+        //   subagents/workflows/wf_<id>/agent-<id>.jsonl
+        // The flat readdir above misses these because it only sees the
+        // "workflows" directory entry (not matching agent-*.jsonl). Descend
+        // one level so each wf_*/ dir gets the same watch+scan treatment.
+        const workflowsPath = join(subagentsPath, 'workflows')
+        if (fs.existsSync(workflowsPath)) {
+          let wfDirs: string[]
+          try {
+            wfDirs = fs.readdirSync(workflowsPath) as string[]
+          } catch { continue }
+          for (const wfDir of wfDirs) {
+            try {
+              const wfPath = join(workflowsPath, wfDir)
+              // Only descend into actual directories. statSync succeeds on
+              // regular files too (e.g. a stray journal.jsonl or lock file
+              // sitting directly in workflows/), so check isDirectory()
+              // explicitly rather than relying on a throw that never comes.
+              if (!fs.statSync(wfPath).isDirectory()) continue
+              watchAndScan(wfPath)
+            } catch { /* skip entries we can't stat or watch */ }
+          }
+        }
       }
     }
   }

package/telegram-plugin/tests/activity-ever-opened-sticky.test.ts

@@ -0,0 +1,47 @@
+/**
+ * M-2: `activityEverOpened` sticky-true invariant — structural assertion.
+ *
+ * `activityEverOpened` is set to `true` exactly once, when the activity feed
+ * posts its first message (the `sendMessage` path in `drainActivitySummary`).
+ * It must NEVER be reset to false or cleared — unlike `activityMessageId`, which
+ * is nulled by `clearActivitySummary` to indicate that the persistent message was
+ * finalized/deleted. The sticky-true invariant lets the turn-end DEGRADED check
+ * (`detectStatusSurfaceDegraded`) distinguish "feed never opened" (the
+ * resume-400 signature) from "feed opened + finalized".
+ *
+ * Load-bearing constraints:
+ *   1. `activityEverOpened = true` is set exactly ONCE in gateway.ts (at the
+ *      send-message success site in drainActivitySummary).
+ *   2. `turn.activityEverOpened = false` NEVER appears in gateway.ts (it is only
+ *      initialised to `false` in the turn-initialiser object literal, never reset
+ *      via a standalone assignment).
+ *
+ * These are STRUCTURAL (source-read) assertions. Pattern: silence-liveness-wiring.test.ts.
+ */
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+const gatewaySrc = readFileSync(
+  resolve(__dirname, '..', 'gateway', 'gateway.ts'),
+  'utf-8',
+)
+
+describe('M-2: activityEverOpened sticky-true invariant', () => {
+  it('activityEverOpened = true appears exactly once (set at send-message success)', () => {
+    const setTrueMatches = [...gatewaySrc.matchAll(/activityEverOpened\s*=\s*true/g)]
+    expect(setTrueMatches).toHaveLength(1)
+  })
+
+  it('turn.activityEverOpened = false never appears (no standalone reset)', () => {
+    // The only `false` value must be in the object literal initialiser
+    // (e.g. `activityEverOpened: false`), never a standalone reassignment.
+    const resetMatches = [...gatewaySrc.matchAll(/turn\.activityEverOpened\s*=\s*false/g)]
+    expect(resetMatches).toHaveLength(0)
+  })
+
+  it('activityEverOpened is initialised false in the turn object literal (per-turn reset)', () => {
+    // The object literal form `activityEverOpened: false` must exist (per-turn init).
+    expect(gatewaySrc).toMatch(/activityEverOpened:\s*false/)
+  })
+})

package/telegram-plugin/tests/answer-stream-dedup.test.ts

@@ -24,7 +24,7 @@
  */
 
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest'
-import { createAnswerStream, __resetDraftIdForTests } from '../answer-stream.js'
+import { createAnswerStream } from '../answer-stream.js'
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -47,7 +47,6 @@ function makeEditMessageText() {
 }
 
 beforeEach(() => {
-  __resetDraftIdForTests()
   nextMessageId = 2000
   vi.useFakeTimers()
 })
@@ -70,9 +69,7 @@ describe('answer-stream materialize() — dedup callbacks (#646)', () => {
     const onMetric = vi.fn()
 
     const stream = createAnswerStream({
-      chatId: 'chat646',
-      isPrivateChat: false,
-      minInitialChars: 0,
+      chatId: 'chat646',      minInitialChars: 0,
       throttleMs: 250,
       sendMessage,
       editMessageText,
@@ -112,9 +109,7 @@ describe('answer-stream materialize() — dedup callbacks (#646)', () => {
     const log = vi.fn()
 
     const stream = createAnswerStream({
-      chatId: 'chat646',
-      isPrivateChat: false,
-      minInitialChars: 0,
+      chatId: 'chat646',      minInitialChars: 0,
       throttleMs: 250,
       sendMessage,
       editMessageText,
@@ -158,9 +153,7 @@ describe('answer-stream materialize() — dedup callbacks (#646)', () => {
     const editMessageText = makeEditMessageText()
 
     const stream = createAnswerStream({
-      chatId: 'chat646',
-      isPrivateChat: false,
-      minInitialChars: 0,
+      chatId: 'chat646',      minInitialChars: 0,
       throttleMs: 250,
       sendMessage,
       editMessageText,
@@ -185,9 +178,7 @@ describe('answer-stream materialize() — dedup callbacks (#646)', () => {
     const recordDedup = vi.fn()
 
     const stream = createAnswerStream({
-      chatId: 'chat646',
-      isPrivateChat: false,
-      minInitialChars: 0,
+      chatId: 'chat646',      minInitialChars: 0,
       throttleMs: 250,
       sendMessage: sendMessage as never,
       editMessageText,
@@ -229,9 +220,7 @@ describe('answer-stream materialize() — dedup callbacks (#646)', () => {
     const editMessageText = makeEditMessageText()
 
     const stream = createAnswerStream({
-      chatId: 'chat646',
-      isPrivateChat: false,
-      minInitialChars: 0,
+      chatId: 'chat646',      minInitialChars: 0,
       throttleMs: 250,
       sendMessage,
       editMessageText,
@@ -276,9 +265,7 @@ describe('answer-stream materialize() — recordOutbound callback (#648)', () =>
     const recordOutbound = vi.fn()
 
     const stream = createAnswerStream({
-      chatId: 'chat648',
-      isPrivateChat: false,
-      minInitialChars: 0,
+      chatId: 'chat648',      minInitialChars: 0,
       throttleMs: 250,
       sendMessage,
       editMessageText,
@@ -303,9 +290,7 @@ describe('answer-stream materialize() — recordOutbound callback (#648)', () =>
     const recordOutbound = vi.fn()
 
     const stream = createAnswerStream({
-      chatId: 'chat648',
-      isPrivateChat: false,
-      minInitialChars: 0,
+      chatId: 'chat648',      minInitialChars: 0,
       throttleMs: 250,
       sendMessage,
       editMessageText,
@@ -331,9 +316,7 @@ describe('answer-stream materialize() — recordOutbound callback (#648)', () =>
     const recordOutbound = vi.fn()
 
     const stream = createAnswerStream({
-      chatId: 'chat648',
-      isPrivateChat: false,
-      minInitialChars: 0,
+      chatId: 'chat648',      minInitialChars: 0,
       throttleMs: 250,
       sendMessage: sendMessage as never,
       editMessageText,