switchroom 0.16.46 → 0.17.0

package/telegram-plugin/tests/subagent-nested-dispatch.test.ts

@@ -0,0 +1,209 @@
+/**
+ * Nested (depth-2+) sub-agent keying — registry primitives.
+ *
+ * Pins the three mechanisms that fix the "nested worker card frozen on
+ * starting…" class:
+ *   1. `recordNestedSubagentDispatch` — the watcher records/repairs a nested
+ *      dispatch row from the PARENT worker's JSONL (the authoritative
+ *      dispatch record), because the PreToolUse hook cannot attribute it
+ *      (turn-active.json is gone once the main turn ends) and can lose the
+ *      write entirely under concurrent nested dispatch.
+ *   2. `resolveSubagentOriginTurnKey` — transitive origin resolution via the
+ *      `parent_agent_id` chain, so a nested worker's card + handback route to
+ *      the originating chat/topic instead of the owner DM.
+ *   3. `backfillJsonlAgentId` — inherits `parent_turn_key` from the nested-
+ *      parent chain BEFORE falling back to the (never-correct-for-nested)
+ *      turns time-window match.
+ *
+ * bun:sqlite — run under Bun:
+ *   bun test telegram-plugin/tests/subagent-nested-dispatch.test.ts
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'bun:test'
+import { mkdtempSync, rmSync, writeFileSync } from 'fs'
+import { tmpdir } from 'os'
+import { join } from 'path'
+import { openTurnsDbInMemory } from '../registry/turns-schema.js'
+import {
+  applySubagentsSchema,
+  recordNestedSubagentDispatch,
+  resolveSubagentOriginTurnKey,
+  getSubagent,
+} from '../registry/subagents-schema.js'
+import { backfillJsonlAgentId } from '../subagent-watcher.js'
+
+type Db = ReturnType<typeof openTurnsDbInMemory>
+
+let tempDir: string
+let db: Db
+
+beforeEach(() => {
+  tempDir = mkdtempSync(join(tmpdir(), 'sub-nested-'))
+  db = openTurnsDbInMemory()
+  applySubagentsSchema(db)
+})
+
+afterEach(() => {
+  try { db.close() } catch { /* ignore */ }
+  try { rmSync(tempDir, { recursive: true, force: true }) } catch { /* ignore */ }
+})
+
+function insertTurn(turnKey: string, chatId: string, startedAt: number, endedAt: number | null) {
+  db.prepare(`
+    INSERT INTO turns (turn_key, chat_id, thread_id, started_at, ended_at, created_at, updated_at)
+    VALUES (?, ?, NULL, ?, ?, ?, ?)
+  `).run(turnKey, chatId, startedAt, endedAt, startedAt, startedAt)
+}
+
+function insertSub(args: {
+  id: string
+  parentTurnKey?: string | null
+  jsonlAgentId?: string | null
+  parentAgentId?: string | null
+  background?: boolean
+  description?: string | null
+  startedAt?: number
+}) {
+  db.prepare(`
+    INSERT INTO subagents
+      (id, parent_session_id, parent_turn_key, agent_type, description,
+       background, started_at, last_activity_at, status, jsonl_agent_id, parent_agent_id)
+    VALUES (?, 'sess-1', ?, 'worker', ?, ?, ?, ?, 'running', ?, ?)
+  `).run(
+    args.id,
+    args.parentTurnKey ?? null,
+    args.description ?? null,
+    args.background ? 1 : 0,
+    args.startedAt ?? 1000,
+    args.startedAt ?? 1000,
+    args.jsonlAgentId ?? null,
+    args.parentAgentId ?? null,
+  )
+}
+
+describe('recordNestedSubagentDispatch', () => {
+  it('creates the row when the hook lost the write (missing-row nested worker)', () => {
+    // Depth-1 parent: background worker, attributed at main-turn dispatch.
+    insertSub({ id: 'toolu_parent', parentTurnKey: '8248:_:1', jsonlAgentId: 'parent01', background: true })
+
+    recordNestedSubagentDispatch(db, {
+      toolUseId: 'toolu_child',
+      parentJsonlAgentId: 'parent01',
+      agentType: 'general-purpose',
+      description: 'nested probe',
+      background: false,
+      now: 5000,
+    })
+
+    const child = getSubagent(db, 'toolu_child')
+    expect(child).not.toBeNull()
+    expect(child?.parent_agent_id).toBe('parent01')
+    // Transitively inherited from the depth-1 row at record time.
+    expect(child?.parent_turn_key).toBe('8248:_:1')
+    expect(child?.description).toBe('nested probe')
+    expect(child?.status).toBe('running')
+  })
+
+  it('repairs a hook-inserted row: stamps parent_agent_id + inherits NULL parent_turn_key', () => {
+    insertSub({ id: 'toolu_parent', parentTurnKey: 'turn-A', jsonlAgentId: 'parent01', background: true })
+    // The hook DID land the row, but with parent_turn_key NULL (marker gone)
+    // — the exact live-incident shape (sibling a18c6003… had an empty key).
+    insertSub({ id: 'toolu_child', parentTurnKey: null, description: 'hook desc' })
+
+    recordNestedSubagentDispatch(db, {
+      toolUseId: 'toolu_child',
+      parentJsonlAgentId: 'parent01',
+      description: 'watcher desc',
+      background: true,
+      now: 6000,
+    })
+
+    const child = getSubagent(db, 'toolu_child')
+    expect(child?.parent_agent_id).toBe('parent01')
+    expect(child?.parent_turn_key).toBe('turn-A')
+    // INSERT OR IGNORE — the hook row's own fields are preserved.
+    expect(child?.description).toBe('hook desc')
+  })
+
+  it('is idempotent and never overwrites an existing parent_turn_key', () => {
+    insertSub({ id: 'toolu_parent', parentTurnKey: 'turn-A', jsonlAgentId: 'parent01', background: true })
+    insertSub({ id: 'toolu_child', parentTurnKey: 'turn-REAL' })
+
+    recordNestedSubagentDispatch(db, {
+      toolUseId: 'toolu_child', parentJsonlAgentId: 'parent01', background: false, now: 1,
+    })
+    recordNestedSubagentDispatch(db, {
+      toolUseId: 'toolu_child', parentJsonlAgentId: 'parent01', background: false, now: 2,
+    })
+
+    const child = getSubagent(db, 'toolu_child')
+    expect(child?.parent_turn_key).toBe('turn-REAL')
+    expect(child?.parent_agent_id).toBe('parent01')
+  })
+})
+
+describe('resolveSubagentOriginTurnKey — transitive origin walk', () => {
+  it('depth-1: returns the row own parent_turn_key', () => {
+    insertSub({ id: 't1', parentTurnKey: 'turn-A', jsonlAgentId: 'a1' })
+    expect(resolveSubagentOriginTurnKey(db, 'a1')).toBe('turn-A')
+  })
+
+  it('depth-2: NULL own key resolves via the parent chain', () => {
+    insertSub({ id: 't1', parentTurnKey: 'turn-A', jsonlAgentId: 'a1' })
+    insertSub({ id: 't2', parentTurnKey: null, jsonlAgentId: 'a2', parentAgentId: 'a1' })
+    expect(resolveSubagentOriginTurnKey(db, 'a2')).toBe('turn-A')
+  })
+
+  it('depth-3: walks multiple hops', () => {
+    insertSub({ id: 't1', parentTurnKey: 'turn-A', jsonlAgentId: 'a1' })
+    insertSub({ id: 't2', parentTurnKey: null, jsonlAgentId: 'a2', parentAgentId: 'a1' })
+    insertSub({ id: 't3', parentTurnKey: null, jsonlAgentId: 'a3', parentAgentId: 'a2' })
+    expect(resolveSubagentOriginTurnKey(db, 'a3')).toBe('turn-A')
+  })
+
+  it('cycle-safe: a corrupt self/loop chain returns null instead of hanging', () => {
+    insertSub({ id: 't1', parentTurnKey: null, jsonlAgentId: 'a1', parentAgentId: 'a2' })
+    insertSub({ id: 't2', parentTurnKey: null, jsonlAgentId: 'a2', parentAgentId: 'a1' })
+    expect(resolveSubagentOriginTurnKey(db, 'a1')).toBeNull()
+  })
+
+  it('missing row / unattributed chain returns null (caller keeps DM fallback)', () => {
+    expect(resolveSubagentOriginTurnKey(db, 'nope')).toBeNull()
+    insertSub({ id: 't1', parentTurnKey: null, jsonlAgentId: 'a1' })
+    expect(resolveSubagentOriginTurnKey(db, 'a1')).toBeNull()
+  })
+})
+
+describe('backfillJsonlAgentId — nested-parent inheritance beats the window match', () => {
+  function writeMeta(stem: string, toolUseId: string): string {
+    const jsonlPath = join(tempDir, `agent-${stem}.jsonl`)
+    writeFileSync(join(tempDir, `agent-${stem}.meta.json`), JSON.stringify({
+      agentType: 'general-purpose', description: 'nested probe', toolUseId,
+    }))
+    return jsonlPath
+  }
+
+  it('inherits the ancestor turn key when the dispatch happened AFTER the main turn ended', () => {
+    // The originating turn ended at t=2000; an unrelated turn is open at
+    // child-dispatch time (t=5000) — the window match would MIS-attribute.
+    insertTurn('turn-ORIGIN', '8248', 1000, 2000)
+    insertTurn('turn-OTHER', '9999', 4000, null)
+    insertSub({ id: 'toolu_parent', parentTurnKey: 'turn-ORIGIN', jsonlAgentId: 'parent01', background: true })
+    // Watcher-recorded nested row (parent_agent_id set, key inherited=NULL
+    // here to force the backfill path to resolve it).
+    db.prepare(`
+      INSERT INTO subagents
+        (id, parent_session_id, parent_turn_key, agent_type, description,
+         background, started_at, last_activity_at, status, jsonl_agent_id, parent_agent_id)
+      VALUES ('toolu_child', NULL, NULL, 'general-purpose', 'nested probe', 0, 5000, 5000, 'running', NULL, 'parent01')
+    `).run()
+
+    const jsonlPath = writeMeta('child01', 'toolu_child')
+    backfillJsonlAgentId(db, jsonlPath, 'child01')
+
+    const child = getSubagent(db, 'toolu_child')
+    expect(child?.jsonl_agent_id).toBe('child01')
+    // Inherited from the parent chain — NOT 'turn-OTHER' from the open window.
+    expect(child?.parent_turn_key).toBe('turn-ORIGIN')
+  })
+})

