switchroom 0.18.3 → 0.18.7

package/telegram-plugin/tests/session-tail.test.ts

@@ -345,6 +345,42 @@ describe('projectTranscriptLine', () => {
       messageId: '103',
     })
   })
+
+  // ─── Live model capture (message.model) ──────────────────────────────
+  it('emits a model event (first) from message.model on an assistant line', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        model: 'claude-opus-4-8',
+        content: [{ type: 'tool_use', name: 'Bash', id: 'toolu_01', input: {} }],
+      },
+    })
+    // Model event is emitted BEFORE the content events so a same-batch render
+    // already reflects the current model.
+    expect(projectTranscriptLine(line)).toEqual([
+      { kind: 'model', model: 'claude-opus-4-8' },
+      { kind: 'tool_use', toolName: 'Bash', toolUseId: 'toolu_01', input: {} },
+    ])
+  })
+
+  it('skips a synthetic model sentinel (keeps no model event)', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        model: '<synthetic>',
+        content: [{ type: 'thinking', thinking: '...' }],
+      },
+    })
+    expect(projectTranscriptLine(line)).toEqual([{ kind: 'thinking' }])
+  })
+
+  it('omits the model event when message.model is absent', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: { content: [{ type: 'thinking', thinking: '...' }] },
+    })
+    expect(projectTranscriptLine(line)).toEqual([{ kind: 'thinking' }])
+  })
 })
 
 // ─── Bug 1 regression: per-file cursor state survives re-attachment ────
@@ -490,6 +526,34 @@ describe('projectSubagentLine', () => {
     ])
   })
 
