switchroom 0.5.0

package/telegram-plugin/tests/subagent-registry-bugs.test.ts

@@ -0,0 +1,725 @@
+/**
+ * Regression tests for three confirmed bugs in the subagent registry.
+ * Vitest-compatible portion: watcher integration tests only.
+ *
+ * Bug 1 — ID mismatch: bumpSubagentActivity is a permanent no-op because the
+ *   watcher looks up rows by JSONL filename stem (e.g. "a37ad763…") but DB rows
+ *   are keyed on tool_use_id (e.g. "toolu_013u…"). Fix: store the JSONL stem in
+ *   a new `jsonl_agent_id` column and let the watcher match on that.
+ *
+ * Bug 2 — Background agents marked completed at launch: PostToolUse fires for
+ *   background Agent() calls within seconds of launch (the "launched" response),
+ *   marking the row completed while the agent is actively running. Fix: gate
+ *   PostToolUse completion on `background === false`; background rows advance
+ *   only via watcher turn_end.
+ *
+ * Bug 3 — No stalled-row sweeper: `recordSubagentStall` exists but nothing calls
+ *   it when a row is `running` and `last_activity_at` is stale. Fix: the watcher
+ *   must call `recordSubagentStall` for stale DB rows in addition to updating the
+ *   in-memory `stallNotified` flag.
+ *
+ * Tests that require bun:sqlite are in:
+ *   telegram-plugin/registry/subagents-bugs.test.ts  (run via bun test)
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest'
+import * as fsReal from 'fs'
+import { startSubagentWatcher } from '../subagent-watcher.js'
+import type { SubagentLivenessDb } from '../subagent-watcher.js'
+
+// ─── Helpers ─────────────────────────────────────────────────────────────────
+
+function buildJSONL(...lines: object[]): string {
+  return lines.map((l) => JSON.stringify(l)).join('\n') + '\n'
+}
+
+function subAgentUserMsg(text: string) {
+  return { type: 'user', message: { content: [{ type: 'text', text }] } }
+}
+
+function subAgentToolUse(name: string, id: string) {
+  return { type: 'assistant', message: { content: [{ type: 'tool_use', name, id, input: {} }] } }
+}
+
+function subAgentTurnDuration() {
+  return { type: 'system', subtype: 'turn_duration', durationMs: 5000 }
+}
+
+/**
+ * Minimal fake DB that records all SQL calls for assertion.
+ * Implements SubagentLivenessDb plus enough for the watcher's SELECT lookup.
+ */
+function makeInMemoryDb(rows: Record<string, Record<string, unknown>> = {}) {
+  const calls: Array<{ sql: string; params: unknown[] }> = []
+  const db: SubagentLivenessDb & {
+    _calls: typeof calls
+    _rows: typeof rows
+  } = {
+    _calls: calls,
+    _rows: rows,
+    prepare(sql: string) {
+      return {
+        run(...params: unknown[]) {
+          calls.push({ sql, params })
+          // Track stall writes for assertion (use /s dotAll to match across newlines)
+          if (/UPDATE subagents[\s\S]*SET status\s*=\s*'stalled'/i.test(sql)) {
+            for (const p of params) {
+              if (typeof p === 'string' && rows[p]) {
+                rows[p]['status'] = 'stalled'
+              }
+              // Also handle jsonl_agent_id lookup
+              if (typeof p === 'string') {
+                const entry = Object.values(rows).find((r) => r['jsonl_agent_id'] === p)
+                if (entry) entry['status'] = 'stalled'
+              }
+            }
+          }
+          // Track end writes (use /s dotAll)
+          if (/UPDATE subagents[\s\S]*SET[\s\S]*ended_at/i.test(sql)) {
+            // params: [endedAt, status, resultSummary, id]
+            // recordSubagentEnd: run(endedAt, status, resultSummary, id)
+            const id = params[3]
+            if (typeof id === 'string' && rows[id]) {
+              rows[id]['ended_at'] = params[0]
+              rows[id]['status'] = params[1]
+            }
+          }
+          // Track activity bumps (UPDATE subagents\n    SET last_activity_at)
+          if (/UPDATE subagents[\s\S]*SET last_activity_at/i.test(sql)) {
+            // bumpSubagentActivity: run(ts, id)
+            const id = params[1]
+            if (typeof id === 'string' && rows[id]) {
+              rows[id]['last_activity_at'] = params[0]
+            }
+          }
+        },
+        get(...params: unknown[]) {
+          calls.push({ sql, params })
+          // SELECT id FROM subagents WHERE id = ?
+          if (/SELECT.*FROM subagents WHERE id\s*=/i.test(sql)) {
+            const id = params[0] as string
+            return rows[id] ?? null
+          }
+          // SELECT id FROM subagents WHERE jsonl_agent_id = ?
+          if (/SELECT.*FROM subagents WHERE jsonl_agent_id/i.test(sql)) {
+            const jsonlId = params[0] as string
+            return Object.values(rows).find((r) => r['jsonl_agent_id'] === jsonlId) ?? null
+          }
+          return null
+        },
+        all(...params: unknown[]) {
+          calls.push({ sql, params })
+          if (/SELECT.*FROM subagents WHERE status.*running/i.test(sql)) {
+            return Object.values(rows).filter((r) => r['status'] === 'running')
+          }
+          return []
+        },
+      }
+    },
+  }
+  return db
+}
+
+type MockFs = {
+  existsSync: typeof fsReal.existsSync
+  readdirSync: typeof fsReal.readdirSync
+  statSync: typeof fsReal.statSync
+  openSync: typeof fsReal.openSync
+  closeSync: typeof fsReal.closeSync
+  readSync: typeof fsReal.readSync
+  watch: typeof fsReal.watch
+}
+
+function makeHarnessWithDb(opts: {
+  agentDir?: string
+  files?: Record<string, string>
+  dirs?: Record<string, string[]>
+  existingDirs?: string[]
+  stallThresholdMs?: number
+  db?: SubagentLivenessDb | null
+}) {
+  const {
+    agentDir = '/home/user/.switchroom/agents/myagent',
+    files = {},
+    dirs = {},
+    existingDirs = [],
+    stallThresholdMs = 60_000,
+    db = null,
+  } = opts
+
+  let currentTime = 10_000
+  const notifications: string[] = []
+  const logs: string[] = []
+
+  const fileContents: Map<string, Buffer> = new Map()
+  for (const [path, content] of Object.entries(files)) {
+    fileContents.set(path, Buffer.from(content, 'utf-8'))
+  }
+
+  let lastOpenedPath: string | null = null
+  const mockFs: MockFs = {
+    existsSync: ((p: fsReal.PathLike) => {
+      const ps = String(p)
+      if (existingDirs.includes(ps)) return true
+      if (dirs[ps] !== undefined) return true
+      if (fileContents.has(ps)) return true
+      for (const fp of fileContents.keys()) {
+        if (fp.startsWith(ps + '/')) return true
+      }
+      return false
+    }) as typeof fsReal.existsSync,
+    readdirSync: ((p: fsReal.PathLike) => {
+      const ps = String(p)
+      if (dirs[ps]) return dirs[ps]
+      const children = new Set<string>()
+      for (const fp of fileContents.keys()) {
+        if (fp.startsWith(ps + '/')) {
+          const rest = fp.slice(ps.length + 1)
+          const part = rest.split('/')[0]
+          if (part) children.add(part)
+        }
+      }
+      return Array.from(children)
+    }) as unknown as typeof fsReal.readdirSync,
+    statSync: ((p: fsReal.PathLike) => {
+      const ps = String(p)
+      const content = fileContents.get(ps)
+      return { size: content?.length ?? 0 } as fsReal.Stats
+    }) as typeof fsReal.statSync,
+    openSync: ((p: fsReal.PathLike) => {
+      lastOpenedPath = String(p)
+      return 42
+    }) as unknown as typeof fsReal.openSync,
+    closeSync: (() => {
+      lastOpenedPath = null
+    }) as typeof fsReal.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 fsReal.readSync,
+    watch: (() => {
+      return { close: vi.fn() } as unknown as fsReal.FSWatcher
+    }) as unknown as typeof fsReal.watch,
+  }
+
+  const intervals: Array<{ fn: () => void; ms: number; ref: number; fireAt: number }> = []
+  let nextRef = 1
+
+  const watcher = startSubagentWatcher({
+    agentDir,
+    sendNotification: (text) => notifications.push(text),
+    stallThresholdMs,
+    rescanMs: 500,
+    now: () => currentTime,
+    setInterval: (fn, ms) => {
+      const ref = nextRef++
+      intervals.push({ fn, ms, ref, fireAt: currentTime + ms })
+      return { ref }
+    },
+    clearInterval: (handle) => {
+      const { ref } = handle as { ref: number }
+      const idx = intervals.findIndex((i) => i.ref === ref)
+      if (idx !== -1) intervals.splice(idx, 1)
+    },
+    fs: mockFs,
+    log: (msg: string) => { logs.push(msg) },
+    db,
+  })
+
+  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 poll = (): void => {
+    const pollInterval = intervals[0]
+    if (pollInterval) pollInterval.fn()
+  }
+
+  return { notifications, logs, advance, poll, watcher, now: () => currentTime, mockFs, fileContents }
+}
+
+// ─── Bug 1 — ID mismatch: watcher never bumps last_activity_at ───────────────
+
+describe('Bug 1 — ID mismatch: bumpSubagentActivity must use jsonl_agent_id', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('watcher bumps last_activity_at when jsonl_agent_id matches', () => {
+    const agentDir = '/home/user/.switchroom/agents/myagent'
+    const subagentsDir = `${agentDir}/.claude/projects/p1/session-abc/subagents`
+    const jsonlStem = 'a37ad7639ae61476c'
+    const toolUseId = 'toolu_013uXh6BmWecF3ajx4mPxS6V'
+    const jsonlPath = `${subagentsDir}/agent-${jsonlStem}.jsonl`
+    const content = buildJSONL(subAgentUserMsg('Do work'), subAgentToolUse('Bash', 'x1'))
+
+    // DB row is keyed on toolUseId but has jsonl_agent_id = jsonlStem
+    const db = makeInMemoryDb({
+      [toolUseId]: { id: toolUseId, jsonl_agent_id: jsonlStem, status: 'running' },
+    })
+
+    const h = makeHarnessWithDb({
+      agentDir,
+      dirs: {
+        [`${agentDir}/.claude/projects`]: ['p1'],
+        [`${agentDir}/.claude/projects/p1`]: ['session-abc'],
+        [subagentsDir]: [`agent-${jsonlStem}.jsonl`],
+      },
+      files: { [jsonlPath]: content },
+      db,
+    })
+
+    // File exists at boot → historical. After boot the watcher still does an
+    // initial read, which should have gone through the jsonl_agent_id lookup.
+    const entry = h.watcher.getRegistry().get(jsonlStem)
+    expect(entry).toBeDefined()
+
+    // The watcher must have queried by jsonl_agent_id (not just by id=jsonlStem)
+    const lookupCalls = db._calls.filter(
+      (c) => /WHERE jsonl_agent_id/i.test(c.sql),
+    )
+    expect(lookupCalls.length).toBeGreaterThan(0)
+
+    // And must have called bumpSubagentActivity — UPDATE SET last_activity_at
+    const bumpCalls = db._calls.filter(
+      (c) => /UPDATE subagents[\s\S]*SET last_activity_at/i.test(c.sql),
+    )
+    expect(bumpCalls.length).toBeGreaterThan(0)
+
+    // The bump WHERE clause must use the actual DB row PK (toolUseId), not the jsonlStem
+    const bumpParams = bumpCalls[0].params
+    expect(bumpParams).toContain(toolUseId)
+
+    h.watcher.stop()
+  })
+
+  it('watcher logs skip when no DB row has matching jsonl_agent_id', () => {
+    const agentDir = '/home/user/.switchroom/agents/myagent'
+    const subagentsDir = `${agentDir}/.claude/projects/p1/session-abc/subagents`
+    const jsonlStem = 'newagent001'
+    const jsonlPath = `${subagentsDir}/agent-${jsonlStem}.jsonl`
+    const content = buildJSONL(subAgentUserMsg('Work'))
+
+    // Empty DB — PreToolUse hasn't fired yet
+    const db = makeInMemoryDb({})
+
+    const h = makeHarnessWithDb({
+      agentDir,
+      dirs: {
+        [`${agentDir}/.claude/projects`]: ['p1'],
+        [`${agentDir}/.claude/projects/p1`]: ['session-abc'],
+        [subagentsDir]: [`agent-${jsonlStem}.jsonl`],
+      },
+      files: { [jsonlPath]: content },
+      db,
+    })
+
+    const skipLogs = h.logs.filter((l) => l.includes('liveness skip') || l.includes('row not in DB'))
+    expect(skipLogs.length).toBeGreaterThan(0)
+
+    h.watcher.stop()
+  })
+
+  it('old behaviour (lookup by agentId directly) misses when IDs differ — confirms the bug', () => {
+    // This documents CURRENT (broken) behaviour: when the watcher does
+    //   SELECT id FROM subagents WHERE id = entry.agentId
+    // and entry.agentId is the JSONL stem, it gets null for a row whose PK
+    // is a tool_use_id. The "watcher logs skip" test above will PASS once
+    // the fix is in because empty-DB is the same result either way. This
+    // test is specifically for the ID-mismatch case.
+    const agentDir = '/home/user/.switchroom/agents/myagent'
+    const subagentsDir = `${agentDir}/.claude/projects/p1/session-abc/subagents`
+    const jsonlStem = 'a37ad7639ae61476c'
+    const toolUseId = 'toolu_013uXh6BmWecF3ajx4mPxS6V'
+    const jsonlPath = `${subagentsDir}/agent-${jsonlStem}.jsonl`
+    const content = buildJSONL(subAgentUserMsg('Work'), subAgentToolUse('Bash', 'x1'))
+
+    // A DB that only responds to tool_use_id lookups (not jsonl stem lookups)
+    // This simulates the pre-fix DB where jsonl_agent_id doesn't exist.
+    let byIdLookups = 0
+    const db = makeInMemoryDb({})
+    const origPrepare = db.prepare.bind(db)
+    db.prepare = (sql: string) => {
+      const stmt = origPrepare(sql)
+      if (/WHERE id\s*=/i.test(sql) && !/jsonl/i.test(sql)) {
+        const origGet = stmt.get.bind(stmt)
+        stmt.get = (...params: unknown[]) => {
+          byIdLookups++
+          // Return the row only when the lookup key matches the tool_use_id,
+          // not when it's the jsonl stem — this is the broken pre-fix behaviour.
+          if (params[0] === toolUseId) {
+            return { id: toolUseId, status: 'running' }
+          }
+          return null // jsonlStem lookup → miss
+        }
+      }
+      return stmt
+    }
+
+    const h = makeHarnessWithDb({
+      agentDir,
+      dirs: {
+        [`${agentDir}/.claude/projects`]: ['p1'],
+        [`${agentDir}/.claude/projects/p1`]: ['session-abc'],
+        [subagentsDir]: [`agent-${jsonlStem}.jsonl`],
+      },
+      files: { [jsonlPath]: content },
+      db,
+    })
+
+    // With current broken code: lookup by agentId (jsonlStem) → null → skip logged
+    // With fixed code: lookup by jsonl_agent_id → found → bump called
+    // Either way the entry is registered; what matters is whether bump fires.
+    const entry = h.watcher.getRegistry().get(jsonlStem)
+    expect(entry).toBeDefined()
+
+    h.watcher.stop()
+  })
+})
+
+// ─── Bug 2 — Background agents marked completed at launch ────────────────────
+
+describe('Bug 2 — Background agent transitions to completed via watcher turn_end only', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('watcher calls recordSubagentEnd for background agent on turn_end', () => {
+    const agentDir = '/home/user/.switchroom/agents/myagent'
+    const subagentsDir = `${agentDir}/.claude/projects/p1/session-abc/subagents`
+    const jsonlStem = 'bg-agent-001'
+    const toolUseId = 'toolu_bgagent001'
+    const jsonlPath = `${subagentsDir}/agent-${jsonlStem}.jsonl`
+
+    const initialContent = buildJSONL(subAgentUserMsg('Long background task'))
+    const finishedContent = initialContent + buildJSONL(subAgentTurnDuration())
+
+    // DB row for background agent — still running (posttool correctly skipped it)
+    const db = makeInMemoryDb({
+      [toolUseId]: { id: toolUseId, jsonl_agent_id: jsonlStem, status: 'running', background: 1 },
+    })
+
+    const h = makeHarnessWithDb({
+      agentDir,
+      dirs: {
+        [`${agentDir}/.claude/projects`]: ['p1'],
+        [`${agentDir}/.claude/projects/p1`]: ['session-abc'],
+        [subagentsDir]: [],
+      },
+      files: {},
+      db,
+    })
+
+    // Write the initial JSONL post-startup so the agent is not historical
+    h.fileContents.set(jsonlPath, Buffer.from(initialContent, 'utf-8'))
+    h.mockFs.readdirSync = ((p: unknown) => {
+      const ps = String(p)
+      if (ps === subagentsDir) return [`agent-${jsonlStem}.jsonl`]
+      if (ps === `${agentDir}/.claude/projects`) return ['p1']
+      if (ps === `${agentDir}/.claude/projects/p1`) return ['session-abc']
+      return []
+    }) as unknown as typeof fsReal.readdirSync
+    h.mockFs.existsSync = ((p: unknown) => {
+      const ps = String(p)
+      return [
+        `${agentDir}/.claude/projects`,
+        `${agentDir}/.claude/projects/p1`,
+        `${agentDir}/.claude/projects/p1/session-abc`,
+        subagentsDir,
+        jsonlPath,
+      ].includes(ps)
+    }) as typeof fsReal.existsSync
+
+    // First poll: register the agent
+    h.poll()
+    const entry = h.watcher.getRegistry().get(jsonlStem)
+    expect(entry).toBeDefined()
+    expect(entry?.state).toBe('running')
+
+    // Append turn_end
+    h.fileContents.set(jsonlPath, Buffer.from(finishedContent, 'utf-8'))
+
+    // Second poll: watcher sees turn_end → entry.state = 'done'
+    // → watcher must call recordSubagentEnd on the DB (UPDATE SET ended_at)
+    h.poll()
+
+    const completedEntry = h.watcher.getRegistry().get(jsonlStem)
+    expect(completedEntry?.state).toBe('done')
+
+    // watcher must have issued UPDATE subagents SET ended_at … WHERE id = toolUseId
+    const endCalls = db._calls.filter(
+      (c) => /UPDATE subagents[\s\S]*SET[\s\S]*ended_at/i.test(c.sql) && c.params.includes(toolUseId),
+    )
+    expect(endCalls.length).toBeGreaterThan(0)
+
+    h.watcher.stop()
+  })
+
+  it('foreground agent still gets completed via DB when watcher sees turn_end (regression)', () => {
+    const agentDir = '/home/user/.switchroom/agents/myagent'
+    const subagentsDir = `${agentDir}/.claude/projects/p1/session-abc/subagents`
+    const jsonlStem = 'fg-agent-001'
+    const toolUseId = 'toolu_fgagent001'
+    const jsonlPath = `${subagentsDir}/agent-${jsonlStem}.jsonl`
+
+    const initialContent = buildJSONL(subAgentUserMsg('Foreground task'))
+    const finishedContent = initialContent + buildJSONL(subAgentTurnDuration())
+
+    const db = makeInMemoryDb({
+      [toolUseId]: { id: toolUseId, jsonl_agent_id: jsonlStem, status: 'running', background: 0 },
+    })
+
+    const h = makeHarnessWithDb({
+      agentDir,
+      dirs: {
+        [`${agentDir}/.claude/projects`]: ['p1'],
+        [`${agentDir}/.claude/projects/p1`]: ['session-abc'],
+        [subagentsDir]: [],
+      },
+      files: {},
+      db,
+    })
+
+    h.fileContents.set(jsonlPath, Buffer.from(initialContent, 'utf-8'))
+    h.mockFs.readdirSync = ((p: unknown) => {
+      const ps = String(p)
+      if (ps === subagentsDir) return [`agent-${jsonlStem}.jsonl`]
+      if (ps === `${agentDir}/.claude/projects`) return ['p1']
+      if (ps === `${agentDir}/.claude/projects/p1`) return ['session-abc']
+      return []
+    }) as unknown as typeof fsReal.readdirSync
+    h.mockFs.existsSync = ((p: unknown) => {
+      const ps = String(p)
+      return [
+        `${agentDir}/.claude/projects`,
+        `${agentDir}/.claude/projects/p1`,
+        `${agentDir}/.claude/projects/p1/session-abc`,
+        subagentsDir,
+        jsonlPath,
+      ].includes(ps)
+    }) as typeof fsReal.existsSync
+
+    h.poll()
+    h.fileContents.set(jsonlPath, Buffer.from(finishedContent, 'utf-8'))
+    h.poll()
+
+    const entry = h.watcher.getRegistry().get(jsonlStem)
+    expect(entry?.state).toBe('done')
+
+    // For foreground agents the PostToolUse hook fires first (marking completed),
+    // so the row may already be completed by the time the watcher sees turn_end.
+    // The watcher's recordSubagentEnd is idempotent — either way the row ends up completed.
+    // Just verify the watcher called it and didn't error.
+    // (The hook-level test is in the bun test suite.)
+    h.watcher.stop()
+  })
+})
+
+// ─── Bug 3 — No stalled-row sweeper ─────────────────────────────────────────
+
+describe('Bug 3 — stalled-row sweeper: watcher must call recordSubagentStall in DB', () => {
+  beforeEach(() => {
+    vi.restoreAllMocks()
+  })
+
+  it('calls UPDATE subagents SET status=stalled for a stale running DB row', () => {
+    const agentDir = '/home/user/.switchroom/agents/myagent'
+    const subagentsDir = `${agentDir}/.claude/projects/p1/session-abc/subagents`
+    const jsonlStem = 'stale-agent-001'
+    const toolUseId = 'toolu_stale001'
+    const jsonlPath = `${subagentsDir}/agent-${jsonlStem}.jsonl`
+    const content = buildJSONL(subAgentUserMsg('Task that stalls'))
+
+    const db = makeInMemoryDb({
+      [toolUseId]: { id: toolUseId, jsonl_agent_id: jsonlStem, status: 'running' },
+    })
+
+    const h = makeHarnessWithDb({
+      agentDir,
+      dirs: {
+        [`${agentDir}/.claude/projects`]: ['p1'],
+        [`${agentDir}/.claude/projects/p1`]: ['session-abc'],
+        [subagentsDir]: [`agent-${jsonlStem}.jsonl`],
+      },
+      files: { [jsonlPath]: content },
+      stallThresholdMs: 60_000,
+      db,
+    })
+
+    // Flip historical flag so stall detection fires
+    const entry = h.watcher.getRegistry().get(jsonlStem)
+    if (entry) entry.historical = false
+
+    // Advance past stall threshold
+    h.advance(65_000)
+
+    // watcher must have issued UPDATE subagents SET status='stalled'
+    const stallDbCalls = db._calls.filter(
+      (c) => /UPDATE subagents[\s\S]*SET status[\s\S]*stalled/i.test(c.sql),
+    )
+    expect(stallDbCalls.length).toBeGreaterThan(0)
+
+    h.watcher.stop()
+  })
+
+  it('does not double-write stall (stallNotified guards idempotency)', () => {
+    const agentDir = '/home/user/.switchroom/agents/myagent'
+    const subagentsDir = `${agentDir}/.claude/projects/p1/session-abc/subagents`
+    const jsonlStem = 'already-stalled'
+    const toolUseId = 'toolu_already001'
+    const jsonlPath = `${subagentsDir}/agent-${jsonlStem}.jsonl`
+    const content = buildJSONL(subAgentUserMsg('Stalled task'))
+
+    const db = makeInMemoryDb({
+      [toolUseId]: { id: toolUseId, jsonl_agent_id: jsonlStem, status: 'running' },
+    })
+
+    const h = makeHarnessWithDb({
+      agentDir,
+      dirs: {
+        [`${agentDir}/.claude/projects`]: ['p1'],
+        [`${agentDir}/.claude/projects/p1`]: ['session-abc'],
+        [subagentsDir]: [`agent-${jsonlStem}.jsonl`],
+      },
+      files: { [jsonlPath]: content },
+      stallThresholdMs: 60_000,
+      db,
+    })
+
+    const entry = h.watcher.getRegistry().get(jsonlStem)
+    if (entry) entry.historical = false
+
+    h.advance(65_000)
+    const firstCount = db._calls.filter(
+      (c) => /UPDATE subagents[\s\S]*SET status[\s\S]*stalled/i.test(c.sql),
+    ).length
+    expect(firstCount).toBeGreaterThan(0)
+
+    h.advance(65_000) // should NOT fire again
+    const secondCount = db._calls.filter(
+      (c) => /UPDATE subagents[\s\S]*SET status[\s\S]*stalled/i.test(c.sql),
+    ).length
+    expect(secondCount).toBe(firstCount)
+
+    h.watcher.stop()
+  })
+
+  it('does not call stall for historical entries (pre-existing at boot)', () => {
+    const agentDir = '/home/user/.switchroom/agents/myagent'
+    const subagentsDir = `${agentDir}/.claude/projects/p1/session-abc/subagents`
+    const jsonlStem = 'hist-agent'
+    const toolUseId = 'toolu_hist001'
+    const jsonlPath = `${subagentsDir}/agent-${jsonlStem}.jsonl`
+    const content = buildJSONL(subAgentUserMsg('Old task'))
+
+    const db = makeInMemoryDb({
+      [toolUseId]: { id: toolUseId, jsonl_agent_id: jsonlStem, status: 'running' },
+    })
+
+    const h = makeHarnessWithDb({
+      agentDir,
+      dirs: {
+        [`${agentDir}/.claude/projects`]: ['p1'],
+        [`${agentDir}/.claude/projects/p1`]: ['session-abc'],
+        [subagentsDir]: [`agent-${jsonlStem}.jsonl`],
+      },
+      files: { [jsonlPath]: content },
+      stallThresholdMs: 60_000,
+      db,
+    })
+
+    // Do NOT flip historical — entry is historical by default (file at boot)
+    h.advance(65_000)
+
+    const stallDbCalls = db._calls.filter(
+      (c) => /UPDATE subagents[\s\S]*SET status[\s\S]*stalled/i.test(c.sql),
+    )
+    // Historical entries must NOT trigger stall writes to DB
+    expect(stallDbCalls).toHaveLength(0)
+
+    h.watcher.stop()
+  })
+})
+
+// ─── result_summary always NULL — extractResultSummary ───────────────────────
+
+describe('result_summary extractResultSummary — Claude Code content[] wrapping', () => {
+  /**
+   * Claude Code wraps Agent() output in { content: [{ type: 'text', text }] }.
+   * The posttool's extractResultSummary only checks .result and .output, so
+   * result_summary is always NULL.
+   */
+
+  it('current extractResultSummary returns null for content-array responses (confirms bug)', () => {
+    const toolResponse = {
+      content: [{ type: 'text', text: 'Task completed. 3 files modified.' }],
+    }
+    // Current (broken) implementation
+    const brokenExtract = (resp: unknown): string | null => {
+      if (!resp) return null
+      const r = resp as Record<string, unknown>
+      const raw = r['result'] ?? r['output'] ?? (typeof resp === 'string' ? resp : null)
+      if (raw == null) return null
+      const str = typeof raw === 'string' ? raw : JSON.stringify(raw)
+      return str.slice(0, 200) || null
+    }
+    expect(brokenExtract(toolResponse)).toBeNull()
+  })
+
+  it('fixed extractResultSummary handles content[0].text', () => {
+    const toolResponse = {
+      content: [{ type: 'text', text: 'Task completed. 3 files modified.' }],
+    }
+    const fixedExtract = (resp: unknown): string | null => {
+      if (!resp) return null
+      const r = resp as Record<string, unknown>
+      const raw =
+        r['result'] ??
+        r['output'] ??
+        (Array.isArray(r['content']) && r['content'].length > 0
+          ? (r['content'][0] as Record<string, unknown>)['text']
+          : null) ??
+        (typeof resp === 'string' ? resp : null)
+      if (raw == null) return null
+      const str = typeof raw === 'string' ? raw : JSON.stringify(raw)
+      return str.slice(0, 200) || null
+    }
+    expect(fixedExtract(toolResponse)).toBe('Task completed. 3 files modified.')
+  })
+
+  it('fixed extractResultSummary still works when result field is present', () => {
+    const toolResponse = { result: 'Direct result string.' }
+    const fixedExtract = (resp: unknown): string | null => {
+      if (!resp) return null
+      const r = resp as Record<string, unknown>
+      const raw =
+        r['result'] ??
+        r['output'] ??
+        (Array.isArray(r['content']) && r['content'].length > 0
+          ? (r['content'][0] as Record<string, unknown>)['text']
+          : null) ??
+        (typeof resp === 'string' ? resp : null)
+      if (raw == null) return null
+      const str = typeof raw === 'string' ? raw : JSON.stringify(raw)
+      return str.slice(0, 200) || null
+    }
+    expect(fixedExtract(toolResponse)).toBe('Direct result string.')
+  })
+})