switchroom 0.7.15 → 0.10.0

package/telegram-plugin/tests/silent-end.test.ts

@@ -0,0 +1,206 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, readFileSync, existsSync, rmSync, writeFileSync, mkdirSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { execFileSync } from 'node:child_process'
+import {
+  writeSilentEndState,
+  clearSilentEndState,
+  readSilentEndState,
+} from '../silent-end.js'
+
+let stateDir: string
+const ORIG_ENV = process.env.TELEGRAM_STATE_DIR
+
+beforeEach(() => {
+  stateDir = mkdtempSync(join(tmpdir(), 'silent-end-test-'))
+  process.env.TELEGRAM_STATE_DIR = stateDir
+})
+
+afterEach(() => {
+  rmSync(stateDir, { recursive: true, force: true })
+  if (ORIG_ENV != null) process.env.TELEGRAM_STATE_DIR = ORIG_ENV
+  else delete process.env.TELEGRAM_STATE_DIR
+})
+
+describe('silent-end.ts — gateway state writer', () => {
+  it('writeSilentEndState creates the file with retryCount=0 on first write', () => {
+    writeSilentEndState({ chatId: '123', threadId: null, turnKey: '123:_' })
+    const state = readSilentEndState()
+    expect(state).not.toBeNull()
+    expect(state!.chatId).toBe('123')
+    expect(state!.threadId).toBeNull()
+    expect(state!.turnKey).toBe('123:_')
+    expect(state!.retryCount).toBe(0)
+    expect(typeof state!.timestamp).toBe('number')
+  })
+
+  it('writeSilentEndState inherits retryCount IFF the prior file matches the same turnKey', () => {
+    // Prior file at retryCount=1 for the same turn (Stop hook had already
+    // blocked once and re-incremented).
+    const path = join(stateDir, 'silent-end-pending.json')
+    writeFileSync(path, JSON.stringify({
+      chatId: '123', threadId: null, turnKey: '123:_', retryCount: 1, timestamp: 0,
+    }))
+    writeSilentEndState({ chatId: '123', threadId: null, turnKey: '123:_' })
+    expect(readSilentEndState()!.retryCount).toBe(1)
+  })
+
+  it('writeSilentEndState resets retryCount to 0 when turnKey differs', () => {
+    const path = join(stateDir, 'silent-end-pending.json')
+    writeFileSync(path, JSON.stringify({
+      chatId: '123', threadId: null, turnKey: '123:_', retryCount: 1, timestamp: 0,
+    }))
+    // Different turn — new silent-end, fresh counter.
+    writeSilentEndState({ chatId: '999', threadId: 42, turnKey: '999:42' })
+    const state = readSilentEndState()
+    expect(state!.turnKey).toBe('999:42')
+    expect(state!.retryCount).toBe(0)
+  })
+
+  it('writeSilentEndState falls back to ~/.claude/channels/telegram when TELEGRAM_STATE_DIR is unset', () => {
+    // Updated 2026-05-13 UAT overnight: discovered the writer used to
+    // silently no-op when the env var was unset, while the Stop hook
+    // (silent-end-interrupt-stop.mjs) and the gateway both fall back
+    // to `~/.claude/channels/telegram`. Mismatch meant the hook
+    // always read a missing file → silent-end recovery never engaged.
+    // The writer now applies the same fallback.
+    delete process.env.TELEGRAM_STATE_DIR
+    const fakeHome = mkdtempSync(join(tmpdir(), 'silent-end-fallback-home-'))
+    const origHome = process.env.HOME
+    process.env.HOME = fakeHome
+    try {
+      writeSilentEndState({ chatId: '123', threadId: null, turnKey: '123:_' })
+      const expected = join(fakeHome, '.claude', 'channels', 'telegram', 'silent-end-pending.json')
+      expect(existsSync(expected)).toBe(true)
+    } finally {
+      if (origHome != null) process.env.HOME = origHome
+      else delete process.env.HOME
+      rmSync(fakeHome, { recursive: true, force: true })
+    }
+  })
+
+  it('clearSilentEndState removes the file when turnKey matches', () => {
+    writeSilentEndState({ chatId: '123', threadId: null, turnKey: '123:_' })
+    expect(existsSync(join(stateDir, 'silent-end-pending.json'))).toBe(true)
+    clearSilentEndState('123:_')
+    expect(existsSync(join(stateDir, 'silent-end-pending.json'))).toBe(false)
+  })
+
+  it('clearSilentEndState leaves the file alone when turnKey does NOT match', () => {
+    writeSilentEndState({ chatId: '123', threadId: null, turnKey: '123:_' })
+    clearSilentEndState('different-turn')
+    expect(existsSync(join(stateDir, 'silent-end-pending.json'))).toBe(true)
+  })
+
+  it('clearSilentEndState is a no-op when no file exists', () => {
+    expect(() => clearSilentEndState('123:_')).not.toThrow()
+  })
+
+  it('clearSilentEndState is a no-op when TELEGRAM_STATE_DIR is unset', () => {
+    delete process.env.TELEGRAM_STATE_DIR
+    expect(() => clearSilentEndState('123:_')).not.toThrow()
+  })
+
+  it('writeSilentEndState handles corrupt prior file by resetting retryCount', () => {
+    const path = join(stateDir, 'silent-end-pending.json')
+    writeFileSync(path, 'not valid json {{{')
+    writeSilentEndState({ chatId: '123', threadId: null, turnKey: '123:_' })
+    expect(readSilentEndState()!.retryCount).toBe(0)
+  })
+
+  it('round-trip: write → read → clear', () => {
+    writeSilentEndState({ chatId: 'c', threadId: 7, turnKey: 'c:7' })
+    const state = readSilentEndState()
+    expect(state).toMatchObject({ chatId: 'c', threadId: 7, turnKey: 'c:7', retryCount: 0 })
+    clearSilentEndState('c:7')
+    expect(readSilentEndState()).toBeNull()
+  })
+})
+
+describe('silent-end-interrupt-stop hook — integration', () => {
+  const hookPath = join(__dirname, '..', 'hooks', 'silent-end-interrupt-stop.mjs')
+
+  function runHook(input: object): { exit: number; stdout: string; stderr: string } {
+    const { spawnSync } = require('node:child_process') as typeof import('node:child_process')
+    const r = spawnSync('node', [hookPath], {
+      input: JSON.stringify(input),
+      env: { ...process.env, TELEGRAM_STATE_DIR: stateDir },
+      encoding: 'utf8',
+      timeout: 5_000,
+    })
+    return { exit: r.status ?? 1, stdout: r.stdout ?? '', stderr: r.stderr ?? '' }
+  }
+
+  it('allows the stop when no state file exists (normal completion)', () => {
+    const r = runHook({
+      session_id: 's',
+      transcript_path: '/tmp/x.jsonl',
+      hook_event_name: 'Stop',
+    })
+    expect(r.exit).toBe(0)
+    expect(r.stdout.trim()).toBe('')
+  })
+
+  it('blocks the stop with decision:block when silent-end state exists at retryCount=0', () => {
+    writeSilentEndState({ chatId: 'c', threadId: null, turnKey: 'c:_' })
+    const r = runHook({
+      session_id: 's',
+      transcript_path: '/tmp/x.jsonl',
+      hook_event_name: 'Stop',
+    })
+    expect(r.exit).toBe(0)
+    const out = JSON.parse(r.stdout.trim())
+    expect(out.decision).toBe('block')
+    expect(out.reason).toContain('reply')
+    // retryCount must have been incremented to 1
+    expect(readSilentEndState()!.retryCount).toBe(1)
+  })
+
+  it('allows the stop when retryCount >= MAX_RETRIES (1)', () => {
+    const path = join(stateDir, 'silent-end-pending.json')
+    writeFileSync(path, JSON.stringify({
+      chatId: 'c', threadId: null, turnKey: 'c:_', retryCount: 1, timestamp: 0,
+    }))
+    const r = runHook({
+      session_id: 's',
+      transcript_path: '/tmp/x.jsonl',
+      hook_event_name: 'Stop',
+    })
+    expect(r.exit).toBe(0)
+    expect(r.stdout.trim()).toBe('')
+    expect(r.stderr).toContain('retry exhausted')
+  })
+
+  it('end-to-end: write silent-end → hook blocks → simulate reply → next stop allows', () => {
+    // 1. Turn ends silently — gateway writes state
+    writeSilentEndState({ chatId: 'c', threadId: null, turnKey: 'c:_' })
+
+    // 2. Stop hook fires, blocks, increments retryCount
+    const r1 = runHook({ session_id: 's', transcript_path: '/tmp/x.jsonl', hook_event_name: 'Stop' })
+    expect(JSON.parse(r1.stdout).decision).toBe('block')
+    expect(readSilentEndState()!.retryCount).toBe(1)
+
+    // 3. Re-prompted agent calls reply — gateway clears the file
+    clearSilentEndState('c:_')
+    expect(readSilentEndState()).toBeNull()
+
+    // 4. Next Stop allows cleanly (no state file)
+    const r2 = runHook({ session_id: 's', transcript_path: '/tmp/x.jsonl', hook_event_name: 'Stop' })
+    expect(r2.stdout.trim()).toBe('')
+  })
+
+  it('fails open on a corrupt state file', () => {
+    const path = join(stateDir, 'silent-end-pending.json')
+    mkdirSync(stateDir, { recursive: true })
+    writeFileSync(path, 'corrupt {{{', 'utf8')
+    const r = runHook({ session_id: 's', transcript_path: '/tmp/x.jsonl', hook_event_name: 'Stop' })
+    expect(r.exit).toBe(0)
+    expect(r.stdout.trim()).toBe('')
+  })
+
+  it('fails open on empty stdin', () => {
+    const r = runHook({}) // serialised as `{}` — but the hook also tolerates empty
+    expect(r.exit).toBe(0)
+  })
+})

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