+  it('emits sub_agent_model (first) from message.model on a sub-agent assistant line', () => {
+    const st = { hasEmittedStart: true }
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        model: 'sr-glm-5',
+        content: [{ type: 'tool_use', id: 'toolu_a', name: 'Read', input: { file_path: '/a' } }],
+      },
+    })
+    const events = projectSubagentLine(line, 'X', st)
+    expect(events[0]).toEqual({ kind: 'sub_agent_model', agentId: 'X', model: 'sr-glm-5' })
+    expect(events[1].kind).toBe('sub_agent_tool_use')
+  })
+
+  it('skips a synthetic sub-agent model sentinel', () => {
+    const st = { hasEmittedStart: true }
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        model: '<synthetic>',
+        content: [{ type: 'tool_use', id: 'toolu_a', name: 'Read', input: { file_path: '/a' } }],
+      },
+    })
+    const events = projectSubagentLine(line, 'X', st)
+    expect(events.some((e) => e.kind === 'sub_agent_model')).toBe(false)
+    expect(events[0].kind).toBe('sub_agent_tool_use')
+  })
+
   it('emits sub_agent_tool_use for regular tools; nested Agent fires ONLY nested_spawn', () => {
     const st = { hasEmittedStart: true }
     const line = JSON.stringify({

package/telegram-plugin/tests/silent-end-interrupt-stop-integration.test.ts

@@ -190,6 +190,59 @@ describe('silent-end-interrupt-stop.mjs — integration', () => {
     expect(state.retryCount).toBe(SILENT_END_MAX_RETRIES)
   })
 
+  it('blocks + writes retryCount=1 when an early qualifying reply is followed by an undelivered verdict (trailing-content bug repro)', () => {
+    // Confirmed-incident shape: (1) a background-task notification
+    // arrives, (2) the agent calls reply ONCE early with a stale,
+    // notification-bearing ack ("running now" — disable_notification
+    // unset, so it satisfies isFinalAnswerReply regardless of length),
+    // (3) the agent then does more work and writes a large substantive
+    // verdict as plain assistant text with NO second reply call. Pre-fix,
+    // the hook's "reply called at least once this turn" check allowed
+    // this to slip through silently — the trailing verdict never reached
+    // the user. Post-fix the hook must block on this shape exactly like
+    // the zero-reply case.
+    const transcript = writeTranscript(tmp, [
+      ENQUEUE,
+      reply('running now'),
+      { type: 'assistant', message: { content: [{ type: 'tool_use', name: 'Bash', input: { command: 'ls' } }] } },
+      { type: 'assistant', message: { content: [{ type: 'tool_use', name: 'Read', input: { file_path: '/tmp/x' } }] } },
+      {
+        type: 'assistant',
+        message: { content: [{ type: 'text', text: 'Here is the actual verdict: ' + 'X'.repeat(300) }] },
+      },
+    ])
+    const r = runHook({
+      event: { session_id: 's1', transcript_path: transcript },
+      stateDir,
+    })
+    expect(r.status).toBe(0)
+    const out = JSON.parse(r.stdout)
+    expect(out.decision).toBe('block')
+    expect(out.reason).toMatch(/Send your final answer/)
+    const statePath = join(stateDir, 'silent-end-pending.json')
+    expect(existsSync(statePath)).toBe(true)
+    const state = JSON.parse(readFileSync(statePath, 'utf8'))
+    expect(state.retryCount).toBe(1)
+    expect(state.chatId).toBe('111')
+    expect(state.turnKey).toBe('111:_')
+  })
+
+  it('does NOT false-positive on a normal single-reply turn ending on the reply tool_use', () => {
+    const transcript = writeTranscript(tmp, [
+      ENQUEUE,
+      { type: 'assistant', message: { content: [{ type: 'text', text: 'Let me check.' }] } },
+      { type: 'assistant', message: { content: [{ type: 'tool_use', name: 'Bash', input: { command: 'ls' } }] } },
+      reply('Here is your answer.', { disable_notification: false }),
+    ])
+    const r = runHook({
+      event: { session_id: 's1', transcript_path: transcript },
+      stateDir,
+    })
+    expect(r.status).toBe(0)
+    expect(r.stdout.trim()).toBe('')
+    expect(existsSync(join(stateDir, 'silent-end-pending.json'))).toBe(false)
+  })
+
   it('NO_REPLY in transcript → allow stop, no state file written', () => {
     const transcript = writeTranscript(tmp, [
       ENQUEUE,

package/telegram-plugin/tests/silent-end-interrupt-stop-scan.test.ts

@@ -184,6 +184,144 @@ describe('scanTurnForFinalReply — final-reply detection', () => {
   })
 })
 
+// ── "at least once" bug regression — trailing content after an early
+//    qualifying reply must still block ────────────────────────────────
+
+describe('scanTurnForFinalReply — trailing undelivered content after an early qualifying reply (bug repro)', () => {
+  it('early notification-bearing ack + later substantive plain text → block (not "reply called once" amnesty)', () => {
+    // Repro of the confirmed incident: the agent (1) got a background-task
+    // notification, (2) called reply ONCE early with a short, stale ack —
+    // notification-bearing (disable_notification unset/false), which
+    // ALWAYS qualifies as "final" under isFinalAnswerReply regardless of
+    // text length — then (3) wrote a large substantive verdict as plain
+    // assistant text with NO second reply call. The pre-fix scan returned
+    // 'allow' on the first qualifying block and never looked further; the
+    // fix must walk the whole turn and catch the undelivered trailing text.
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'running now' }),
+      assistantToolUse('Bash', { command: 'ls' }),
+      assistantToolUse('Read', { file_path: '/tmp/x' }),
+      assistantText('Here is the actual verdict after investigation: ' + 'X'.repeat(300)),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.reason).toBe('trailing-text-after-reply')
+    // turnKey/chatId must still be populated so the gateway's retry
+    // bookkeeping works exactly as it does for the zero-reply block path.
+    expect(r.chatId).toBe('111')
+    expect(r.turnKey).toBe('111:_')
+  })
+
+  it('early qualifying reply + trailing SHORT pleasantry → allow (#2956 review: substance floor, no-spam)', () => {
+    // A short trailing text after a delivered reply (a closer like "let me
+    // know if you need anything else.") is NOT a dropped answer — it's a
+    // pleasantry the persona prompts discourage but which must not burn
+    // retry budget or force a redundant second reply. Only SUBSTANTIVE
+    // trailing text (≥ FINAL_ANSWER_MIN_CHARS) blocks. Pre-fix this
+    // false-positive blocked and re-prompted a healthy turn.
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'ok', disable_notification: false }),
+      assistantText('actually, one more thing you should know'),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('allow')
+  })
+
+it('early qualifying reply + trailing SUBSTANTIVE undelivered text (≥ floor) → block (at-least-once holds)', () => {
+    // The substance floor must NOT weaken the at-least-once guarantee for
+    // a real dropped answer: a long trailing verdict the model forgot to
+    // send still blocks. The trailing text here clears FINAL_ANSWER_MIN_CHARS.
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'ok', disable_notification: false }),
+      assistantText('Here is the actual verdict after investigation: ' + 'X'.repeat(200)),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.reason).toBe('trailing-text-after-reply')
+  })
+
+  it('final qualifying reply is the LAST content block → allow (healthy shape, no false positive)', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantText('Let me check that.'),
+      assistantToolUse('Bash', { command: 'ls' }),
+      assistantToolUse('mcp__switchroom-telegram__reply', {
+        text: 'Here is your answer.',
+        disable_notification: false,
+      }),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('allow')
+    expect(r.reason).toBe('final-reply')
+  })
+
+  it('turn ends on a tool_result with no trailing text at all → allow (not a normal-turn false positive)', () => {
+    // A turn whose very last assistant content is the delivering
+    // reply tool_use, followed only by a (user-role) tool_result line —
+    // never any further assistant text. Must not be flagged.
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', {
+        text: 'Done — here is the summary.',
+        disable_notification: false,
+      }),
+      JSON.stringify({ type: 'user', message: { content: [{ type: 'tool_result', content: 'ok' }] } }),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('allow')
+    expect(r.reason).toBe('final-reply')
+  })
+
+  it('undelivered text sandwiched between two qualifying replies is superseded by the LATER reply → allow', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'first answer', disable_notification: false }),
+      assistantText('actually let me reconsider that'),
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'corrected final answer', disable_notification: false }),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('allow')
+    expect(r.reason).toBe('final-reply')
+  })
+
+  it('explicit trailing NO_REPLY after an earlier qualifying reply overrides → allow (intentional final silence)', () => {
+    const text = jsonl(
+      ENQUEUE,
+      assistantToolUse('mcp__switchroom-telegram__reply', { text: 'draft answer', disable_notification: false }),
+      assistantText('actually, scrap that, nothing more to add\nNO_REPLY'),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('allow')
+    expect(r.reason).toBe('silent-marker-text')
+  })
+
+  it('reverse case: an EARLIER NO_REPLY silence marker followed by later undelivered prose → block', () => {
+    // Mirror image of the "trailing NO_REPLY overrides" allow-case above.
+    // Here the model signals silence FIRST — as plain transcript text,
+    // not through the reply tool — and then keeps going, writing a real
+    // substantive answer afterward that it never sent through `reply` or
+    // `stream_reply`. The NO_REPLY marker is a "deliver" event (silence is
+    // a valid outcome), but it must not amnesty content written AFTER it,
+    // same failure shape as the original "at least once" bug: a naive scan
+    // that stops at the FIRST qualifying delivery/silence event would
+    // return 'allow' here and the trailing answer would be silently
+    // dropped. The fix's "last delivery event, then check for trailing
+    // text" walk must still catch this.
+    const text = jsonl(
+      ENQUEUE,
+      assistantText('Nothing to report right now.\nNO_REPLY'),
+      assistantToolUse('Bash', { command: 'ls' }),
+      assistantText('Wait, actually I found something you need to know: ' + 'Y'.repeat(300)),
+    )
+    const r = scanTurnForFinalReply(text)
+    expect(r.decided).toBe('block')
+    expect(r.reason).toBe('trailing-text-after-reply')
+  })
+})
+
 describe('scanTurnForFinalReply — silent-marker carve-out', () => {
   it('NO_REPLY → allow', () => {
     const text = jsonl(

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

@@ -10,6 +10,7 @@ import {
   recordSilentTurnEnd,
   recordUndeliveredTurnEnd,
   SILENT_END_MAX_RETRIES,
+  SILENT_END_STALE_RECORD_MAX_AGE_MS,
 } from '../silent-end.js'
 import { isFinalAnswerReply } from '../final-answer-detect.js'
 
@@ -206,12 +207,56 @@ describe('recordSilentTurnEnd — #1161 exhaustion detection', () => {
       chatId: 'c', threadId: null, turnKey: 'c:_',
       retryCount: SILENT_END_MAX_RETRIES, timestamp: 0,
     }))
-    const r = recordSilentTurnEnd({ chatId: 'c', threadId: null, turnKey: 'c:_' })
+    // Pin `now` alongside the record's timestamp=0 so this exercises the
+    // genuine same-turn ladder, not fix #8's age-based staleness bound
+    // (which is covered by its own dedicated tests below).
+    const r = recordSilentTurnEnd(
+      { chatId: 'c', threadId: null, turnKey: 'c:_' },
+      { now: () => 0 },
+    )
     expect(r.exhausted).toBe(true)
     // State cleared so the Stop hook on this final turn allows the stop.
     expect(readSilentEndState()).toBeNull()
   })
 
+  it('fix #8: an exhausted record older than the plausible turn lifetime starts a fresh retry budget (no delivery evidence needed)', () => {
+    // A crash/interrupt bypassed the gateway's own exhaust-read-and-clear,
+    // so a spent (retryCount >= MAX) record from an OLD turn survives on
+    // disk. turnKey is the STABLE statusKey(chatId, threadId) — it matches
+    // this brand-new dark turn on the same chat/thread even though it
+    // belongs to a completely different turn instance.
+    const path = join(stateDir, 'silent-end-pending.json')
+    writeFileSync(path, JSON.stringify({
+      chatId: 'c', threadId: null, turnKey: 'c:_',
+      retryCount: SILENT_END_MAX_RETRIES, timestamp: 0,
+    }))
+    const now = SILENT_END_STALE_RECORD_MAX_AGE_MS + 1000 // just past the age bound
+    const r = recordSilentTurnEnd(
+      { chatId: 'c', threadId: null, turnKey: 'c:_' },
+      { now: () => now },
+    )
+    // Must run its OWN re-prompt ladder, not immediately fall back.
+    expect(r.exhausted).toBe(false)
+    expect(readSilentEndState()).toMatchObject({ turnKey: 'c:_', retryCount: 0 })
+  })
+
+  it('fix #8: a genuinely same-turn exhausted record (within the age bound) still reports exhausted — no regression', () => {
+    const path = join(stateDir, 'silent-end-pending.json')
+    const recentTimestamp = 1_000_000
+    writeFileSync(path, JSON.stringify({
+      chatId: 'c', threadId: null, turnKey: 'c:_',
+      retryCount: SILENT_END_MAX_RETRIES, timestamp: recentTimestamp,
+    }))
+    // Well within the plausible single-turn retry-ladder window.
+    const now = recentTimestamp + 5000
+    const r = recordSilentTurnEnd(
+      { chatId: 'c', threadId: null, turnKey: 'c:_' },
+      { now: () => now },
+    )
+    expect(r.exhausted).toBe(true)
+    expect(readSilentEndState()).toBeNull()
+  })
+
   it('treats a capped prior state for a DIFFERENT turn as a fresh silent-end', () => {
     const path = join(stateDir, 'silent-end-pending.json')
     writeFileSync(path, JSON.stringify({

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

@@ -108,6 +108,45 @@ describe('subagent-tracker-pretool', () => {
     expect(row!.last_activity_at).toBe(row!.started_at)
   })
 
+  it('persists tool_input.model as the first-paint model on the row', () => {
+    const event = {
+      session_id: 'sess-model',
+      tool_name: 'Agent',
+      tool_use_id: 'toolu_model001',
+      tool_input: {
+        subagent_type: 'worker',
+        description: 'Build with a pinned model',
+        run_in_background: true,
+        model: 'claude-opus-4-8',
+      },
+    }
+    const result = runHook(PRETOOL_SCRIPT, event)
+    expect(result.status).toBe(0)
+
+    const db = openDb()
+    const row = db.prepare('SELECT model FROM subagents WHERE id = ?').get('toolu_model001') as
+      | { model: string | null }
+      | undefined
+    expect(row?.model).toBe('claude-opus-4-8')
+  })
+
+  it('leaves model null when the Agent dispatch carries no model', () => {
+    const event = {
+      session_id: 'sess-nomodel',
+      tool_name: 'Agent',
+      tool_use_id: 'toolu_nomodel001',
+      tool_input: { subagent_type: 'worker', description: 'no model', run_in_background: false },
+    }
+    const result = runHook(PRETOOL_SCRIPT, event)
+    expect(result.status).toBe(0)
+
+    const db = openDb()
+    const row = db.prepare('SELECT model FROM subagents WHERE id = ?').get('toolu_nomodel001') as
+      | { model: string | null }
+      | undefined
+    expect(row?.model ?? null).toBeNull()
+  })
+
   it('does not write a row when tool_name is not Agent', () => {
     const event = {
       session_id: 'sess-abc123',

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

@@ -37,14 +37,19 @@ describe('boot promotion — in-flight worker replays its activity through onPro
     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(
+    // the freshness gate makes it ELIGIBLE — but fix #5 also requires actual
+    // post-boot growth before promoting (mtime freshness alone can't
+    // distinguish this from a worker killed moments before the restart).
+    // `content` grows below via the captured fs.watch callback to supply
+    // that confirmation.
+    let 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
+    let watchCb: (() => void) | null = null
     const mockFs = {
       existsSync: ((p: fs.PathLike) => {
         const ps = String(p)
@@ -69,7 +74,10 @@ describe('boot promotion — in-flight worker replays its activity through onPro
         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,
+      watch: ((_p: fs.PathLike, cb?: () => void) => {
+        watchCb = cb ?? null
+        return { close: vi.fn() } as unknown as fs.FSWatcher
+      }) as unknown as typeof fs.watch,
     }
 
     const progressCalls: Array<{ agentId: string; progressLine?: string; toolCount: number }> = []
@@ -86,10 +94,25 @@ describe('boot promotion — in-flight worker replays its activity through onPro
       },
     })
 
+    // Fix #5: registration alone (mtime-fresh, no observed growth yet) must
+    // NOT promote — it stays historical/pending until growth confirms it.
+    const preGrowthEntry = watcher.getRegistry().get(agentId)
+    expect(preGrowthEntry?.historical).toBe(true)
+    expect(preGrowthEntry?.bootPromotionPending).toBeDefined()
+
+    // Simulate the worker taking one more real step post-boot: the JSONL
+    // grows, and Claude Code's fs notification fires.
+    content = Buffer.concat([content, Buffer.from(buildJSONL(
+      { type: 'assistant', message: { content: [{ type: 'text', text: 'still going' }] } },
+    ), 'utf-8')])
+    currentTime += 1000
+    watchCb?.()
+
     const entry = watcher.getRegistry().get(agentId)
     expect(entry).toBeDefined()
-    // Promoted live (fresh mtime, still running).
+    // Promoted live now that post-boot growth was actually observed.
     expect(entry?.historical).toBe(false)
+    expect(entry?.bootPromotionPending).toBeUndefined()
     // Replay rebuilt the entry WITHOUT double-counting the initial read.
     expect(entry?.toolCount).toBe(2)
     expect(entry?.lastTool?.name).toBe('Bash')
@@ -102,6 +125,86 @@ describe('boot promotion — in-flight worker replays its activity through onPro
     watcher.stop()
   })
 
+  it('fix #5: a running-at-boot file with fresh mtime but NO post-boot growth is never promoted (avoids a stale completed handback)', () => {
+    const agentId = 'inflight-no-growth-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
+    // Fresh mtime (30s old) but the file NEVER grows again — indistinguishable
+    // from a worker that was killed moments before this restart.
+    const content = Buffer.from(buildJSONL(
+      { type: 'user', message: { content: [{ type: 'text', text: 'task that got killed' }] } },
+      { type: 'assistant', message: { content: [{ type: 'tool_use', id: 't1', name: 'Read', input: { file_path: '/repo/a.ts' } }] } },
+    ), 'utf-8')
+
+    let lastOpened: string | null = null
+    const intervals: Array<{ fn: () => void; ms: number; fireAt: number }> = []
+    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: 100_000 - 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 finishCalls: Array<{ agentId: string; outcome: string }> = []
+    const watcher = startSubagentWatcher({
+      agentDir,
+      fs: mockFs,
+      inflightPromoteMaxAgeMs: 60_000, // small bound so the test can cross it
+      now: () => currentTime,
+      setInterval: (fn, ms) => {
+        intervals.push({ fn, ms, fireAt: currentTime + ms })
+        return { ref: 0 }
+      },
+      clearInterval: () => {},
+      setTimeout: () => ({ ref: 0 }),
+      clearTimeout: () => {},
+      onFinish: ({ agentId: id, outcome }) => finishCalls.push({ agentId: id, outcome }),
+    })
+
+    const entryAtBoot = watcher.getRegistry().get(agentId)
+    expect(entryAtBoot?.historical).toBe(true)
+    expect(entryAtBoot?.bootPromotionPending).toBeDefined()
+
+    // Advance well past the promotion window WITHOUT the file ever growing.
+    currentTime += 120_000
+    for (const iv of intervals) if (iv.fireAt <= currentTime) iv.fn()
+
+    const entry = watcher.getRegistry().get(agentId)
+    // Never promoted: still historical, no completed/failed handback ever
+    // synthesised from these pre-restart bytes.
+    expect(entry?.historical).toBe(true)
+    expect(entry?.bootPromotionPending).toBeUndefined() // gave up after the deadline
+    expect(finishCalls).toHaveLength(0)
+
+    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'

package/telegram-plugin/tests/subagent-watcher-handback-gaps.test.ts

@@ -224,14 +224,22 @@ describe('Gap 1 — background worker in-flight across a gateway restart', () =>
     expect(h.finishCalls[0].agentId).toBe('gap1-complete')
     expect(h.finishCalls[0].outcome).toBe('completed') // pre-fix: 'orphan' → dropped
     expect(h.finishCalls[0].resultText).toContain('root cause')
-    // The promotion is logged so the path is observable in prod.
-    expect(h.logs.some((l) => l.includes('in-flight at boot — promoting to live'))).toBe(true)
+    // Fix #5: promotion now requires an observed post-boot growth event
+    // (mtime freshness alone is refused) — the `append` above supplied it,
+    // and the promotion is logged so the path is observable in prod.
+    expect(h.logs.some((l) => l.includes('confirmed live') && l.includes('post-boot JSONL growth'))).toBe(true)
   })
 
-  it('an in-flight-at-boot worker that dies silently is rescued by stall synthesis', () => {
+  it('an in-flight-at-boot worker that dies silently (after proving liveness) is rescued by stall synthesis', () => {
     // Pre-fix, historical entries were skipped by stall detection, so a
     // worker that crossed a restart and then went silent sat running
     // forever — no handback ever. After promotion it gets the safety net.
+    //
+    // Fix #5: promotion additionally requires proof of post-boot liveness —
+    // a single real step (e.g. a narrative line) grows the JSONL past its
+    // boot-time snapshot, confirming this is NOT a worker killed moments
+    // before the restart. Only THEN does it get the stall-synthesis safety
+    // net when it subsequently goes silent for good.
     const h = makeHarness({
       agentId: 'gap1-silent',
       bootLines: [subAgentUserMsg('bg task')],
@@ -239,6 +247,11 @@ describe('Gap 1 — background worker in-flight across a gateway restart', () =>
       silentStallTerminalMs: 120_000,
     })
 
+    h.append(subAgentText('still investigating'))
+    h.advance(600) // one poll observes the post-boot growth → promotes
+
+    expect(h.watcher.getRegistry().get('gap1-silent')?.historical).toBe(false)
+
     h.advance(62_000) // stall threshold crossed
     expect(h.stallTerminalCalls).toHaveLength(0)
     h.advance(121_000) // silent-stall terminal window elapses → synthesis
@@ -247,6 +260,30 @@ describe('Gap 1 — background worker in-flight across a gateway restart', () =>
     expect(h.finishCalls[0].outcome).toBe('completed')
   })
 
+  it('fix #5: an in-flight-at-boot worker that NEVER shows post-boot growth is left historical (no stale completed handback)', () => {
+    // The bug this closes: a worker killed <15min before a restart is
+    // byte-for-byte indistinguishable from a live one by mtime alone. Absent
+    // any actual post-boot growth, it must NOT be promoted — so it can never
+    // synthesise a false 'completed' handback from the pre-restart bytes.
+    const h = makeHarness({
+      agentId: 'gap1-killed-before-restart',
+      bootLines: [subAgentUserMsg('bg task')],
+      stallThresholdMs: 60_000,
+      silentStallTerminalMs: 120_000,
+      inflightPromoteMaxAgeMs: 60_000,
+    })
+
+    // No append — the file never grows again after boot.
+    h.advance(62_000)
+    h.advance(121_000)
+    h.advance(600_000) // well past the promotion window too
+
+    expect(h.watcher.getRegistry().get('gap1-killed-before-restart')?.historical).toBe(true)
+    expect(h.stallTerminalCalls).toHaveLength(0)
+    expect(h.finishCalls).toHaveLength(0)
+    expect(h.logs.some((l) => l.includes('never observed post-boot JSONL growth'))).toBe(true)
+  })
+
   it('a worker already DONE at boot stays suppressed (no spurious replay)', () => {
     // The legitimate use of `historical`: a worker that finished in a prior
     // session must NOT re-fire a handback on every restart. This is the
@@ -298,7 +335,8 @@ describe('Gap 1 freshness gate — v0.14.24 stale-replay regression', () => {
 
     expect(h.finishCalls).toHaveLength(1)
     expect(h.finishCalls[0].outcome).toBe('completed')
-    expect(h.logs.some((l) => l.includes('promoting to live'))).toBe(true)
+    // Fix #5: the append above supplies the required post-boot growth proof.
+    expect(h.logs.some((l) => l.includes('confirmed live'))).toBe(true)
   })
 
   it('kill-switch (bootPromoteEnabled=false) suppresses even a fresh running-at-boot worker', () => {