switchroom 0.18.6 → 0.18.7

package/telegram-plugin/tests/resume-inbound-builder.test.ts

@@ -18,7 +18,13 @@ import {
   humanizeElapsed,
   buildResumeInterruptedInbound,
   buildResumeWatchdogReportInbound,
+  buildResumeDeferredReportInbound,
+  isResumeSyntheticTurn,
   selectResumeBuilder,
+  decideBootResumeKind,
+  RESUME_SYNTHETIC_PROMPT_PREFIX,
+  renderInterruptedSubagentsBlock,
+  type InterruptedSubagent,
 } from '../gateway/resume-inbound-builder.js'
 import type { Turn, TurnEndedVia } from '../registry/turns-schema.js'
 
@@ -158,6 +164,155 @@ describe('buildResumeInterruptedInbound', () => {
   })
 })
 
+describe('interrupted sub-agent block', () => {
+  const twoRunning: InterruptedSubagent[] = [
+    { agentType: 'worker', description: 'refactor the auth module and add tests', status: 'running' },
+    { agentType: 'researcher', description: 'survey the pricing pages of 5 competitors', status: 'running' },
+  ]
+
+  it('renderInterruptedSubagentsBlock lists each worker with type + prompt', () => {
+    const block = renderInterruptedSubagentsBlock(twoRunning)
+    expect(block).toContain('2 sub-agents were still')
+    expect(block).toContain('did NOT complete')
+    expect(block).toContain('[worker]')
+    expect(block).toContain('refactor the auth module and add tests')
+    expect(block).toContain('[researcher]')
+    expect(block).toContain('survey the pricing pages of 5 competitors')
+    expect(block).toContain('Re-dispatch the ones still needed')
+  })
+
+  it('returns empty string when there are no in-flight sub-agents', () => {
+    expect(renderInterruptedSubagentsBlock(undefined)).toBe('')
+    expect(renderInterruptedSubagentsBlock([])).toBe('')
+  })
+
+  it('interrupted-turn inbound contains BOTH running sub-agents', () => {
+    const msg = buildResumeInterruptedInbound({ turn: makeTurn(), subagents: twoRunning })
+    expect(msg.text).toContain('refactor the auth module and add tests')
+    expect(msg.text).toContain('survey the pricing pages of 5 competitors')
+    expect(msg.text).toContain('did NOT complete')
+    expect(msg.text).toContain('Re-dispatch the ones still needed')
+  })
+
+  it('interrupted-turn inbound is UNCHANGED when no sub-agents were running', () => {
+    const withNone = buildResumeInterruptedInbound({ turn: makeTurn(), subagents: [] })
+    const bare = buildResumeInterruptedInbound({ turn: makeTurn() })
+    expect(withNone.text).toBe(bare.text)
+    expect(withNone.text).not.toContain('did NOT complete')
+  })
+
+  it('truncates each dispatch prompt to ~200 chars', () => {
+    const long = 'x'.repeat(400)
+    const block = renderInterruptedSubagentsBlock([{ agentType: 'worker', description: long }])
+    // The 400-char prompt must not survive in full; the entry line is capped.
+    expect(block).not.toContain(long)
+    expect(block).toContain('…')
+    // 200-char cap → the truncated slice (199 chars + ellipsis) is present.
+    expect(block).toContain('x'.repeat(199))
+    expect(block).not.toContain('x'.repeat(201))
+  })
+
+  it('caps the list at 10 and summarises the remainder', () => {
+    const many: InterruptedSubagent[] = Array.from({ length: 14 }, (_, i) => ({
+      agentType: 'worker',
+      description: `task number ${i + 1}`,
+    }))
+    const block = renderInterruptedSubagentsBlock(many)
+    expect(block).toContain('14 sub-agents were still')
+    expect(block).toContain('task number 10')
+    expect(block).not.toContain('task number 11')
+    expect(block).toContain('…and 4 more.')
+    // Exactly 10 numbered entries rendered.
+    const numbered = block.match(/^\s+\d+\. \[/gm) ?? []
+    expect(numbered.length).toBe(10)
+  })
+
+  it('falls back to a generic label + placeholder when type/prompt are missing', () => {
+    const block = renderInterruptedSubagentsBlock([{ agentType: null, description: null }])
+    expect(block).toContain('[sub-agent]')
+    expect(block).toContain('(no task description recorded)')
+  })
+
+  it('singularises a single killed sub-agent', () => {
+    const block = renderInterruptedSubagentsBlock([{ agentType: 'worker', description: 'do X' }])
+    expect(block).toContain('1 sub-agent was still')
+    expect(block).not.toContain('1 sub-agents')
+  })
+
+  it('codepoint-safe truncation never splits a surrogate pair', () => {
+    // 199 ASCII chars, then an astral-plane emoji (2 UTF-16 code units)
+    // straddling the cap. A code-unit slice would cut the pair in half and
+    // leave a lone surrogate; the codepoint-safe slice must not.
+    const desc = 'a'.repeat(199) + '🚀' + 'b'.repeat(50)
+    const block = renderInterruptedSubagentsBlock([{ agentType: 'worker', description: desc }])
+    expect(block).toContain('…')
+    // No lone surrogates anywhere in the rendered block.
+    expect(/[\uD800-\uDBFF](?![\uDC00-\uDFFF])|(?<![\uD800-\uDBFF])[\uDC00-\uDFFF]/.test(block)).toBe(false)
+    expect(block).toBe(block.normalize('NFC')) // sanity: still a well-formed string
+  })
+
+  it('the watchdog report inbound carries the block in DEFERRED form (ask-first contract)', () => {
+    const msg = buildResumeWatchdogReportInbound({
+      turn: makeTurn({ ended_via: 'timeout' }),
+      idleMs: 300_000,
+      subagents: twoRunning,
+    })
+    expect(msg.text).toContain('did NOT complete')
+    expect(msg.text).toContain('refactor the auth module and add tests')
+    // Deferred wording: re-dispatch is conditional on the user asking to retry…
+    expect(msg.text).toContain("If the user asks you to retry, they'll need re-dispatching")
+    expect(msg.text).toContain("don't assume their work landed")
+    // …and the resume-path imperative must NOT appear — it would contradict
+    // the watchdog inbound's "Do NOT silently resume … ask" hang-safety gate.
+    expect(msg.text).not.toContain('Re-dispatch the ones still needed')
+    expect(msg.text).not.toContain('before declaring the task done')
+  })
+
+  it('the resume-path inbound keeps the assertive imperative (and not the deferred form)', () => {
+    const msg = buildResumeInterruptedInbound({ turn: makeTurn(), subagents: twoRunning })
+    expect(msg.text).toContain('Re-dispatch the ones still needed before declaring the task done')
+    expect(msg.text).not.toContain('If the user asks you to retry')
+  })
+
+  for (const reason of ['loop-guard', 'clean-restart-suppressed'] as const) {
+    it(`the deferred report (${reason}) carries the block in DEFERRED form — suppressed resumes still name worker deaths`, () => {
+      const msg = buildResumeDeferredReportInbound({
+        turn: makeTurn(),
+        reason,
+        subagents: twoRunning,
+      })
+      expect(msg.text).toContain('did NOT complete')
+      expect(msg.text).toContain('refactor the auth module and add tests')
+      expect(msg.text).toContain('survey the pricing pages of 5 competitors')
+      // Deferred wording only — never the resume-path imperative, which would
+      // contradict this inbound's "Do NOT silently resume … ask" contract.
+      expect(msg.text).toContain("If the user asks you to retry, they'll need re-dispatching")
+      expect(msg.text).not.toContain('Re-dispatch the ones still needed')
+      expect(msg.text).not.toContain('before declaring the task done')
+      // Appending the block must not disturb the loop-guard anchor at pos 0.
+      expect(msg.text.startsWith(RESUME_SYNTHETIC_PROMPT_PREFIX)).toBe(true)
+    })
+  }
+
+  it('deferred report without subagents is unchanged (no block)', () => {
+    const withNone = buildResumeDeferredReportInbound({ turn: makeTurn(), reason: 'loop-guard', subagents: [] })
+    const bare = buildResumeDeferredReportInbound({ turn: makeTurn(), reason: 'loop-guard' })
+    expect(withNone.text).toBe(bare.text)
+    expect(withNone.text).not.toContain('did NOT complete')
+  })
+
+  it('appending the block preserves the RESUME_SYNTHETIC_PROMPT_PREFIX anchor on resume + watchdog inbounds too', () => {
+    const resume = buildResumeInterruptedInbound({ turn: makeTurn(), subagents: twoRunning })
+    expect(resume.text.startsWith(RESUME_SYNTHETIC_PROMPT_PREFIX)).toBe(true)
+    const report = buildResumeWatchdogReportInbound({
+      turn: makeTurn({ ended_via: 'timeout' }),
+      idleMs: 300_000,
+      subagents: twoRunning,
+    })
+    expect(report.text.startsWith(RESUME_SYNTHETIC_PROMPT_PREFIX)).toBe(true)
+  })
+})
+
 describe('buildResumeWatchdogReportInbound', () => {
   it('sets the resume_watchdog_timeout source and idle_ms passthrough', () => {
     const turn = makeTurn({ ended_via: 'timeout' })
@@ -243,3 +398,134 @@ describe('selectResumeBuilder', () => {
     expect(selectResumeBuilder('restart', { ageMs: MAX + 1 })).toBe('resume') // needs BOTH to cap
   })
 })
+
+// ---------------------------------------------------------------------------
+// Loop-guard: RESUME_SYNTHETIC_PROMPT_PREFIX / isResumeSyntheticTurn
+// ---------------------------------------------------------------------------
+
+describe('resume synthetic-turn detection (loop-guard anchor)', () => {
+  it('EVERY synthetic boot inbound text starts with the machine-stable prefix', () => {
+    // The loop-guard keys on this prefix landing in user_prompt_preview, so if
+    // a prose edit drops it the chain-cap silently breaks. Pin it here.
+    const turn = makeTurn({ user_prompt_preview: 'do the thing' })
+    expect(buildResumeInterruptedInbound({ turn }).text.startsWith(RESUME_SYNTHETIC_PROMPT_PREFIX)).toBe(true)
+    expect(
+      buildResumeWatchdogReportInbound({ turn: makeTurn({ ended_via: 'timeout' }), idleMs: 1000 }).text.startsWith(
+        RESUME_SYNTHETIC_PROMPT_PREFIX,
+      ),
+    ).toBe(true)
+    expect(
+      buildResumeDeferredReportInbound({ turn, reason: 'loop-guard' }).text.startsWith(
+        RESUME_SYNTHETIC_PROMPT_PREFIX,
+      ),
+    ).toBe(true)
+    expect(
+      buildResumeDeferredReportInbound({ turn, reason: 'clean-restart-suppressed' }).text.startsWith(
+        RESUME_SYNTHETIC_PROMPT_PREFIX,
+      ),
+    ).toBe(true)
+  })
+
+  it('isResumeSyntheticTurn is true for a turn whose preview is a synthetic prompt', () => {
+    const synthetic = buildResumeInterruptedInbound({ turn: makeTurn() })
+    // A resume turn stores the first ~200 chars of the synthetic text as its
+    // preview (channel wrapper stripped) — simulate that.
+    const resumeTurn = makeTurn({ user_prompt_preview: synthetic.text.slice(0, 200) })
+    expect(isResumeSyntheticTurn(resumeTurn)).toBe(true)
+  })
+
+  it('isResumeSyntheticTurn is false for real user work and for null preview', () => {
+    expect(isResumeSyntheticTurn(makeTurn({ user_prompt_preview: 'refactor the auth module' }))).toBe(false)
+    expect(isResumeSyntheticTurn(makeTurn({ user_prompt_preview: null }))).toBe(false)
+  })
+})
+
+// ---------------------------------------------------------------------------
+// buildResumeDeferredReportInbound
+// ---------------------------------------------------------------------------
+
+describe('buildResumeDeferredReportInbound', () => {
+  it('emits source=resume_deferred and carries the dedup anchor + reason', () => {
+    const turn = makeTurn({ turn_key: 'zz:3' })
+    const msg = buildResumeDeferredReportInbound({ turn, reason: 'loop-guard' })
+    expect(msg.meta.source).toBe('resume_deferred')
+    expect(msg.meta.resume_turn_key).toBe('zz:3')
+    expect(msg.meta.defer_reason).toBe('loop-guard')
+  })
+
+  it('loop-guard framing tells the model the chain was capped, not to resume', () => {
+    const msg = buildResumeDeferredReportInbound({ turn: makeTurn(), reason: 'loop-guard' })
+    expect(msg.text.toLowerCase()).toContain('resume of earlier interrupted work')
+    expect(msg.text).toContain('Do NOT silently resume')
+  })
+
+  it('clean-restart-suppressed framing cites boot_resume: never', () => {
+    const msg = buildResumeDeferredReportInbound({ turn: makeTurn(), reason: 'clean-restart-suppressed' })
+    expect(msg.text).toContain('boot_resume: never')
+    expect(msg.text).toContain('Do NOT silently resume')
+  })
+
+  it('routes to the origin thread when the turn carried one', () => {
+    const turn = makeTurn({ chat_id: '-100999', thread_id: '77' })
+    const msg = buildResumeDeferredReportInbound({ turn, reason: 'loop-guard' })
+    expect(msg.chatId).toBe('-100999')
+    expect(msg.threadId).toBe(77)
+    expect(msg.meta.message_thread_id).toBe('77')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// decideBootResumeKind — boot-resume precedence + bounded resume chain
+// ---------------------------------------------------------------------------
+
+describe('decideBootResumeKind', () => {
+  const MAX = 10_800_000 // 3h
+
+  it('resumes genuinely in-flight work after a deliberate restart (not suppressed)', () => {
+    // The core product fix: clean restart mid-turn → resume, not silence.
+    const pending = makeTurn({ ended_via: 'restart', user_prompt_preview: 'ship the release' })
+    expect(decideBootResumeKind({ pending, suppressed: false, ageMs: 1000, maxAgeMs: MAX })).toBe('resume')
+  })
+
+  it("boot_resume:never (suppressed) → 'defer-suppressed' passive report, never silence", () => {
+    const pending = makeTurn({ ended_via: 'restart', user_prompt_preview: 'ship the release' })
+    expect(decideBootResumeKind({ pending, suppressed: true, ageMs: 1000, maxAgeMs: MAX })).toBe('defer-suppressed')
+  })
+
+  it('watchdog timeout still reports even when not suppressed', () => {
+    const pending = makeTurn({ ended_via: 'timeout', user_prompt_preview: 'ship the release' })
+    expect(decideBootResumeKind({ pending, suppressed: false, ageMs: 1000, maxAgeMs: MAX })).toBe('report')
+  })
+
+  it('BOUNDED CHAIN: a restart DURING a resume turn does NOT re-resume — loop-guard fires', () => {
+    // Simulate the chain the coordinator flagged:
+    //   A: real work, interrupted → resume R1 (turn B created from R1's text)
+    //   restart lands during B → pending is B, whose preview IS the synthetic
+    //   resume prompt. We must NOT mint a second resume (endless loop risk).
+    const r1 = buildResumeInterruptedInbound({ turn: makeTurn({ user_prompt_preview: 'real work' }) })
+    const turnB = makeTurn({ ended_via: 'restart', user_prompt_preview: r1.text.slice(0, 200) })
+    // Even though NOT suppressed (would normally resume), the loop-guard wins:
+    expect(decideBootResumeKind({ pending: turnB, suppressed: false, ageMs: 1000, maxAgeMs: MAX })).toBe('defer-loop')
+  })
+
+  it('BOUNDED CHAIN: a restart during a deferred-report turn stays capped (still defer-loop, never resume)', () => {
+    // Depth does not grow: a report-of-report is still a passive report, never
+    // a resume — so no unbounded restart→resume→restart chain can form.
+    const deferred = buildResumeDeferredReportInbound({ turn: makeTurn(), reason: 'loop-guard' })
+    const turnC = makeTurn({ ended_via: 'restart', user_prompt_preview: deferred.text.slice(0, 200) })
+    const kind = decideBootResumeKind({ pending: turnC, suppressed: false, ageMs: 1000, maxAgeMs: MAX })
+    expect(kind).toBe('defer-loop')
+    expect(kind).not.toBe('resume')
+  })
+
+  it('loop-guard takes precedence over suppression too (synthetic turn never resumes or double-reports as resume)', () => {
+    const r1 = buildResumeInterruptedInbound({ turn: makeTurn() })
+    const turnB = makeTurn({ ended_via: 'restart', user_prompt_preview: r1.text.slice(0, 200) })
+    expect(decideBootResumeKind({ pending: turnB, suppressed: true, ageMs: 1000, maxAgeMs: MAX })).toBe('defer-loop')
+  })
+
+  it('stale in-flight work downgrades to report when older than maxAgeMs', () => {
+    const pending = makeTurn({ ended_via: 'restart', user_prompt_preview: 'stale work' })
+    expect(decideBootResumeKind({ pending, suppressed: false, ageMs: MAX + 1, maxAgeMs: MAX })).toBe('report')
+  })
+})

package/telegram-plugin/tests/session-model-source.test.ts

@@ -0,0 +1,67 @@
+/**
+ * Pins the /status session-model freshness contract (#2982 + live-model PR):
+ * the FRESHEST observation wins between the transcript's `message.model` and
+ * the /model override, arbitrated by a shared monotonic sequence. This is the
+ * "model display must never be stale" invariant:
+ *
+ *   - override set AFTER the last transcript observation (idle-time /model
+ *     switch, no assistant line yet) → /status shows the override;
+ *   - a new assistant line after that → the transcript wins again.
+ */
+import { describe, it, expect } from 'vitest'
+import { createSessionModelSource } from '../gateway/session-model-source.js'
+
+describe('createSessionModelSource — freshest observation wins', () => {
+  it('returns null when neither source has reported', () => {
+    const s = createSessionModelSource()
+    expect(s.resolve()).toBeNull()
+    expect(s.getOverride()).toBeNull()
+  })
+
+  it('transcript-only → transcript', () => {
+    const s = createSessionModelSource()
+    s.noteTranscriptModel('claude-opus-4-8')
+    expect(s.resolve()).toEqual({ model: 'claude-opus-4-8', source: 'transcript' })
+  })
+
+  it('override-only → override (fresh boot before the first assistant line)', () => {
+    const s = createSessionModelSource()
+    s.setOverride('sr-glm-5')
+    expect(s.resolve()).toEqual({ model: 'sr-glm-5', source: 'override' })
+  })
+
+  it('idle-after-switch window: an override set AFTER the last transcript line wins', () => {
+    // The #2982 regression this pins: /model switch while idle — the
+    // transcript still holds the OLD model, the override holds the NEW one.
+    const s = createSessionModelSource()
+    s.noteTranscriptModel('claude-opus-4-8') // old model's last assistant line
+    s.setOverride('Sonnet 5') // confirmed switch, no assistant line yet
+    expect(s.resolve()).toEqual({ model: 'Sonnet 5', source: 'override' })
+  })
+
+  it('a NEW assistant line after the switch reclaims the transcript as the source', () => {
+    const s = createSessionModelSource()
+    s.noteTranscriptModel('claude-opus-4-8')
+    s.setOverride('Sonnet 5')
+    s.noteTranscriptModel('claude-sonnet-5') // first line under the new model
+    expect(s.resolve()).toEqual({ model: 'claude-sonnet-5', source: 'transcript' })
+  })
+
+  it('clearing the override (null) falls back to the transcript', () => {
+    const s = createSessionModelSource()
+    s.noteTranscriptModel('claude-opus-4-8')
+    s.setOverride('sr-glm-5')
+    s.setOverride(null)
+    expect(s.getOverride()).toBeNull()
+    expect(s.resolve()).toEqual({ model: 'claude-opus-4-8', source: 'transcript' })
+  })
+
+  it('getOverride reports the override independent of freshness', () => {
+    const s = createSessionModelSource()
+    s.setOverride('sr-glm-5')
+    s.noteTranscriptModel('claude-opus-4-8') // transcript is now fresher
+    expect(s.resolve()?.source).toBe('transcript')
+    // ...but the override record itself is still readable (menu "session" marker).
+    expect(s.getOverride()).toBe('sr-glm-5')
+  })
+})

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.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',