package/telegram-plugin/tests/subagent-tracker-hooks.test.ts

@@ -563,3 +563,40 @@ describe('agent-dir resolution (RFC §Bug 2)', () => {
     }
   })
 })
+
+// ---------------------------------------------------------------------------
+// Concurrent nested dispatch — row-creation reliability (unified cards)
+// ---------------------------------------------------------------------------
+
+describe('pretool — concurrent dispatch reliability', () => {
+  it('N hook processes writing the same registry.db concurrently all land their rows', async () => {
+    // The live-incident failure mode: several sub-agents dispatch at once
+    // (a depth-1 worker fanning out nested workers), the hook processes
+    // contend on registry.db, and a loser's INSERT vanished with
+    // SQLITE_BUSY → 0 rows → the worker's card froze on "starting…".
+    // The busy_timeout arming + this pin keep that from regressing.
+    const N = 8
+    const { spawn } = require('child_process') as typeof import('child_process')
+    const runs = Array.from({ length: N }, (_, i) => new Promise<number>((resolve) => {
+      const child = spawn(process.execPath, [PRETOOL_SCRIPT], {
+        env: { ...process.env, SWITCHROOM_AGENT_DIR: agentDir },
+        stdio: ['pipe', 'ignore', 'inherit'],
+      })
+      child.on('close', (code: number | null) => resolve(code ?? -1))
+      child.stdin!.end(JSON.stringify({
+        session_id: 'sess-conc',
+        tool_name: 'Task',
+        tool_use_id: `toolu_conc_${i}`,
+        tool_input: { description: `concurrent worker ${i}`, run_in_background: true },
+      }))
+    }))
+    const codes = await Promise.all(runs)
+    expect(codes.every((c) => c === 0)).toBe(true)
+
+    const db = openDb()
+    const rows = db.prepare(
+      "SELECT id FROM subagents WHERE id LIKE 'toolu_conc_%' ORDER BY id",
+    ).all() as Array<{ id: string }>
+    expect(rows.length).toBe(N)
+  }, 30_000)
+})