@@ -211,3 +211,110 @@ describe('subagent-tracker-posttool', () => {
     expect(row?.status).toBe('failed')
   })
 })
+
+describe('agent-dir resolution (RFC §Bug 2)', () => {
+  // The hooks used to look only at SWITCHROOM_AGENT_DIR and then cwd.
+  // In production neither matched the path the gateway + watcher used,
+  // so rows were written to a registry.db nobody read. The fix adds
+  // TELEGRAM_STATE_DIR (the env var start.sh exports for every agent)
+  // as a middle lookup. These tests pin the precedence + the legacy
+  // fallback so a future refactor can't silently revert.
+
+  function runWith(scriptPath: string, event: object, env: Record<string, string | undefined>) {
+    const finalEnv: Record<string, string> = { ...process.env } as Record<string, string>
+    // Clear the inherited overrides; we want a clean baseline.
+    delete finalEnv.SWITCHROOM_AGENT_DIR
+    delete finalEnv.TELEGRAM_STATE_DIR
+    for (const [k, v] of Object.entries(env)) {
+      if (v === undefined) delete finalEnv[k]
+      else finalEnv[k] = v
+    }
+    return spawnSync(process.execPath, [scriptPath], {
+      input: JSON.stringify(event),
+      encoding: 'utf8',
+      env: finalEnv,
+      timeout: 15_000,
+    })
+  }
+
+  const baseEvent = {
+    session_id: 's',
+    tool_name: 'Agent',
+    tool_use_id: 'toolu_envtest1',
+    tool_input: { subagent_type: 'w', description: 'd', run_in_background: true },
+  }
+
+  it('pretool prefers SWITCHROOM_AGENT_DIR over TELEGRAM_STATE_DIR', () => {
+    const explicit = mkdtempSync(join(tmpdir(), 'agent-dir-explicit-'))
+    const stateDirParent = mkdtempSync(join(tmpdir(), 'state-dir-parent-'))
+    mkdirSync(join(explicit, 'telegram'), { recursive: true })
+    mkdirSync(join(stateDirParent, 'telegram'), { recursive: true })
+    try {
+      const result = runWith(PRETOOL_SCRIPT, baseEvent, {
+        SWITCHROOM_AGENT_DIR: explicit,
+        TELEGRAM_STATE_DIR: join(stateDirParent, 'telegram'),
+      })
+      expect(result.status).toBe(0)
+      // Row landed in the EXPLICIT location, not the state-dir-derived one.
+      const explicitDb = join(explicit, 'telegram', 'registry.db')
+      const stateDirDb = join(stateDirParent, 'telegram', 'registry.db')
+      expect(Bun.file(explicitDb).size).toBeGreaterThan(0)
+      expect(Bun.file(stateDirDb).size).toBe(0)
+    } finally {
+      try { rmSync(explicit, { recursive: true }) } catch { /* */ }
+      try { rmSync(stateDirParent, { recursive: true }) } catch { /* */ }
+    }
+  })
+
+  it('pretool derives agentDir from TELEGRAM_STATE_DIR when SWITCHROOM_AGENT_DIR is unset (the production path)', () => {
+    const stateDirParent = mkdtempSync(join(tmpdir(), 'state-dir-only-'))
+    mkdirSync(join(stateDirParent, 'telegram'), { recursive: true })
+    try {
+      const result = runWith(PRETOOL_SCRIPT, baseEvent, {
+        TELEGRAM_STATE_DIR: join(stateDirParent, 'telegram'),
+      })
+      expect(result.status).toBe(0)
+      const dbPath = join(stateDirParent, 'telegram', 'registry.db')
+      expect(Bun.file(dbPath).size).toBeGreaterThan(0)
+      // Row landed in the state-dir-derived location.
+      const { Database } = require('bun:sqlite') as { Database: new (p: string) => {
+        prepare(sql: string): { get(...params: unknown[]): unknown }
+      } }
+      const db = new Database(dbPath)
+      const row = db.prepare('SELECT id FROM subagents WHERE id = ?').get('toolu_envtest1') as
+        | { id: string } | undefined
+      expect(row?.id).toBe('toolu_envtest1')
+    } finally {
+      try { rmSync(stateDirParent, { recursive: true }) } catch { /* */ }
+    }
+  })
+
+  it('pretool ignores TELEGRAM_STATE_DIR that does NOT end in /telegram (defensive)', () => {
+    // If TELEGRAM_STATE_DIR ever drifts to a non-canonical shape, the
+    // hook should NOT silently use it — falling through to cwd is the
+    // safer behaviour (you'll notice the wrong location quickly).
+    const weirdDir = mkdtempSync(join(tmpdir(), 'state-dir-weird-'))
+    const cwdDir = mkdtempSync(join(tmpdir(), 'cwd-dir-'))
+    mkdirSync(join(cwdDir, 'telegram'), { recursive: true })
+    try {
+      const result = spawnSync(process.execPath, [PRETOOL_SCRIPT], {
+        input: JSON.stringify(baseEvent),
+        encoding: 'utf8',
+        cwd: cwdDir,
+        env: {
+          ...process.env,
+          SWITCHROOM_AGENT_DIR: undefined as unknown as string,
+          TELEGRAM_STATE_DIR: weirdDir, // does NOT end in /telegram
+        } as Record<string, string>,
+        timeout: 15_000,
+      })
+      expect(result.status).toBe(0)
+      // Fell through to cwd, NOT the weird TELEGRAM_STATE_DIR.
+      const cwdDb = join(cwdDir, 'telegram', 'registry.db')
+      expect(Bun.file(cwdDb).size).toBeGreaterThan(0)
+    } finally {
+      try { rmSync(weirdDir, { recursive: true }) } catch { /* */ }
+      try { rmSync(cwdDir, { recursive: true }) } catch { /* */ }
+    }
+  })
+})

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

