switchroom 0.18.18 → 0.18.20

package/telegram-plugin/tests/worker-feed-terminal-cleanup.test.ts

@@ -0,0 +1,254 @@
+/**
+ * Integration guard for the worker-feed ghost-leak fix (PR #3226 review,
+ * Finding 1). The unit tests in `worker-feed-coalesce.test.ts` call
+ * `feed.terminate()` DIRECTLY — they prove the feed collapses/unpins when
+ * asked, but they do NOT prove the two halves of the actual wire that was
+ * broken:
+ *
+ *   (a) the subagent-watcher FIRES `onTerminalCleanup` from its authoritative
+ *       `cleanupTerminalAgent` sweep — on BOTH the JSONL-vanished path
+ *       (`onFileVanished` → `cleanupTerminalAgent`) AND the boot done-at-boot
+ *       orphan path — the exact paths that never fire `onFinish`; and
+ *   (b) wiring that callback to `workerActivityFeed.terminate` removes the row
+ *       and collapses/unpins the shared card end-to-end.
+ *
+ * These drive the REAL `startSubagentWatcher` (with a mock fs) wired to a REAL
+ * `createWorkerActivityFeed` exactly as the gateway wires them
+ * (`onTerminalCleanup: (id) => feed.terminate(id)`). If a future refactor drops
+ * the `config.onTerminalCleanup(agentId)` call in `cleanupTerminalAgent`, the
+ * callback never fires, the feed row survives, and these go RED — the
+ * regression the divergence-based leak represented.
+ */
+import { describe, it, expect, vi } from 'vitest'
+import * as fs from 'fs'
+import { startSubagentWatcher } from '../subagent-watcher.js'
+import {
+  createWorkerActivityFeed,
+  type BotApiForWorkerFeed,
+  type WorkerActivityView,
+} from '../worker-activity-feed.js'
+
+function buildJSONL(...lines: object[]): string {
+  return lines.map((l) => JSON.stringify(l)).join('\n') + '\n'
+}
+const subAgentUserMsg = (t: string) => ({ type: 'user', message: { content: [{ type: 'text', text: t }] } })
+const subAgentTurnEnd = () => ({ type: 'system', subtype: 'turn_duration', duration_ms: 100 })
+
+function view(desc: string, step: string, elapsedMs: number): WorkerActivityView {
+  return { description: desc, lastTool: null, toolCount: 2, latestSummary: step, elapsedMs, state: 'running' }
+}
+
+/** A real feed with a fake bot + reconcilePin capture, driven off `now`. */
+function makeFeed(now: () => number) {
+  const sends: { text: string }[] = []
+  const edits: { messageId: number; text: string }[] = []
+  const pins: { messageId: number | null }[] = []
+  let seq = 700
+  const bot: BotApiForWorkerFeed = {
+    sendMessage: async (_c, text) => {
+      sends.push({ text })
+      return { message_id: seq++ }
+    },
+    editMessageText: async (_c, messageId, text) => {
+      edits.push({ messageId, text })
+      return true
+    },
+  }
+  const feed = createWorkerActivityFeed({
+    bot,
+    now,
+    minEditIntervalMs: 0,
+    heartbeatTickMs: 1000,
+    firstPaintMinMs: 0,
+    setInterval: () => 0,
+    clearInterval: () => {},
+    reconcilePin: ({ messageId }) => pins.push({ messageId }),
+  })
+  return { feed, sends, edits, pins }
+}
+async function drain(): Promise<void> {
+  for (let i = 0; i < 12; i++) await new Promise((r) => setImmediate(r))
+}
+
+/**
+ * A mock fs over a single subagents dir with one worker JSONL. `vanished`
+ * flips the file-read calls to throw ENOENT (Claude Code reaped the parent
+ * session's `subagents/` dir) to exercise the vanished terminal path.
+ */
+function mockWatcherFs(opts: {
+  agentDir: string
+  fileName: string
+  content: Buffer
+  vanished: () => boolean
+}) {
+  const projectsRoot = `${opts.agentDir}/.claude/projects`
+  const projectDir = `${projectsRoot}/mock-cwd`
+  const sessionDir = `${projectDir}/sess`
+  const subagentsDir = `${sessionDir}/subagents`
+  const filePath = `${subagentsDir}/${opts.fileName}`
+  let lastOpened: string | null = null
+  const enoent = (): never => {
+    const e = new Error('ENOENT') as NodeJS.ErrnoException
+    e.code = 'ENOENT'
+    throw e
+  }
+  const mock = {
+    existsSync: ((p: fs.PathLike) => {
+      const ps = String(p)
+      if (ps === projectsRoot || ps === projectDir || ps === sessionDir || ps === subagentsDir) return true
+      return ps === filePath && !opts.vanished()
+    }) as typeof fs.existsSync,
+    readdirSync: ((p: fs.PathLike) => {
+      const ps = String(p)
+      if (ps === projectsRoot) return ['mock-cwd']
+      if (ps === projectDir) return ['sess']
+      if (ps === sessionDir) return ['subagents']
+      if (ps === subagentsDir) return opts.vanished() ? [] : [opts.fileName]
+      return []
+    }) as unknown as typeof fs.readdirSync,
+    statSync: ((p: fs.PathLike) => {
+      if (opts.vanished()) return enoent()
+      return { size: opts.content.length, mtimeMs: 0 } as fs.Stats
+    }) as typeof fs.statSync,
+    openSync: ((p: fs.PathLike) => {
+      if (opts.vanished()) return enoent()
+      lastOpened = String(p)
+      return 7
+    }) as unknown as typeof fs.openSync,
+    closeSync: (() => { lastOpened = null }) as typeof fs.closeSync,
+    readSync: ((_fd: number, buf: NodeJS.ArrayBufferView, offset: number, length: number, position: number | null): number => {
+      if (opts.vanished() || lastOpened == null) return 0
+      const src = opts.content.slice(position ?? 0, (position ?? 0) + length)
+      src.copy(buf as Buffer, offset)
+      return src.length
+    }) as unknown as typeof fs.readSync,
+    watch: (() => ({ close: vi.fn() }) as unknown as fs.FSWatcher) as unknown as typeof fs.watch,
+  }
+  return { mock, filePath }
+}
+
+/** Deterministic clock + injectable timers shared by watcher + feed. */
+function makeClock() {
+  let currentTime = 1_000_000
+  const intervals: Array<{ fn: () => void; ms: number; fireAt: number }> = []
+  const timeouts: Array<{ fn: () => void; fireAt: number; ref: number }> = []
+  let nextRef = 1
+  const now = () => currentTime
+  const advance = (ms: number): void => {
+    currentTime += ms
+    for (;;) {
+      timeouts.sort((a, b) => a.fireAt - b.fireAt)
+      const next = timeouts[0]
+      if (!next || next.fireAt > currentTime) break
+      timeouts.shift()
+      next.fn()
+    }
+    for (const iv of intervals) {
+      while (iv.fireAt <= currentTime) {
+        iv.fn()
+        iv.fireAt += iv.ms
+      }
+    }
+  }
+  const timers = {
+    setInterval: (fn: () => void, ms: number) => {
+      intervals.push({ fn, ms, fireAt: currentTime + ms })
+      return { ref: 0 }
+    },
+    clearInterval: () => {},
+    setTimeout: (fn: () => void, ms: number) => {
+      const ref = nextRef++
+      timeouts.push({ fn, fireAt: currentTime + ms, ref })
+      return { ref }
+    },
+    clearTimeout: (handle: { ref: number }) => {
+      const idx = timeouts.findIndex((t) => t.ref === handle.ref)
+      if (idx !== -1) timeouts.splice(idx, 1)
+    },
+  }
+  return { now, advance, timers }
+}
+
+describe('worker-feed ghost-leak — watcher terminal sweep → feed removal (integration)', () => {
+  it('boot done-at-boot orphan: cleanupTerminalAgent fires onTerminalCleanup → feed row removed, card collapsed + unpinned', async () => {
+    const agentDir = '/home/user/.switchroom/agents/x'
+    const { now, advance, timers } = makeClock()
+    const { feed, pins } = makeFeed(now)
+
+    // The worker was live in the feed (its progress had surfaced there).
+    await feed.update('boot1', 'chat', view('task boot1', 'reading', 0))
+    await drain()
+    expect(feed.size).toBe(1)
+    expect(pins.at(-1)?.messageId).not.toBeNull() // pinned
+
+    const { mock } = mockWatcherFs({
+      agentDir,
+      fileName: 'agent-boot1.jsonl',
+      // Already `done` at boot (turn_end present) → registerAgent schedules a
+      // terminal cleanup with NO onFinish (the boot-orphan bypass path).
+      content: Buffer.from(buildJSONL(subAgentUserMsg('done task'), subAgentTurnEnd()), 'utf-8'),
+      vanished: () => false,
+    })
+    const watcher = startSubagentWatcher({
+      agentDir,
+      fs: mock,
+      now,
+      // Wire EXACTLY as the gateway does.
+      onTerminalCleanup: (agentId) => { void feed.terminate(agentId) },
+      ...timers,
+    })
+    expect(watcher.getRegistry().has('boot1')).toBe(true)
+
+    // Fire the scheduled terminal cleanup (30s grace) → onTerminalCleanup.
+    advance(30_000)
+    await drain()
+
+    expect(feed.size).toBe(0)                        // row removed by the sweep
+    expect(pins.at(-1)?.messageId).toBeNull()        // card collapsed + UNPINNED
+    watcher.stop()
+  })
+
+  it('JSONL-vanished path: onFileVanished → cleanupTerminalAgent → onTerminalCleanup → feed row removed + unpinned', async () => {
+    const agentDir = '/home/user/.switchroom/agents/y'
+    const { now, advance, timers } = makeClock()
+    const { feed, pins } = makeFeed(now)
+
+    await feed.update('van1', 'chat', view('task van1', 'running a command', 0))
+    await drain()
+    expect(feed.size).toBe(1)
+
+    let vanished = false
+    const { mock } = mockWatcherFs({
+      agentDir,
+      fileName: 'agent-van1.jsonl',
+      // Running at boot (no turn_end) — stays registered; the poll loop reads
+      // it defensively, so when the file vanishes the read throws ENOENT and
+      // the watcher takes onFileVanished → cleanupTerminalAgent.
+      content: Buffer.from(buildJSONL(subAgentUserMsg('long task')), 'utf-8'),
+      vanished: () => vanished,
+    })
+    const captured: string[] = []
+    const watcher = startSubagentWatcher({
+      agentDir,
+      fs: mock,
+      now,
+      onTerminalCleanup: (agentId) => {
+        captured.push(agentId)
+        void feed.terminate(agentId)
+      },
+      ...timers,
+    })
+    expect(watcher.getRegistry().has('van1')).toBe(true)
+
+    // The parent session ends → Claude Code reaps subagents/ → next poll read
+    // hits ENOENT.
+    vanished = true
+    advance(2_000) // drive the rescan/poll interval
+    await drain()
+
+    expect(captured).toContain('van1')               // vanished path funnels here
+    expect(feed.size).toBe(0)                         // wired removal happened
+    expect(pins.at(-1)?.messageId).toBeNull()         // unpinned
+    watcher.stop()
+  })
+})

