switchroom 0.18.6 → 0.18.8

package/telegram-plugin/tests/voice-send.test.ts

@@ -0,0 +1,308 @@
+/**
+ * Telegram file_id reuse for the on-demand '🔊 Listen' send path.
+ *
+ * gateway.ts is a 25k-line module with import-time side effects, so the send
+ * decision core lives in ../voice-send.ts (imported by the gateway). These
+ * tests drive the real orchestrator + cache primitive with a mocked bot api,
+ * proving the observable contract the gateway wires up:
+ *
+ *   (a) FIRST tap (no stored id) uploads via InputFile and captures the
+ *       returned file_id onto the cache entry;
+ *   (b) SECOND tap sends BY the file_id string — no disk read, no InputFile;
+ *   (c) a file_id send REJECTED as stale (400) falls back to a re-upload and
+ *       refreshes the stored id, so a dead id never permanently breaks Listen.
+ */
+
+import { describe, it, expect } from 'bun:test'
+import {
+  sendVoiceReusingFileId,
+  extractVoiceFileId,
+  isInvalidTelegramFileIdError,
+  isHttp400Error,
+  type SentVoiceMessage,
+} from '../voice-send.js'
+import { VoiceOnDemandCache } from '../voice-ondemand.js'
+
+/** A minimal grammy-shaped 400 error (duck-typed the way the gateway sees it). */
+function grammy400(description: string): Error {
+  return Object.assign(new Error(description), { error_code: 400, description })
+}
+
+/** Sent-message stub echoing a file_id, as Telegram returns from sendVoice. */
+function sentWithFileId(fileId: string): SentVoiceMessage {
+  return { voice: { file_id: fileId } }
+}
+
+const OGG = new Uint8Array([0x4f, 0x67, 0x67, 0x53]) // OggS magic
+
+describe('sendVoiceReusingFileId — file_id reuse contract', () => {
+  it('(a) first tap: no stored id → uploads via InputFile, captures the id', async () => {
+    const calls: string[] = []
+    let byFileId = 0
+    let uploaded = 0
+    let captured: string | null = null
+
+    const res = await sendVoiceReusingFileId({
+      fileId: null,
+      sendByFileId: async () => {
+        byFileId++
+        return null
+      },
+      loadAudio: async () => {
+        calls.push('loadAudio')
+        return OGG
+      },
+      sendByUpload: async (audio) => {
+        uploaded++
+        expect(audio).toBe(OGG)
+        return sentWithFileId('FILE_ID_1')
+      },
+      onFileId: (id) => {
+        captured = id
+      },
+    })
+
+    expect(res).toEqual({ ok: true, path: 'upload', refreshed: false })
+    expect(byFileId).toBe(0) // never tried the id path — none stored
+    expect(uploaded).toBe(1) // exactly one upload
+    expect(calls).toEqual(['loadAudio']) // audio WAS loaded on the first tap
+    expect(captured).toBe('FILE_ID_1') // id captured for reuse
+  })
+
+  it('(b) second tap: stored id → sends by file_id string, no disk read, no InputFile', async () => {
+    let loadAudioCalls = 0
+    let uploadCalls = 0
+    let sentId: string | null = null
+
+    const res = await sendVoiceReusingFileId({
+      fileId: 'FILE_ID_1',
+      sendByFileId: async (fid) => {
+        sentId = fid
+        return sentWithFileId('FILE_ID_1') // Telegram echoes the same id
+      },
+      loadAudio: async () => {
+        loadAudioCalls++ // MUST NOT happen — proves no disk read
+        return OGG
+      },
+      sendByUpload: async () => {
+        uploadCalls++ // MUST NOT happen — proves no re-upload
+        return null
+      },
+      onFileId: () => {},
+    })
+
+    expect(res).toEqual({ ok: true, path: 'file_id', refreshed: false })
+    expect(sentId).toBe('FILE_ID_1') // sent BY the string id
+    expect(loadAudioCalls).toBe(0) // no disk read
+    expect(uploadCalls).toBe(0) // no InputFile upload
+  })
+
+  it('(c) stale id (400): falls back to re-upload and refreshes the stored id', async () => {
+    let byFileId = 0
+    let uploaded = 0
+    let refreshedTo: string | null = null
+
+    const res = await sendVoiceReusingFileId({
+      fileId: 'STALE_ID',
+      sendByFileId: async () => {
+        byFileId++
+        throw grammy400('Bad Request: wrong file identifier/HTTP URL specified')
+      },
+      loadAudio: async () => OGG,
+      sendByUpload: async () => {
+        uploaded++
+        return sentWithFileId('FRESH_ID')
+      },
+      onFileId: (id) => {
+        refreshedTo = id
+      },
+    })
+
+    expect(res).toEqual({ ok: true, path: 'upload', refreshed: true })
+    expect(byFileId).toBe(1) // tried the stale id once
+    expect(uploaded).toBe(1) // then re-uploaded
+    expect(refreshedTo).toBe('FRESH_ID') // stored id refreshed, not left stale
+  })
+
+  it('a NON-stale send error is a real failure — no silent re-upload', async () => {
+    let uploaded = 0
+    const res = await sendVoiceReusingFileId({
+      fileId: 'FILE_ID_1',
+      sendByFileId: async () => {
+        throw Object.assign(new Error('forbidden'), { error_code: 403 })
+      },
+      loadAudio: async () => OGG,
+      sendByUpload: async () => {
+        uploaded++
+        return null
+      },
+      onFileId: () => {},
+    })
+    expect(res.ok).toBe(false)
+    expect(uploaded).toBe(0) // did NOT paper over a 403 with an upload
+  })
+
+  it('(C1) UNKNOWN-wording 400: re-uploads + refreshes id even outside the stale-id substrings', async () => {
+    // A 400 whose text is NOT in isInvalidTelegramFileIdError's substring set.
+    // Pre-tweak (substring-gated) this classified as send-failed and never
+    // refreshed the id; post-tweak ANY 400 recovers via re-upload.
+    let byFileId = 0
+    let uploaded = 0
+    let refreshedTo: string | null = null
+
+    const err400 = grammy400('Bad Request: some brand-new file rejection wording')
+    expect(isInvalidTelegramFileIdError(err400)).toBe(false) // guard: outside old substrings
+    expect(isHttp400Error(err400)).toBe(true) // but IS a 400 → now re-uploadable
+
+    const res = await sendVoiceReusingFileId({
+      fileId: 'STALE_ID',
+      sendByFileId: async () => {
+        byFileId++
+        throw err400
+      },
+      loadAudio: async () => OGG,
+      sendByUpload: async () => {
+        uploaded++
+        return sentWithFileId('FRESH_ID')
+      },
+      onFileId: (id) => {
+        refreshedTo = id
+      },
+    })
+
+    expect(res).toEqual({ ok: true, path: 'upload', refreshed: true })
+    expect(byFileId).toBe(1) // tried the id once
+    expect(uploaded).toBe(1) // then re-uploaded on the unknown 400
+    expect(refreshedTo).toBe('FRESH_ID') // stored id refreshed, not left stale
+  })
+
+  it('(C1) a network error (no error_code) still does NOT re-upload', async () => {
+    let uploaded = 0
+    const res = await sendVoiceReusingFileId({
+      fileId: 'FILE_ID_1',
+      sendByFileId: async () => {
+        throw new Error('ECONNRESET') // no error_code → not a 400
+      },
+      loadAudio: async () => OGG,
+      sendByUpload: async () => {
+        uploaded++
+        return null
+      },
+      onFileId: () => {},
+    })
+    expect(res.ok).toBe(false)
+    expect(uploaded).toBe(0) // transient network error is a real failure, not a re-upload
+  })
+
+  it('(C1) re-upload after a 400 ALSO fails → returns failure, no second re-upload', async () => {
+    let byFileId = 0
+    let uploaded = 0
+    let refreshed: string | null = null
+
+    const res = await sendVoiceReusingFileId({
+      fileId: 'STALE_ID',
+      sendByFileId: async () => {
+        byFileId++
+        throw grammy400('Bad Request: totally unfamiliar 400 wording')
+      },
+      loadAudio: async () => OGG,
+      sendByUpload: async () => {
+        uploaded++
+        throw grammy400('Bad Request: upload also rejected') // recovery send fails too
+      },
+      onFileId: (id) => {
+        refreshed = id
+      },
+    })
+
+    expect(res.ok).toBe(false)
+    if (!res.ok) expect(res.reason).toBe('send-failed')
+    expect(byFileId).toBe(1) // id tried once
+    expect(uploaded).toBe(1) // re-uploaded exactly once — NO second attempt / loop
+    expect(refreshed).toBeNull() // failed upload never refreshed the id
+  })
+
+  it('no-audio on the upload path returns { ok:false, reason:"no-audio" }', async () => {
+    const res = await sendVoiceReusingFileId({
+      fileId: null,
+      sendByFileId: async () => null,
+      loadAudio: async () => null, // swept + synth unavailable
+      sendByUpload: async () => {
+        throw new Error('should not be called')
+      },
+      onFileId: () => {},
+    })
+    expect(res).toEqual({ ok: false, reason: 'no-audio' })
+  })
+})
+
+describe('extractVoiceFileId / isInvalidTelegramFileIdError', () => {
+  it('extracts a present file_id, ignores missing/empty', () => {
+    expect(extractVoiceFileId({ voice: { file_id: 'abc' } })).toBe('abc')
+    expect(extractVoiceFileId({ voice: {} })).toBeUndefined()
+    expect(extractVoiceFileId({ voice: { file_id: '' } })).toBeUndefined()
+    expect(extractVoiceFileId(null)).toBeUndefined()
+    expect(extractVoiceFileId(undefined)).toBeUndefined()
+  })
+
+  it('classifies a 400 wrong-file-identifier as stale, others as not', () => {
+    expect(
+      isInvalidTelegramFileIdError(grammy400('Bad Request: wrong file identifier/HTTP URL specified')),
+    ).toBe(true)
+    expect(isInvalidTelegramFileIdError(grammy400('Bad Request: wrong remote file identifier'))).toBe(
+      true,
+    )
+    // Not a file_id problem — genuine failures the caller must surface.
+    expect(isInvalidTelegramFileIdError(grammy400('Bad Request: chat not found'))).toBe(false)
+    expect(
+      isInvalidTelegramFileIdError(Object.assign(new Error('forbidden'), { error_code: 403 })),
+    ).toBe(false)
+    expect(isInvalidTelegramFileIdError(new Error('network'))).toBe(false)
+    expect(isInvalidTelegramFileIdError(null)).toBe(false)
+  })
+
+  it('isHttp400Error: true only for error_code 400, wording-agnostic', () => {
+    expect(isHttp400Error(grammy400('any wording at all'))).toBe(true)
+    expect(isHttp400Error(grammy400('Bad Request: chat not found'))).toBe(true) // 400 regardless of text
+    expect(isHttp400Error(Object.assign(new Error('x'), { error_code: 403 }))).toBe(false)
+    expect(isHttp400Error(Object.assign(new Error('x'), { error_code: 500 }))).toBe(false)
+    expect(isHttp400Error(new Error('network'))).toBe(false) // no error_code
+    expect(isHttp400Error(null)).toBe(false)
+    expect(isHttp400Error(undefined)).toBe(false)
+  })
+})
+
+describe('VoiceOnDemandCache.setTelegramFileId — capture + sweep drop', () => {
+  it('stores an id on a live entry and returns it via get()', () => {
+    const cache = new VoiceOnDemandCache()
+    cache.put('tok', { text: 'hi', speed: 1.1 })
+    cache.setTelegramFileId('tok', 'FILE_ID_1')
+    expect(cache.get('tok')?.telegramFileId).toBe('FILE_ID_1')
+  })
+
+  it('ignores an empty id and unknown/evicted tokens', () => {
+    const cache = new VoiceOnDemandCache()
+    cache.put('tok', { text: 'hi', speed: 1.1 })
+    cache.setTelegramFileId('tok', '') // ignored
+    expect(cache.get('tok')?.telegramFileId).toBeUndefined()
+    cache.setTelegramFileId('missing', 'X') // no-op, no throw
+    expect(cache.get('missing')).toBeNull()
+  })
+
+  it('drops the stored id when the 7-day sweep prunes the entry — no resurrection', () => {
+    const cache = new VoiceOnDemandCache()
+    cache.put('tok', { text: 'hi', speed: 1.1 })
+    cache.setTelegramFileId('tok', 'FILE_ID_1')
+    cache.prune(['tok']) // sweep deleted the on-disk file for this token
+    expect(cache.get('tok')).toBeNull() // entry AND its file_id are gone
+  })
+
+  it('does not store an id on an already-expired entry', () => {
+    let t = 1000
+    const cache = new VoiceOnDemandCache({ ttlMs: 100, now: () => t })
+    cache.put('tok', { text: 'hi', speed: 1.1 })
+    t = 2000 // past TTL
+    cache.setTelegramFileId('tok', 'FILE_ID_1') // no-op on expired entry
+    expect(cache.get('tok')).toBeNull()
+  })
+})