@@ -0,0 +1,224 @@
+/**
+ * Env-var overrides for the watcher's threshold knobs
+ * (`stallThresholdMs`, `silentSynthesisStallThresholdMs`,
+ * `silentStallTerminalMs`). Used by the UAT harness to compress the
+ * stall+synth window so `bg-sub-agent-dispatch-dm.test.ts` can
+ * validate Bug 6's terminal-synthesis path inside its 120s timeout
+ * instead of waiting the production-tuned 6min.
+ *
+ * Resolution order: explicit config arg → env var → compile-time
+ * default. Invalid env values (0, negative, NaN, empty string) fall
+ * through to the default — we don't want a stray `=0` to silently
+ * disable stall detection in production.
+ */
+
+import { describe, it, expect, vi, beforeEach, afterEach } 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'
+}
+function subAgentUserMsg(promptText: string) {
+  return { type: 'user', message: { content: [{ type: 'text', text: promptText }] } }
+}
+
+function makeHarness(opts: {
+  agentId?: string
+  configStallThresholdMs?: number
+  configSilentStallTerminalMs?: number
+} = {}) {
+  const { agentId = 'env-thresh-agent', configStallThresholdMs, configSilentStallTerminalMs } = opts
+
+  let currentTime = 1000
+  const stallCalls: Array<{ idleMs: number }> = []
+  const stallTerminalCalls: Array<{ agentId: string }> = []
+  const finishCalls: Array<{ outcome: string }> = []
+
+  const agentDir = '/home/user/.switchroom/agents/myagent'
+  const sessionId = 'mock-session'
+  const projectsRoot = `${agentDir}/.claude/projects`
+  const projectDir = `${projectsRoot}/mock-cwd`
+  const sessionDir = `${projectDir}/${sessionId}`
+  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'))
+
+  let lastOpenedPath: string | null = null
+  const mockFs = {
+    existsSync: ((p: fs.PathLike) => {
+      const ps = String(p)
+      if (ps === projectsRoot || ps === projectDir || ps === sessionDir || ps === subagentsDir) return true
+      return fileContents.has(ps)
+    }) as typeof fs.existsSync,
+    readdirSync: ((p: fs.PathLike) => {
+      const ps = String(p)
+      if (ps === projectsRoot) return ['mock-cwd']
+      if (ps === projectDir) return [sessionId]
+      if (ps === sessionDir) return ['subagents']
+      if (ps === subagentsDir) return [`agent-${agentId}.jsonl`]
+      return []
+    }) as unknown as typeof fs.readdirSync,
+    statSync: ((p: fs.PathLike) => ({ size: fileContents.get(String(p))?.length ?? 0 }) as fs.Stats) as typeof fs.statSync,
+    openSync: ((p: fs.PathLike) => { lastOpenedPath = String(p); return 42 }) as unknown as typeof fs.openSync,
+    closeSync: (() => { lastOpenedPath = null }) as typeof fs.closeSync,
+    readSync: ((
+      _fd: number, buf: NodeJS.ArrayBufferView, offset: number, length: number, position: number | null,
+    ): number => {
+      const content = lastOpenedPath != null ? fileContents.get(lastOpenedPath) : undefined
+      if (!content) return 0
+      const pos = position ?? 0
+      const src = content.slice(pos, pos + length)
+      ;(src as Buffer).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 intervals: Array<{ fn: () => void; ms: number; ref: number; fireAt: number }> = []
+  let nextRef = 1
+  const watcher = startSubagentWatcher({
+    agentDir,
+    stallThresholdMs: configStallThresholdMs,
+    silentSynthesisStallThresholdMs: configStallThresholdMs,
+    silentStallTerminalMs: configSilentStallTerminalMs,
+    rescanMs: 500,
+    sendNotification: () => {},
+    onStall: (_id, idleMs) => stallCalls.push({ idleMs }),
+    onStallTerminal: (id) => stallTerminalCalls.push({ agentId: id }),
+    onFinish: ({ outcome }) => finishCalls.push({ outcome }),
+    now: () => currentTime,
+    setInterval: (fn, ms) => {
+      const ref = nextRef++
+      intervals.push({ fn, ms, ref, fireAt: currentTime + ms })
+      return { ref }
+    },
+    clearInterval: (h) => {
+      const { ref } = h as { ref: number }
+      const idx = intervals.findIndex((i) => i.ref === ref)
+      if (idx !== -1) intervals.splice(idx, 1)
+    },
+    fs: mockFs,
+  })
+
+  const advance = (ms: number): void => {
+    currentTime += ms
+    for (;;) {
+      intervals.sort((a, b) => a.fireAt - b.fireAt)
+      const next = intervals[0]
+      if (!next || next.fireAt > currentTime) break
+      next.fireAt += next.ms
+      next.fn()
+    }
+  }
+
+  const unmarkHistorical = (): void => {
+    const e = watcher.getRegistry().get(agentId)
+    if (e) e.historical = false
+  }
+
+  return { stallCalls, stallTerminalCalls, finishCalls, advance, unmarkHistorical }
+}
+
+const ENV_KEYS = [
+  'SWITCHROOM_SUBAGENT_STALL_MS',
+  'SWITCHROOM_SUBAGENT_SILENT_SYNTH_STALL_MS',
+  'SWITCHROOM_SUBAGENT_STALL_TERMINAL_MS',
+] as const
+
+describe('subagent-watcher env-var threshold overrides', () => {
+  const saved: Record<string, string | undefined> = {}
+
+  beforeEach(() => {
+    for (const k of ENV_KEYS) {
+      saved[k] = process.env[k]
+      delete process.env[k]
+    }
+  })
+
+  afterEach(() => {
+    for (const k of ENV_KEYS) {
+      if (saved[k] === undefined) delete process.env[k]
+      else process.env[k] = saved[k]
+    }
+  })
+
+  it('honors SWITCHROOM_SUBAGENT_STALL_TERMINAL_MS for the synth window', () => {
+    process.env.SWITCHROOM_SUBAGENT_STALL_TERMINAL_MS = '5000'
+    const h = makeHarness({
+      // Tight stall threshold so the test isn't dominated by the
+      // 60s default.
+      configStallThresholdMs: 1000,
+    })
+    h.advance(500) // register
+    h.unmarkHistorical()
+    h.advance(2_000) // stall fires (idle > 1s)
+    expect(h.stallCalls).toHaveLength(1)
+    expect(h.stallTerminalCalls).toHaveLength(0)
+
+    // 4s post-stall — still under 5s env override.
+    h.advance(4_000)
+    expect(h.stallTerminalCalls).toHaveLength(0)
+
+    // Cross 5s — synth fires.
+    h.advance(2_000)
+    expect(h.stallTerminalCalls).toHaveLength(1)
+    expect(h.finishCalls).toHaveLength(1)
+  })
+
+  it('explicit config arg overrides env var (config wins)', () => {
+    process.env.SWITCHROOM_SUBAGENT_STALL_TERMINAL_MS = '5000'
+    const h = makeHarness({
+      configStallThresholdMs: 1000,
+      configSilentStallTerminalMs: 60_000, // overrides env
+    })
+    h.advance(500)
+    h.unmarkHistorical()
+    h.advance(2_000) // stall fires
+    expect(h.stallCalls).toHaveLength(1)
+
+    // 10s past stall — env would have synthesised (5s) but config
+    // override pins it at 60s.
+    h.advance(10_000)
+    expect(h.stallTerminalCalls).toHaveLength(0)
+
+    // Cross 60s — synth fires.
+    h.advance(55_000)
+    expect(h.stallTerminalCalls).toHaveLength(1)
+  })
+
+  it('invalid env value falls through to default (does not disable)', () => {
+    // Both negative and NaN should be ignored — not coerced to "disable
+    // stall detection" or "fire immediately".
+    process.env.SWITCHROOM_SUBAGENT_STALL_TERMINAL_MS = '-1'
+    const h1 = makeHarness({ configStallThresholdMs: 1000 })
+    h1.advance(500)
+    h1.unmarkHistorical()
+    h1.advance(2_000) // stall fires
+    expect(h1.stallCalls).toHaveLength(1)
+    // Default is 300_000 — synth must NOT fire after a small advance.
+    h1.advance(60_000)
+    expect(h1.stallTerminalCalls).toHaveLength(0)
+  })
+
+  it('NaN env value falls through to default', () => {
+    process.env.SWITCHROOM_SUBAGENT_STALL_TERMINAL_MS = 'not-a-number'
+    const h = makeHarness({ configStallThresholdMs: 1000 })
+    h.advance(500)
+    h.unmarkHistorical()
+    h.advance(2_000)
+    h.advance(60_000)
+    expect(h.stallTerminalCalls).toHaveLength(0)
+  })
+
+  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 })
+    h.advance(500)
+    h.unmarkHistorical()
+    h.advance(2_000)
+    h.advance(60_000)
+    expect(h.stallTerminalCalls).toHaveLength(0)
+  })
+})