package/telegram-plugin/tests/subagent-watcher-boot-promotion-replay.test.ts

@@ -0,0 +1,167 @@
+/**
+ * Boot-promotion / onProgress gate-ordering regression (unified progress
+ * cards — the frozen-"starting…" contributor in registerAgent).
+ *
+ * Pre-fix sequence for a worker file that is IN-FLIGHT at boot:
+ *   1. registerAgent creates the entry with `historical = true`,
+ *   2. the initial readSubTail runs — every onProgress cue is suppressed by
+ *      the `!entry.historical` guard — and leaves the cursor at EOF,
+ *   3. THEN the promotion block flips `historical = false`.
+ * Result: the promoted live worker's existing activity never fires
+ * onProgress, so its card (painted later by the heartbeat) shows a bare
+ * "starting…" stub, and for a quiet worker no later tick ever repairs it.
+ *
+ * The fix re-reads the tail from byte 0 AFTER promotion (resetting
+ * toolCount/lastTool so nothing double-counts), so the replayed events both
+ * rebuild the entry and fire onProgress. This test pins that.
+ */
+
+import { describe, it, expect, vi } from 'vitest'
+import { startSubagentWatcher } from '../subagent-watcher.js'
+import * as fs from 'fs'
+
+function buildJSONL(...lines: object[]): string {
+  return lines.map((l) => JSON.stringify(l)).join('\n') + '\n'
+}
+
+describe('boot promotion — in-flight worker replays its activity through onProgress', () => {
+  it('fires onProgress for pre-existing tool activity after promotion (not suppressed)', () => {
+    const agentId = 'inflight-at-boot-01'
+    const agentDir = '/home/user/.switchroom/agents/myagent'
+    const projectsRoot = `${agentDir}/.claude/projects`
+    const projectDir = `${projectsRoot}/mock-cwd`
+    const sessionDir = `${projectDir}/sess`
+    const subagentsDir = `${sessionDir}/subagents`
+    const jsonlPath = `${subagentsDir}/agent-${agentId}.jsonl`
+
+    let currentTime = 100_000
+    // The file EXISTS AT BOOT with real in-flight activity: a prompt and two
+    // tool steps, still running (no turn_end). mtime is fresh (30s ago) so
+    // the freshness gate promotes it.
+    const content = Buffer.from(buildJSONL(
+      { type: 'user', message: { content: [{ type: 'text', text: 'long research task' }] } },
+      { type: 'assistant', message: { content: [{ type: 'tool_use', id: 't1', name: 'Read', input: { file_path: '/repo/a.ts' } }] } },
+      { type: 'assistant', message: { content: [{ type: 'tool_use', id: 't2', name: 'Bash', input: { command: 'npm test' } }] } },
+    ), 'utf-8')
+
+    let lastOpened: string | null = null
+    const mockFs = {
+      existsSync: ((p: fs.PathLike) => {
+        const ps = String(p)
+        return ps === projectsRoot || ps === projectDir || ps === sessionDir || ps === subagentsDir || ps === jsonlPath
+      }) 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 [`agent-${agentId}.jsonl`]
+        return []
+      }) as unknown as typeof fs.readdirSync,
+      statSync: (() => ({ size: content.length, mtimeMs: currentTime - 30_000 }) as fs.Stats) as typeof fs.statSync,
+      openSync: ((p: fs.PathLike) => { 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 (lastOpened !== jsonlPath) return 0
+        const src = 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,
+    }
+
+    const progressCalls: Array<{ agentId: string; progressLine?: string; toolCount: number }> = []
+    const watcher = startSubagentWatcher({
+      agentDir,
+      fs: mockFs,
+      now: () => currentTime,
+      setInterval: () => ({ ref: 0 }),
+      clearInterval: () => {},
+      setTimeout: () => ({ ref: 0 }),
+      clearTimeout: () => {},
+      onProgress: ({ agentId: id, progressLine, toolCount }) => {
+        progressCalls.push({ agentId: id, progressLine, toolCount })
+      },
+    })
+
+    const entry = watcher.getRegistry().get(agentId)
+    expect(entry).toBeDefined()
+    // Promoted live (fresh mtime, still running).
+    expect(entry?.historical).toBe(false)
+    // Replay rebuilt the entry WITHOUT double-counting the initial read.
+    expect(entry?.toolCount).toBe(2)
+    expect(entry?.lastTool?.name).toBe('Bash')
+    // THE regression pin: the replayed tool steps fired onProgress — pre-fix
+    // this was zero (suppressed by the historical gate, cursor left at EOF).
+    const mine = progressCalls.filter((c) => c.agentId === agentId)
+    expect(mine.length).toBeGreaterThanOrEqual(2)
+    expect(mine.some((c) => c.progressLine != null && c.progressLine.length > 0)).toBe(true)
+
+    watcher.stop()
+  })
+
+  it('a STALE running-at-boot file stays historical and fires no onProgress (no replay spam)', () => {
+    const agentId = 'stale-at-boot-01'
+    const agentDir = '/home/user/.switchroom/agents/myagent'
+    const projectsRoot = `${agentDir}/.claude/projects`
+    const projectDir = `${projectsRoot}/mock-cwd`
+    const sessionDir = `${projectDir}/sess`
+    const subagentsDir = `${sessionDir}/subagents`
+    const jsonlPath = `${subagentsDir}/agent-${agentId}.jsonl`
+
+    const currentTime = 100_000_000
+    const content = Buffer.from(buildJSONL(
+      { type: 'user', message: { content: [{ type: 'text', text: 'dead prior-session task' }] } },
+      { type: 'assistant', message: { content: [{ type: 'tool_use', id: 't1', name: 'Read', input: { file_path: '/x' } }] } },
+    ), 'utf-8')
+
+    let lastOpened: string | null = null
+    const mockFs = {
+      existsSync: ((p: fs.PathLike) => {
+        const ps = String(p)
+        return ps === projectsRoot || ps === projectDir || ps === sessionDir || ps === subagentsDir || ps === jsonlPath
+      }) 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 [`agent-${agentId}.jsonl`]
+        return []
+      }) as unknown as typeof fs.readdirSync,
+      // Last write DAYS ago — far past the 15-min freshness window.
+      statSync: (() => ({ size: content.length, mtimeMs: currentTime - 3 * 24 * 3600_000 }) as fs.Stats) as typeof fs.statSync,
+      openSync: ((p: fs.PathLike) => { 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 (lastOpened !== jsonlPath) return 0
+        const src = 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,
+    }
+
+    const progressCalls: string[] = []
+    const watcher = startSubagentWatcher({
+      agentDir,
+      fs: mockFs,
+      now: () => currentTime,
+      setInterval: () => ({ ref: 0 }),
+      clearInterval: () => {},
+      setTimeout: () => ({ ref: 0 }),
+      clearTimeout: () => {},
+      onProgress: ({ agentId: id }) => { progressCalls.push(id) },
+    })
+
+    const entry = watcher.getRegistry().get(agentId)
+    expect(entry?.historical).toBe(true)
+    expect(progressCalls.filter((id) => id === agentId)).toHaveLength(0)
+
+    watcher.stop()
+  })
+})