package/telegram-plugin/tests/worker-activity-feed.test.ts

@@ -86,6 +86,17 @@ describe('renderWorkerActivity', () => {
     expect(out).not.toContain('<code>')
   })
 
+  it('renders the friendly live model on the worker metrics line', () => {
+    const out = renderWorkerActivity(view({ model: 'claude-sonnet-5' }))
+    expect(out).toContain('_10s · 3 tools · sonnet 5_')
+  })
+
+  it('omits the model tag when the worker model is unknown', () => {
+    const out = renderWorkerActivity(view())
+    expect(out).toContain('_10s · 3 tools_')
+    expect(out).not.toContain('· sonnet')
+  })
+
   it('shows a "starting…" line when no step has run yet', () => {
     const out = renderWorkerActivity(view({ lastTool: null, latestSummary: '' }))
     expect(out).toContain('🛠 **Worker**')

package/telegram-plugin/tests/worker-feed-dispatch.test.ts

@@ -17,6 +17,7 @@ function makeSub(over: Partial<Subagent>): Subagent {
     result_summary: null,
     jsonl_agent_id: 'a37ad7639ae61476c',
     parent_agent_id: null,
+    model: null,
     ...over,
   }
 }
@@ -61,6 +62,85 @@ describe('resolveWorkerFeedDispatch (#2002 regression pin)', () => {
     // flip a foreground turn into a background one.
     expect(resolveWorkerFeedDispatch(null, '').isBackground).toBe(false)
   })
+
+  it('surfaces the persisted registry model as feedModel (first-paint fallback)', () => {
+    const sub = makeSub({ background: true, model: 'claude-opus-4-8' })
+    expect(resolveWorkerFeedDispatch(sub, 'sub-agent').feedModel).toBe('claude-opus-4-8')
+  })
+
+  it('feedModel is null when the row is missing or carries no model', () => {
+    expect(resolveWorkerFeedDispatch(null, 'sub-agent').feedModel).toBeNull()
+    expect(resolveWorkerFeedDispatch(makeSub({ model: null }), 'sub-agent').feedModel).toBeNull()
+  })
+})
+
+describe('gateway onFinish — fix #1: resultText-driven handback fallback (model)', () => {
+  // Mirrors the exact fallback gateway.ts's onFinish handler applies on top
+  // of `resolveWorkerFeedDispatch`'s own result (gateway.ts, onFinish
+  // handler, right after computing `dispatch`):
+  //
+  //   let isBackground = dispatch.isBackground
+  //   if (!dispatch.hasRow && entryBackground == null && resultText.trim().length > 0) {
+  //     isBackground = true
+  //   }
+  //
+  // This is the worst case of the #1 bug: the DB row was never linked
+  // (unlinked `jsonl_agent_id`) AND the watcher's own cached
+  // `entry.background` was also never observed (both `resolveWorkerFeedDispatch`
+  // fallbacks came up empty). A finished worker with actual narrative
+  // result text is far more likely a dropped background handback than a
+  // legitimate foreground no-op, so this degrades to background rather
+  // than silently discarding the result.
+  function applyOnFinishBackgroundFallback(
+    dispatch: { isBackground: boolean; hasRow: boolean },
+    entryBackground: boolean | undefined,
+    resultText: string,
+  ): boolean {
+    let isBackground = dispatch.isBackground
+    if (!dispatch.hasRow && entryBackground == null && resultText.trim().length > 0) {
+      isBackground = true
+    }
+    return isBackground
+  }
+
+  it('meta-missing path: no row, no entry.background, non-empty resultText → routes a handback', () => {
+    const dispatch = resolveWorkerFeedDispatch(null, 'sub-agent', undefined)
+    const result = applyOnFinishBackgroundFallback(dispatch, undefined, 'Here is what I found...')
+    expect(result).toBe(true)
+  })
+
+  it('no-fuzzy-candidate path: no row, no entry.background, non-empty resultText → routes a handback', () => {
+    // Same shape as above — the ambiguous-fuzzy-match-refused case (fix #3)
+    // also leaves jsonl_agent_id unlinked, landing in the same no-row state.
+    const dispatch = resolveWorkerFeedDispatch(null, 'sub-agent', undefined)
+    const result = applyOnFinishBackgroundFallback(dispatch, undefined, 'Task complete: 3 files changed.')
+    expect(result).toBe(true)
+  })
+
+  it('empty resultText with no row/no entry.background does NOT escalate (true foreground no-op preserved)', () => {
+    const dispatch = resolveWorkerFeedDispatch(null, 'sub-agent', undefined)
+    const result = applyOnFinishBackgroundFallback(dispatch, undefined, '   ')
+    expect(result).toBe(false)
+  })
+
+  it('entry.background=false (watcher DID observe it as foreground) is trusted over resultText', () => {
+    const dispatch = resolveWorkerFeedDispatch(null, 'sub-agent', false)
+    const result = applyOnFinishBackgroundFallback(dispatch, false, 'Some prose result anyway.')
+    expect(result).toBe(false)
+  })
+
+  it('entry.background=true (watcher DID observe it) is trusted directly, no resultText fallback needed', () => {
+    const dispatch = resolveWorkerFeedDispatch(null, 'sub-agent', true)
+    const result = applyOnFinishBackgroundFallback(dispatch, true, '')
+    expect(result).toBe(true)
+  })
+
+  it('a present DB row is authoritative — the resultText fallback never overrides a real foreground row', () => {
+    const sub = makeSub({ background: false })
+    const dispatch = resolveWorkerFeedDispatch(sub, 'sub-agent', undefined)
+    const result = applyOnFinishBackgroundFallback(dispatch, undefined, 'Long narrative result...')
+    expect(result).toBe(false)
+  })
 })
 
 // Deterministic PRNG (mulberry32) so a failing case is reproducible from the