package/telegram-plugin/tests/worker-feed-terminal-state-truthful.test.ts

@@ -0,0 +1,125 @@
+/**
+ * Residual B regression: a worker cleaned up by the TTL / authoritative
+ * `terminate` sweep — i.e. reaped / vanished / crashed WITHOUT ever delivering
+ * a clean `onFinish` result — must render a TRUTHFUL terminal state, NOT "done".
+ *
+ * `terminateWorker` synthesises the recap when NO clean finish arrived (a clean
+ * `onFinish` removes the row first, making `terminate` a no-op; an errored
+ * worker goes through `onFinish(outcome:'failed')`). So a row still present at
+ * terminate time genuinely ended without a result → it must render as the
+ * `incomplete` terminal ("incomplete · …"), never "done".
+ *
+ * OUTCOME assertions on the finalized card body (RED if `terminate` reverts to
+ * `state:'done'`), applied to the generic worker row so the guarantee holds at
+ * every nesting level (the feed keys rows by agentId, depth-agnostic):
+ *   - a solo reaped worker's terminal card reads `incomplete`, never `done`;
+ *   - a genuinely-`finish`ed worker still reads `done` with its result.
+ */
+import { describe, it, expect } from 'vitest'
+import {
+  createWorkerActivityFeed,
+  renderWorkerActivity,
+  type BotApiForWorkerFeed,
+  type WorkerActivityView,
+} from '../worker-activity-feed.js'
+
+function makeFeed(now: () => number) {
+  const sends: { text: string }[] = []
+  const edits: { messageId: number; text: string }[] = []
+  let seq = 900
+  const bot: BotApiForWorkerFeed = {
+    sendMessage: async (_c, text) => { sends.push({ text }); return { message_id: seq++ } },
+    editMessageText: async (_c, messageId, text) => { edits.push({ messageId, text }); return true },
+  }
+  const feed = createWorkerActivityFeed({
+    bot,
+    now,
+    minEditIntervalMs: 0,
+    firstPaintMinMs: 0,
+    setInterval: () => 0,
+    clearInterval: () => {},
+  })
+  return { feed, sends, edits }
+}
+const runningView = (desc: string, step: string, elapsedMs: number): WorkerActivityView => ({
+  description: desc, lastTool: null, toolCount: 3, latestSummary: step, elapsedMs, state: 'running',
+})
+async function drain(): Promise<void> {
+  for (let i = 0; i < 12; i++) await new Promise((r) => setImmediate(r))
+}
+
+describe('worker terminal state is truthful for reaped workers (Residual B)', () => {
+  it('a reaped/vanished worker (terminate, no clean finish) renders `incomplete`, never `done`', async () => {
+    let clock = 1000
+    const { feed, edits } = makeFeed(() => clock)
+    clock = 1000
+    await feed.update('w', 'chat', runningView('background job', 'doing work', 1000))
+    await drain()
+    clock = 5000
+    // Authoritative sweep / TTL backstop: no onFinish ever arrived.
+    await feed.terminate('w')
+    await drain()
+
+    const last = edits[edits.length - 1].text
+    expect(last, 'reaped worker must NOT read as done').not.toMatch(/\bdone\b/)
+    expect(last, 'reaped worker reads the truthful incomplete terminal').toContain('incomplete')
+    expect(feed.size).toBe(0)
+  })
+
+  it('a genuinely finished worker still renders `done` with its result', async () => {
+    let clock = 1000
+    const { feed, edits } = makeFeed(() => clock)
+    await feed.update('w', 'chat', runningView('background job', 'doing work', 1000))
+    await drain()
+    clock = 2000
+    await feed.finish('w', {
+      description: 'background job',
+      lastTool: null,
+      toolCount: 5,
+      latestSummary: 'the delivered result paragraph',
+      elapsedMs: 2000,
+      state: 'done',
+    })
+    await drain()
+    const last = edits[edits.length - 1].text
+    expect(last).toContain('done')
+    expect(last).toContain('the delivered result paragraph')
+    expect(last).not.toContain('incomplete')
+  })
+
+  it('renderWorkerActivity renders the `incomplete` state as a finished card without a fabricated result', () => {
+    const card = renderWorkerActivity({
+      description: 'background job',
+      lastTool: null,
+      toolCount: 3,
+      latestSummary: '', // reaped: no result text
+      elapsedMs: 4000,
+      state: 'incomplete',
+    })
+    expect(card).toContain('incomplete')
+    expect(card).not.toMatch(/\bdone\b/)
+    // No fabricated result paragraph (latestSummary empty) → no ✅ result block.
+    expect(card).not.toContain('✅')
+  })
+
+  it('renderWorkerActivity NEVER renders a result/⚠️ block for `incomplete`, even with a non-empty latestSummary (deterministic guard, not caller-discipline)', () => {
+    // Latent-trap regression guard: the live call site (terminateWorker) always
+    // passes latestSummary:'' for a reaped worker, but a future/direct caller
+    // could pass stray text. The truthful-no-result invariant must be enforced
+    // in the renderer — an `incomplete` worker produced no result, so it must
+    // never fabricate a ⚠️-prefixed result paragraph regardless of the summary.
+    const card = renderWorkerActivity({
+      description: 'background job',
+      lastTool: null,
+      toolCount: 3,
+      latestSummary: 'this looks like a real result but the worker never finished',
+      elapsedMs: 4000,
+      state: 'incomplete',
+    })
+    expect(card).toContain('incomplete')
+    // The renderer maps a non-`done` finished result to the ⚠️ emoji; the guard
+    // must suppress that block entirely for `incomplete`.
+    expect(card).not.toContain('⚠️')
+    expect(card).not.toContain('this looks like a real result')
+  })
+})