package/telegram-plugin/tests/subagent-watcher-env-thresholds.test.ts

@@ -26,9 +26,17 @@ function subAgentUserMsg(promptText: string) {
 function makeHarness(opts: {
   agentId?: string
   configStallThresholdMs?: number
+  configSilentSynthStallThresholdMs?: number
   configSilentStallTerminalMs?: number
+  initialContent?: string
 } = {}) {
-  const { agentId = 'env-thresh-agent', configStallThresholdMs, configSilentStallTerminalMs } = opts
+  const {
+    agentId = 'env-thresh-agent',
+    configStallThresholdMs,
+    configSilentSynthStallThresholdMs,
+    configSilentStallTerminalMs,
+    initialContent,
+  } = opts
 
   let currentTime = 1000
   const stallCalls: Array<{ idleMs: number }> = []
@@ -43,7 +51,7 @@ function makeHarness(opts: {
   const subagentsDir = `${sessionDir}/subagents`
   const jsonlPath = `${subagentsDir}/agent-${agentId}.jsonl`
   const fileContents = new Map<string, Buffer>()
-  fileContents.set(jsonlPath, Buffer.from(buildJSONL(subAgentUserMsg('bg task')), 'utf-8'))
+  fileContents.set(jsonlPath, Buffer.from(initialContent ?? buildJSONL(subAgentUserMsg('bg task')), 'utf-8'))
 
   let lastOpenedPath: string | null = null
   const mockFs = {
@@ -81,7 +89,7 @@ function makeHarness(opts: {
   const watcher = startSubagentWatcher({
     agentDir,
     stallThresholdMs: configStallThresholdMs,
-    silentSynthesisStallThresholdMs: configStallThresholdMs,
+    silentSynthesisStallThresholdMs: configSilentSynthStallThresholdMs ?? configStallThresholdMs,
     silentStallTerminalMs: configSilentStallTerminalMs,
     rescanMs: 500,
     onStall: (_id, idleMs) => stallCalls.push({ idleMs }),
@@ -211,6 +219,41 @@ describe('subagent-watcher env-var threshold overrides', () => {
     expect(h.stallTerminalCalls).toHaveLength(0)
   })
 
+  it('a Bash-in-flight worker skips the tight stall threshold but still releases the terminal gate', () => {
+    // End-to-end of the long-runner suppression under compressed env-tuned
+    // windows: a worker mid-`Bash` (a) is NOT flagged at the tight active-loop
+    // threshold, (b) IS eventually flagged at the widened silent-synthesis
+    // window, and (c) the pass-2 terminal synthesis STILL fires the fixed
+    // window after that — the load-bearing completion-gate release is intact.
+    const h = makeHarness({
+      agentId: 'env-thresh-bash',
+      configStallThresholdMs: 1000, // tight active-loop threshold
+      configSilentSynthStallThresholdMs: 10_000, // widened long-runner window
+      configSilentStallTerminalMs: 5000, // compressed terminal window
+      initialContent: buildJSONL(
+        subAgentUserMsg('bg task'),
+        { type: 'assistant', message: { content: [{ type: 'tool_use', id: 'tool-B', name: 'Bash', input: { command: 'npm test' } }] } },
+      ),
+    })
+    h.advance(500) // register + tail → toolCount=1, lastTool=Bash
+    h.unmarkHistorical()
+
+    // 5s idle — well past the 1s active-loop threshold, but a Bash worker uses
+    // the 10s silent-synthesis window, so NO false stall.
+    h.advance(5_000)
+    expect(h.stallCalls).toHaveLength(0)
+
+    // Cross the 10s window → the stall IS flagged (pass-2 becomes reachable).
+    h.advance(6_000)
+    expect(h.stallCalls).toHaveLength(1)
+    expect(h.stallTerminalCalls).toHaveLength(0)
+
+    // 5s post-stall → terminal synthesis releases the deferred-completion gate.
+    h.advance(6_000)
+    expect(h.stallTerminalCalls).toHaveLength(1)
+    expect(h.finishCalls).toHaveLength(1)
+  })
+
   it('zero env value falls through to default (zero is not "fire immediately")', () => {
     process.env.SWITCHROOM_SUBAGENT_STALL_TERMINAL_MS = '0'
     const h = makeHarness({ configStallThresholdMs: 1000 })

package/telegram-plugin/tests/subagent-watcher-stall-notification.test.ts

@@ -311,6 +311,76 @@ describe('subagent-watcher onStall callback (Option C, issue #393)', () => {
     expect(stallCalls).toHaveLength(1)
   })
 
+  // Bash-in-flight suppression: a worker whose LAST observed tool is a known
+  // long-runner (`Bash` — a build, `npm test`, a long curl) legitimately goes
+  // quiet in the JSONL for minutes while the command runs. Pre-fix the tight
+  // 60s active-loop threshold misfired on exactly this population, producing
+  // the false "stall detected (idle 60s)" the operator hit while a background
+  // worker was mid-Bash. The watcher now widens the threshold for such workers
+  // to the silent-synthesis window.
+  it('does NOT trip stall at 60s when the last tool is Bash (long-runner suppression)', () => {
+    const agentId = 'stall-bash-01'
+    const { stallCalls, advance, watcher } = makeStallHarness({
+      agentId,
+      stallThresholdMs: 60_000,
+      silentSynthesisStallThresholdMs: 300_000, // 5min
+      rescanMs: 500,
+      initialContent: buildJSONL(
+        subAgentUserMsg('background task'),
+        { type: 'assistant', message: { content: [{ type: 'tool_use', id: 'tool-B', name: 'Bash', input: { command: 'npm test' } }] } },
+      ),
+    })
+    advance(500) // register + tail read → toolCount=1, lastTool=Bash
+    const entry = watcher.getRegistry().get(agentId)
+    if (entry) entry.historical = false
+    expect(entry?.lastTool?.name).toBe('Bash')
+    advance(120_000) // 2min idle — far past 60s but under the silent-synth window
+    expect(stallCalls).toHaveLength(0) // NOT falsely stalled mid-Bash
+  })
+
+  it('DOES trip stall for a Bash worker once past the silent-synthesis window (pass-2 gate still reachable)', () => {
+    const agentId = 'stall-bash-02'
+    const { stallCalls, advance, watcher } = makeStallHarness({
+      agentId,
+      stallThresholdMs: 60_000,
+      silentSynthesisStallThresholdMs: 300_000, // 5min
+      rescanMs: 500,
+      initialContent: buildJSONL(
+        subAgentUserMsg('background task'),
+        { type: 'assistant', message: { content: [{ type: 'tool_use', id: 'tool-B', name: 'Bash', input: { command: 'sleep 999' } }] } },
+      ),
+    })
+    advance(500)
+    const entry = watcher.getRegistry().get(agentId)
+    if (entry) entry.historical = false
+    advance(120_000) // under the window — no stall yet
+    expect(stallCalls).toHaveLength(0)
+    advance(200_000) // total ~5min20s — past the silent-synth window → stall fires
+    expect(stallCalls).toHaveLength(1)
+    expect(stallCalls[0].agentId).toBe(agentId)
+  })
+
+  it('a non-long-runner last tool (Read) still trips at the tight 60s threshold', () => {
+    // Guard the suppression is scoped to long-runners only — a Read that goes
+    // quiet for 60s is genuinely stalled and must still flag.
+    const agentId = 'stall-read-01'
+    const { stallCalls, advance, watcher } = makeStallHarness({
+      agentId,
+      stallThresholdMs: 60_000,
+      silentSynthesisStallThresholdMs: 600_000, // way out — proves the 60s path is taken
+      rescanMs: 500,
+      initialContent: buildJSONL(
+        subAgentUserMsg('background task'),
+        { type: 'assistant', message: { content: [{ type: 'tool_use', id: 'tool-R', name: 'Read', input: { path: '/x' } }] } },
+      ),
+    })
+    advance(500)
+    const entry = watcher.getRegistry().get(agentId)
+    if (entry) entry.historical = false
+    advance(65_000) // 65s quiet after a Read → genuinely stalled
+    expect(stallCalls).toHaveLength(1)
+  })
+
   // Test 10: onStall is NOT called for sub-agents already done/failed
   it('does not call onStall for sub-agents in done/failed state', () => {
     const agentId = 'stall-test-10-done'

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

@@ -8,6 +8,8 @@ import {
   renderActivityFeedWithNested,
   renderActivityHeader,
   formatFeedElapsed,
+  formatStepSuffix,
+  STEP_TIMER_MIN_MS,
   type SessionActivityHeader,
 } from "../tool-activity-summary.js";
 import { STATUS_ROLLING_LINES, STATUS_LINE_MAX } from "../status-no-truncate.js";
@@ -782,6 +784,20 @@ describe("formatFeedElapsed — elapsed formatter", () => {
   });
 });
 
+describe("formatStepSuffix — per-step suffix with 10s gate", () => {
+  it("returns empty string while the step is younger than STEP_TIMER_MIN_MS", () => {
+    expect(formatStepSuffix(0)).toBe("");
+    expect(formatStepSuffix(9_999)).toBe("");
+    expect(formatStepSuffix(STEP_TIMER_MIN_MS - 1)).toBe("");
+  });
+
+  it("renders ` · <elapsed>` once the step reaches the gate", () => {
+    expect(formatStepSuffix(STEP_TIMER_MIN_MS)).toBe(" · 10s");
+    expect(formatStepSuffix(13_000)).toBe(" · 13s");
+    expect(formatStepSuffix(65_000)).toBe(" · 1m05s");
+  });
+});
+
 describe("renderActivityFeed — header param (main-session card fix)", () => {
   it("prepends the two-line header when header is supplied (running)", () => {
     const header: SessionActivityHeader = {

package/telegram-plugin/tests/tool-filter.test.ts

@@ -15,7 +15,6 @@ import {
 // A representative slice mirroring the real TOOL_SCHEMAS names.
 const SAMPLE: NamedTool[] = [
   { name: 'reply', description: 'r' },
-  { name: 'stream_reply', description: 's' },
   { name: 'get_recent_messages', description: 'g' },
   { name: 'react', description: 'k' },
   { name: 'edit_message', description: 'e' },
@@ -58,10 +57,9 @@ describe('buildEffectiveToolSchemas — per-tool deferral pins (B)', () => {
     }
   })
 
-  it('the reply path (reply/stream_reply) is ALWAYS pinned — never defers', () => {
+  it('the reply path (reply) is ALWAYS pinned — never defers', () => {
     const out = buildEffectiveToolSchemas(SAMPLE, { linearEnabled: false })
     expect(metaOf(out, 'reply')).toEqual({ 'anthropic/alwaysLoad': true })
-    expect(metaOf(out, 'stream_reply')).toEqual({ 'anthropic/alwaysLoad': true })
   })
 
   it('cold tools carry NO _meta (so they defer under tool-search)', () => {

package/telegram-plugin/tests/tool-label-pretool.test.ts

@@ -41,18 +41,15 @@ describe('computeLabel — never-null built-in fallthrough', () => {
 })
 
 describe('computeLabel — surface-tool suppression is key-agnostic', () => {
-  it('returns null for telegram reply/stream_reply under any registration key', () => {
+  it('returns null for telegram reply under any registration key', () => {
     // Standard switchroom-telegram key.
     expect(computeLabel('mcp__switchroom-telegram__reply', {})).toBeNull()
-    expect(computeLabel('mcp__switchroom-telegram__stream_reply', {})).toBeNull()
 
     // Legacy clerk-telegram key — same plugin, different registration name.
     expect(computeLabel('mcp__clerk-telegram__reply', {})).toBeNull()
-    expect(computeLabel('mcp__clerk-telegram__stream_reply', {})).toBeNull()
 
     // Hypothetical custom fork.
     expect(computeLabel('mcp__my-custom-telegram__reply', {})).toBeNull()
-    expect(computeLabel('mcp__my-custom-telegram__stream_reply', {})).toBeNull()
   })
 
   it('returns null for telegram react under any registration key', () => {