@@ -140,6 +220,52 @@ describe('resolveWorkerFeedDispatch — randomized property sweep', () => {
   })
 })
 
+describe('resolveWorkerFeedDispatch — fix #1(+#2): entryBackground fallback', () => {
+  it('falls back to entryBackground=true when the registry row is missing (unlinked jsonl_agent_id)', () => {
+    // Simulates onFinish firing for a background worker whose DB row was
+    // never linked via `jsonl_agent_id` (meta.json missing, or the fuzzy
+    // backfill match never fired) — the watcher's own cached
+    // `entry.background` (seeded at dispatch time / kept fresh by
+    // `readSubTail`'s liveness lookup) is the only signal left.
+    const out = resolveWorkerFeedDispatch(null, 'sub-agent', true)
+    expect(out.isBackground).toBe(true)
+    expect(out.hasRow).toBe(false)
+  })
+
+  it('falls back to entryBackground=false when the row is missing and the entry was foreground', () => {
+    const out = resolveWorkerFeedDispatch(null, 'sub-agent', false)
+    expect(out.isBackground).toBe(false)
+  })
+
+  it('defaults to false when the row is missing AND entryBackground was never observed (undefined)', () => {
+    // Both fallbacks come up empty — worst case, matches pre-fix
+    // behaviour (isBackground=false) at the resolver level. The gateway's
+    // onFinish handler applies its OWN further fallback on top of this
+    // (routing a handback anyway when resultText is non-empty) — that's
+    // pinned separately in the gateway-level test, not here.
+    const out = resolveWorkerFeedDispatch(null, 'sub-agent', undefined)
+    expect(out.isBackground).toBe(false)
+    expect(out.hasRow).toBe(false)
+  })
+
+  it('a present registry row always wins over entryBackground, even when they disagree', () => {
+    // The DB row is the authoritative source whenever it's actually
+    // linked — entryBackground is a pure fallback for the unlinked case,
+    // never a second vote.
+    const sub = makeSub({ background: true })
+    const out = resolveWorkerFeedDispatch(sub, 'sub-agent', false)
+    expect(out.isBackground).toBe(true)
+  })
+
+  it('omitting entryBackground entirely preserves prior 2-arg call-site behaviour', () => {
+    // #2002-era callers pass only 2 args — the optional 3rd param must not
+    // change their observed result.
+    expect(resolveWorkerFeedDispatch(null, 'sub-agent')).toEqual(
+      resolveWorkerFeedDispatch(null, 'sub-agent', undefined),
+    )
+  })
+})
+
 describe('resolveWorkerFeedDispatch — nested/row-presence signals (unified progress cards)', () => {
   it('hasRow=false for a missing registry row (never silently foreground-nest it)', () => {
     const out = resolveWorkerFeedDispatch(null, 'sub-agent')

package/telegram-plugin/tests/worker-pin-reaper.test.ts

@@ -0,0 +1,132 @@
+import { describe, it, expect } from "vitest";
+import {
+  decideWorkerPinReaps,
+  workerAgentIdOfPinKey,
+  WORKER_PIN_TTL_MS_DEFAULT,
+  type WorkerPinCandidate,
+} from "../gateway/worker-pin-reaper.js";
+
+const NOW = 1_750_000_000_000;
+const TTL = WORKER_PIN_TTL_MS_DEFAULT;
+
+function pin(over: Partial<WorkerPinCandidate> = {}): WorkerPinCandidate {
+  return { pinKey: "wk:agent-1", chatId: "123", pinnedAt: NOW - 60_000, ...over };
+}
+
+describe("workerAgentIdOfPinKey", () => {
+  it("extracts the agentId from a wk: key", () => {
+    expect(workerAgentIdOfPinKey("wk:abc123")).toBe("abc123");
+  });
+  it("returns null for non-worker keys (fg:/banner:/tool:) and empty ids", () => {
+    expect(workerAgentIdOfPinKey("fg:123:5")).toBeNull();
+    expect(workerAgentIdOfPinKey("banner:owner")).toBeNull();
+    expect(workerAgentIdOfPinKey("tool:123:9")).toBeNull();
+    expect(workerAgentIdOfPinKey("wk:")).toBeNull();
+  });
+});
+
+describe("decideWorkerPinReaps (#3001 mid-session wk: sweep)", () => {
+  it("reaps a pin whose worker is terminal, however young the pin is", () => {
+    const reaps = decideWorkerPinReaps({
+      pins: [pin({ pinnedAt: NOW - 1_000 })],
+      statusOf: () => 'terminal' as const,
+      ttlMs: TTL,
+      now: NOW,
+    });
+    expect(reaps).toHaveLength(1);
+    expect(reaps[0].reason).toBe("terminal");
+    expect(reaps[0].pinKey).toBe("wk:agent-1");
+  });
+
+  it("reaps a non-terminal pin once it exceeds the TTL", () => {
+    const reaps = decideWorkerPinReaps({
+      pins: [pin({ pinnedAt: NOW - TTL })],
+      statusOf: () => 'unknown' as const,
+      ttlMs: TTL,
+      now: NOW,
+    });
+    expect(reaps).toHaveLength(1);
+    expect(reaps[0].reason).toBe("ttl");
+  });
+
+  it("NEVER touches a pin younger than the TTL when the registry cannot vouch (unknown)", () => {
+    const reaps = decideWorkerPinReaps({
+      pins: [pin({ pinnedAt: NOW - TTL + 1 })],
+      statusOf: () => 'unknown' as const,
+      ttlMs: TTL,
+      now: NOW,
+    });
+    expect(reaps).toHaveLength(0);
+  });
+
+  it("ignores non-worker keys entirely (fg:/banner:/tool: are not its job)", () => {
+    const reaps = decideWorkerPinReaps({
+      pins: [
+        pin({ pinKey: "fg:123:5", pinnedAt: NOW - 10 * TTL }),
+        pin({ pinKey: "banner:owner", pinnedAt: NOW - 10 * TTL }),
+        pin({ pinKey: "tool:123:9", pinnedAt: NOW - 10 * TTL }),
+      ],
+      statusOf: () => 'terminal' as const,
+      ttlMs: TTL,
+      now: NOW,
+    });
+    expect(reaps).toHaveLength(0);
+  });
+
+  it("skips a candidate with no chat id (cannot unpin without one)", () => {
+    const reaps = decideWorkerPinReaps({
+      pins: [pin({ chatId: "", pinnedAt: NOW - 10 * TTL })],
+      statusOf: () => 'terminal' as const,
+      ttlMs: TTL,
+      now: NOW,
+    });
+    expect(reaps).toHaveLength(0);
+  });
+
+  it("a registry-confirmed RUNNING worker keeps its pin PAST the TTL (no unpin/re-pin churn on healthy long workers)", () => {
+    const reaps = decideWorkerPinReaps({
+      pins: [pin({ pinnedAt: NOW - 10 * TTL })],
+      statusOf: () => 'running' as const,
+      ttlMs: TTL,
+      now: NOW,
+    });
+    expect(reaps).toHaveLength(0);
+  });
+
+  it("status is consulted per-agent: terminal reaps young, running exempts old, unknown falls to the TTL gate", () => {
+    const seen: string[] = [];
+    const reaps = decideWorkerPinReaps({
+      pins: [
+        pin({ pinKey: "wk:done", pinnedAt: NOW - 1_000 }),
+        pin({ pinKey: "wk:running-old", pinnedAt: NOW - TTL - 1 }),
+        pin({ pinKey: "wk:unknown-young", pinnedAt: NOW - 1_000 }),
+        pin({ pinKey: "wk:unknown-old", pinnedAt: NOW - TTL - 1 }),
+      ],
+      statusOf: (agentId) => {
+        seen.push(agentId);
+        if (agentId === "done") return "terminal";
+        if (agentId === "running-old") return "running";
+        return "unknown";
+      },
+      ttlMs: TTL,
+      now: NOW,
+    });
+    expect(seen).toEqual(["done", "running-old", "unknown-young", "unknown-old"]);
+    expect(reaps.map((r) => [r.pinKey, r.reason])).toEqual([
+      ["wk:done", "terminal"],
+      ["wk:unknown-old", "ttl"],
+    ]);
+  });
+
+  it("registry hiccup ('unknown') never unpins a young pin — the caller's contract on statusOf degrade", () => {
+    // The gateway wraps its DB lookup and degrades to 'unknown'. This pins the
+    // pure module's side of the contract: unknown + young pin = untouched.
+    const reaps = decideWorkerPinReaps({
+      pins: [pin()],
+      statusOf: () => 'unknown' as const,
+      ttlMs: TTL,
+      now: NOW,
+    });
+    expect(reaps).toHaveLength(0);
+  });
+});

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

@@ -91,6 +91,7 @@ import {
 } from './status-no-truncate.js'
 import { escapeMarkdown, stripMarkdown, truncate, stackCardLines } from './card-format.js'
 import { isTelegramSurfaceTool } from './tool-names.js'
+import { formatModelLabel } from './model-label.js'
 
 /**
  * Optional header for the main-session activity card, matching the worker
@@ -106,6 +107,14 @@ export interface SessionActivityHeader {
   elapsedMs: number
   toolCount: number
   state: 'running' | 'done'
+  /**
+   * Live model in use, as a raw resolved model id (e.g. `claude-opus-4-8`,
+   * `sr-glm-5`) sourced from the transcript. Rendered as a short friendly form
+   * appended to the metrics line (`… · opus 4.8`). Omitted when unknown — the
+   * card never guesses from config. Formatting + sentinel-filtering live in
+   * `formatModelLabel` (model-label.ts).
+   */
+  model?: string
 }
 
 /**
@@ -173,14 +182,19 @@ export function renderActivityHeader(
   elapsedMs: number,
   toolCount: number,
   state: 'running' | 'done' | 'failed',
+  model?: string,
 ): [string, string] {
   const toolWord = toolCount === 1 ? 'tool' : 'tools'
   const elapsed = formatFeedElapsed(elapsedMs)
   const descPart = description.length > 0 ? ` · _${escapeMarkdown(description)}_` : ''
   const line1 = `${emoji} **${escapeMarkdown(label)}**${descPart}`
+  // Subtle live-model tag: joins the existing dot-separated metrics (never a new
+  // line). formatModelLabel returns null for absent/sentinel values → no suffix.
+  const modelLabel = formatModelLabel(model)
+  const modelPart = modelLabel != null ? ` · ${escapeMarkdown(modelLabel)}` : ''
   const line2 = state === 'running'
-    ? `_${elapsed} · ${toolCount} ${toolWord}_`
-    : `_${state} · ${toolCount} ${toolWord} · ${elapsed}_`
+    ? `_${elapsed} · ${toolCount} ${toolWord}${modelPart}_`
+    : `_${state} · ${toolCount} ${toolWord} · ${elapsed}${modelPart}_`
   return [line1, line2]
 }
 
@@ -270,6 +284,9 @@ export interface StatusCardHeader {
   elapsedMs: number
   toolCount: number
   state: 'running' | 'done' | 'failed'
+  /** Live model id (raw, e.g. `claude-opus-4-8`) — rendered as a short friendly
+   *  tag on the metrics line via `formatModelLabel`. Omitted when unknown. */
+  model?: string
 }
 
 /** Inputs to the unified status-card renderer. */
@@ -321,6 +338,7 @@ export function renderStatusCard(opts: StatusCardOpts): string | null {
         // when the result block is empty. The agent surface never passes
         // 'failed', so only the worker card is affected.
         header.state,
+        header.model,
       )
     : []
 
@@ -476,6 +494,7 @@ export function renderActivityFeed(
           elapsedMs: header.elapsedMs,
           toolCount: header.toolCount,
           state: header.state,
+          model: header.model,
         }
       : undefined,
     steps: lines,
@@ -527,6 +546,7 @@ export function renderActivityFeedWithNested(
           elapsedMs: header.elapsedMs,
           toolCount: header.toolCount,
           state: header.state,
+          model: header.model,
         }
       : undefined,
     steps: lines,