package/telegram-plugin/tool-activity-summary.ts

@@ -170,8 +170,10 @@ export function clipNarrative(s: string): string {
  * `description` — italicised task description (optional)
  * `elapsedMs`   — wall-clock elapsed, rendered via `formatFeedElapsed`
  * `toolCount`   — labeled tool calls this turn
- * `state`       — 'running' | 'done' | 'failed' (controls the status line wording;
- *                 'failed' renders `failed · …` so a failed worker never reads as done)
+ * `state`       — 'running' | 'done' | 'failed' | 'incomplete' (controls the
+ *                 status line wording; 'failed'/'incomplete' render
+ *                 `failed · …` / `incomplete · …` so a failed or reaped worker
+ *                 never reads as done)
  *
  * Returns a two-element array of ready Telegram HTML lines (no trailing newline).
  */
@@ -181,7 +183,7 @@ export function renderActivityHeader(
   description: string,
   elapsedMs: number,
   toolCount: number,
-  state: 'running' | 'done' | 'failed',
+  state: 'running' | 'done' | 'failed' | 'incomplete',
   model?: string,
 ): [string, string] {
   const toolWord = toolCount === 1 ? 'tool' : 'tools'
@@ -283,7 +285,7 @@ export interface StatusCardHeader {
   description?: string
   elapsedMs: number
   toolCount: number
-  state: 'running' | 'done' | 'failed'
+  state: 'running' | 'done' | 'failed' | 'incomplete'
   /** Live model id (raw, e.g. `claude-opus-4-8`) — rendered as a short friendly
    *  tag on the metrics line via `formatModelLabel`. Omitted when unknown. */
   model?: string
@@ -582,6 +584,16 @@ export interface CombinedWorkerRow {
   toolCount: number
   /** The worker's latest step line (raw prose or friendly tool label). */
   currentStep: string
+  /**
+   * The worker's accumulated narrative history (oldest→newest, raw/unescaped),
+   * already deduped + rolling-window capped upstream (STATUS_ROLLING_LINES).
+   * When present + non-empty, the combined feed paints the worker's last-K
+   * lines as a `✓`/`→` step trail (prior steps struck, newest in-progress) —
+   * the same idiom as the single-worker card — with K set by the adaptive
+   * per-worker line budget. Absent/empty → falls back to the single
+   * `currentStep` line (back-compat for direct callers).
+   */
+  historyLines?: string[]
   /** Live model id (raw, e.g. `claude-opus-4-8`); omitted when unknown. */
   model?: string
 }
@@ -593,17 +605,53 @@ export interface CombinedWorkerFeedOpts {
   maxRows: number
 }
 
+/**
+ * Total per-worker BODY line budget for the combined feed — the sum, across all
+ * visible workers, of (one header line + that worker's history lines). The top
+ * `🛠 Workers · N running` line and the `+M more working…` spill are OUTSIDE
+ * this budget (fixed chrome). 13 is chosen so the card stays a compact glance,
+ * not a wall: at 2 workers it yields the full 5-line history each (2·1 header +
+ * 2·5 history = 12 ≤ 13), and it degrades to a single history line each by ~6
+ * workers — matching the pre-adaptive one-line-per-worker floor while never
+ * letting a 2–3 worker fan-out lose its narrative trail.
+ */
+const MAX_COMBINED_BODY_LINES = 13
+/** Each visible worker costs one header line before any history. */
+const PER_WORKER_HEADER_COST = 1
+
+/**
+ * Deterministic per-worker history depth for `w` visible workers:
+ *   clamp( floor( (BUDGET − headerCost·w) / w ), 1, STATUS_ROLLING_LINES )
+ * So 2 workers → 5 lines each, 3 → 3, 4 → 2, ≥6 → 1 (today's single-line floor
+ * is the graceful-degradation floor, never below it). Pure function of the
+ * visible worker count — no model input, consistent with deterministic controls.
+ */
+export function combinedHistoryDepth(w: number): number {
+  if (w <= 0) return 1
+  const raw = Math.floor((MAX_COMBINED_BODY_LINES - PER_WORKER_HEADER_COST * w) / w)
+  return Math.max(1, Math.min(STATUS_ROLLING_LINES, raw))
+}
+
 /**
  * Render N≥1 live workers into ONE combined feed body (ready Telegram
  * markdown; callers send verbatim — do NOT re-escape). Layout:
  *
  *   🛠 **Workers** · _N running_
  *   **{desc1}** _· {elapsed} · {n} tools_
- *   → _{step1}_
+ *   ~~_✓ {earlier step}_~~
+ *   **→ {newest step}**
  *   **{desc2}** _· {elapsed} · {n} tools_
- *   → _{step2}_
+ *   **→ {newest step}**
  *   _+M more working…_
  *
+ * ADAPTIVE DENSITY: each visible worker renders its last-K narrative lines as a
+ * `✓`/`→` trail (prior steps struck, newest bold in-progress) — the single-
+ * worker card's idiom — where K = `combinedHistoryDepth(visibleCount)` splits a
+ * fixed body-line budget across the running workers. So 2 workers each show
+ * their full recent history and a 6-way fan-out degrades to one line each, the
+ * card staying bounded regardless of fan-out. When a worker has no history yet
+ * it falls back to a single `→ starting…`/currentStep line.
+ *
  * Pure. Rows are rendered in the order supplied (the manager passes them
  * dispatch-order, oldest first). `maxRows` caps the visible rows; the hidden
  * remainder collapses to a single `+M more working…` line. A total-budget
@@ -618,29 +666,43 @@ export function renderCombinedWorkerFeed(
   if (rows.length === 0) return null
   const maxRows = Math.max(1, Math.floor(opts.maxRows))
 
-  const rowLines = (r: CombinedWorkerRow): [string, string] => {
+  const rowHeader = (r: CombinedWorkerRow): string => {
     const desc = escapeMarkdown(
       truncate(stripMarkdown(r.description).replace(/\s+/g, ' ').trim() || 'background task', COMBINED_ROW_DESC_MAX),
     )
     const toolWord = r.toolCount === 1 ? 'tool' : 'tools'
     const modelLabel = formatModelLabel(r.model)
     const modelPart = modelLabel != null ? ` · ${escapeMarkdown(modelLabel)}` : ''
-    const header = `**${desc}** _· ${formatFeedElapsed(r.elapsedMs)} · ${r.toolCount} ${toolWord}${modelPart}_`
-    const stepClean = stripMarkdown(r.currentStep).replace(/\s+/g, ' ').trim()
-    const step =
-      stepClean.length > 0
-        ? `→ _${escapeMarkdown(truncate(stepClean, STATUS_LINE_MAX))}_`
-        : `→ _starting…_`
-    return [header, step]
+    return `**${desc}** _· ${formatFeedElapsed(r.elapsedMs)} · ${r.toolCount} ${toolWord}${modelPart}_`
+  }
+
+  // Raw (unescaped) history for a worker, oldest→newest, empty lines stripped.
+  // Falls back to the single currentStep when no history was supplied.
+  const rowHistory = (r: CombinedWorkerRow): string[] => {
+    const src = r.historyLines != null && r.historyLines.length > 0 ? r.historyLines : [r.currentStep]
+    return src.filter((s) => s != null && stripMarkdown(s).replace(/\s+/g, ' ').trim().length > 0)
   }
 
   const compose = (visibleCount: number): string => {
     const shown = rows.slice(0, visibleCount)
     const hidden = rows.length - shown.length
+    // Adaptive depth: split the fixed body-line budget across the VISIBLE
+    // workers so the card stays bounded regardless of fan-out.
+    const depth = combinedHistoryDepth(shown.length)
     const out: string[] = [`🛠 **Workers** · _${rows.length} running_`]
     for (const r of shown) {
-      const [h, s] = rowLines(r)
-      out.push(h, s)
+      out.push(rowHeader(r))
+      const hist = rowHistory(r)
+      if (hist.length === 0) {
+        out.push('→ _starting…_')
+        continue
+      }
+      // Paint the last-K history lines with the SAME `✓`/`→` idiom as the
+      // single-worker card: escape each raw line through the shared per-line
+      // pipeline (escapeStepLine), then renderStepFeed strikes the prior steps
+      // and bolds the newest in-progress step.
+      const esc = hist.slice(-depth).map(escapeStepLine)
+      renderStepFeed(out, esc, false)
     }
     if (hidden > 0) out.push(`_+${hidden} more working…_`)
     return stackCardLines(out)

package/telegram-plugin/turn-flush-safety.ts

@@ -199,7 +199,8 @@ export function decideTurnFlush(input: FlushDecisionInput): FlushDecision {
   // render as an undifferentiated wall-of-text. `\n\n` is the GFM paragraph
   // separator; the gateway send path then wedges visible spacers into those
   // gaps via addParagraphSpacers (mirroring the reply path, #2692) so the
-  // paragraphs render with real separation.
+  // paragraphs render with real separation (the rich GFM renderer otherwise
+  // shows a bare `\n\n` gap TIGHT).
   //
   // The silent-marker guards below are unaffected by this change:
   // isSilentFlushMarker length-guards the whole joined string; the composite /