switchroom 0.20.11 → 0.20.12

package/telegram-plugin/hooks/hooks.json

@@ -5,16 +5,17 @@
         "hooks": [
           {
             "type": "command",
-            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" node \"${CLAUDE_PLUGIN_ROOT}/hooks/secret-guard-pretool.mjs\"",
+            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" bun \"${CLAUDE_PLUGIN_ROOT}/hooks/secret-guard-pretool.mjs\"",
             "timeout": 10
           }
         ]
       },
       {
+        "matcher": "^mcp__switchroom-telegram__(reply|stream_reply)$",
         "hooks": [
           {
             "type": "command",
-            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" node \"${CLAUDE_PLUGIN_ROOT}/hooks/sentinel-reply-guard-pretool.mjs\"",
+            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" bun \"${CLAUDE_PLUGIN_ROOT}/hooks/sentinel-reply-guard-pretool.mjs\"",
             "timeout": 5
           }
         ]
@@ -24,7 +25,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" node \"${CLAUDE_PLUGIN_ROOT}/hooks/subagent-tracker-pretool.mjs\"",
+            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" bun \"${CLAUDE_PLUGIN_ROOT}/hooks/subagent-tracker-pretool.mjs\"",
             "timeout": 10
           }
         ]
@@ -33,7 +34,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" node \"${CLAUDE_PLUGIN_ROOT}/hooks/tool-label-pretool.mjs\"",
+            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" bun \"${CLAUDE_PLUGIN_ROOT}/hooks/tool-label-pretool.mjs\"",
             "timeout": 5
           }
         ]
@@ -43,7 +44,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" node \"${CLAUDE_PLUGIN_ROOT}/hooks/repo-context-pretool.mjs\"",
+            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" bun \"${CLAUDE_PLUGIN_ROOT}/hooks/repo-context-pretool.mjs\"",
             "timeout": 5
           }
         ]
@@ -55,7 +56,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" node \"${CLAUDE_PLUGIN_ROOT}/hooks/subagent-tracker-posttool.mjs\"",
+            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" bun \"${CLAUDE_PLUGIN_ROOT}/hooks/subagent-tracker-posttool.mjs\"",
             "timeout": 10
           }
         ]
@@ -65,7 +66,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" node \"${CLAUDE_PLUGIN_ROOT}/hooks/sandbox-hint-posttool.mjs\"",
+            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" bun \"${CLAUDE_PLUGIN_ROOT}/hooks/sandbox-hint-posttool.mjs\"",
             "timeout": 3
           }
         ]
@@ -76,7 +77,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" node \"${CLAUDE_PLUGIN_ROOT}/hooks/compaction-marker-precompact.mjs\"",
+            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" bun \"${CLAUDE_PLUGIN_ROOT}/hooks/compaction-marker-precompact.mjs\"",
             "timeout": 5
           }
         ]
@@ -87,7 +88,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" node \"${CLAUDE_PLUGIN_ROOT}/hooks/secret-scrub-stop.mjs\"",
+            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" bun \"${CLAUDE_PLUGIN_ROOT}/hooks/secret-scrub-stop.mjs\"",
             "timeout": 15,
             "async": true
           }
@@ -97,7 +98,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" node \"${CLAUDE_PLUGIN_ROOT}/hooks/silent-end-interrupt-stop.mjs\"",
+            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" bun \"${CLAUDE_PLUGIN_ROOT}/hooks/silent-end-interrupt-stop.mjs\"",
             "timeout": 5
           }
         ]
@@ -106,7 +107,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" node \"${CLAUDE_PLUGIN_ROOT}/hooks/dispatch-claim-stop.mjs\"",
+            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" bun \"${CLAUDE_PLUGIN_ROOT}/hooks/dispatch-claim-stop.mjs\"",
             "timeout": 5
           }
         ]
@@ -115,7 +116,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" node \"${CLAUDE_PLUGIN_ROOT}/hooks/tool-label-stop.mjs\"",
+            "command": "sh \"${CLAUDE_PLUGIN_ROOT}/hooks/run-hook.sh\" bun \"${CLAUDE_PLUGIN_ROOT}/hooks/tool-label-stop.mjs\"",
             "timeout": 5,
             "async": true
           }

package/telegram-plugin/hooks/narration-classify.mjs

@@ -108,7 +108,7 @@ export function isStructuralNarration(text, followedByToolUse) {
  * follow-up, MF4). A text block followed ONLY by tools in this set is still the
  * TERMINAL answer for backstop-coalescing purposes — these tools carry no
  * model-authored answer text and are the only ones plausibly fired AFTER a
- * terminal answer (answer, then react / pin / typing / edit). Everything NOT in
+ * terminal answer (answer, then react / typing / edit). Everything NOT in
  * this set — work / deliverable tools (download_attachment, get_recent_messages,
  * send_checklist, ask_user, …) and every non-telegram tool (retain / read /
  * bash / web / …) — is turn-CONTINUING: a text block a real tool followed is
@@ -123,7 +123,6 @@ export function isStructuralNarration(text, followedByToolUse) {
 export const EPHEMERAL_TOOLS = new Set([
   'react',
   'send_typing',
-  'pin_message',
   'delete_message',
   'edit_message',
 ])

package/telegram-plugin/hooks/silent-end-scan.mjs

@@ -41,7 +41,7 @@
 // Cross-checked the full tool surface in `telegram-plugin/bridge/bridge.ts`
 // (`TOOL_SCHEMAS`, kept in sync with `gateway/gateway.ts`): `edit_message`
 // explicitly does NOT ping/deliver a fresh answer (its own description says
-// "send a new reply when a long task completes"); `react`, `pin_message`,
+// "send a new reply when a long task completes"); `react`,
 // `delete_message`, `forward_message`, `send_typing`, `download_attachment`,
 // `get_recent_messages` carry no model-authored answer text at all;
 // `send_checklist` / `send_sticker` / `send_gif` / `ask_user` /

package/telegram-plugin/status-pin.ts

@@ -210,12 +210,9 @@ export function isUnpinTerminalError(err: unknown): boolean {
  * Deliberately IN-MEMORY / per-boot only: pin rights may be granted later, and
  * Telegram surfaces the new permission to the bot only on a fresh chat-member
  * fetch — a gateway restart. Clearing the cache on restart is therefore the
- * correct re-enable trigger. An explicit `pin_message` tool success in a chat
- * also clears its entry (rights were granted mid-session).
+ * correct re-enable trigger.
  *
- * Scope: the AUTO status-pin path only. The explicit `pin_message` MCP tool
- * never consults this cache — it always attempts and surfaces the error to the
- * agent as a normal tool error.
+ * Scope: the AUTO status-pin path only (`pin_status_while_working`).
  */
 export class PinRightsCache {
   private readonly blocked = new Set<string>()

package/telegram-plugin/tests/backstop-exactly-once.test.ts

@@ -121,9 +121,9 @@ describe('selectBackstopDelivery — deterministic backstop coalescer (#3513 fol
 // ── isEphemeralTool — MF4 exact set ─────────────────────────────────────────
 
 describe('isEphemeralTool — the exact ephemeral surface set (MF4)', () => {
-  it('recognises exactly {react, send_typing, pin_message, delete_message, edit_message}, MCP-prefixed or bare', () => {
+  it('recognises exactly {react, send_typing, delete_message, edit_message}, MCP-prefixed or bare', () => {
     expect([...EPHEMERAL_TOOLS].sort()).toEqual(
-      ['delete_message', 'edit_message', 'pin_message', 'react', 'send_typing'].sort(),
+      ['delete_message', 'edit_message', 'react', 'send_typing'].sort(),
     )
     for (const t of EPHEMERAL_TOOLS) {
       expect(isEphemeralTool(t)).toBe(true)
@@ -132,6 +132,12 @@ describe('isEphemeralTool — the exact ephemeral surface set (MF4)', () => {
     }
   })
 
+  it('pin_message is NOT ephemeral — the pin_message MCP tool was retired (#4452)', () => {
+    expect(EPHEMERAL_TOOLS.has('pin_message')).toBe(false)
+    expect(isEphemeralTool('pin_message')).toBe(false)
+    expect(isEphemeralTool('mcp__switchroom-telegram__pin_message')).toBe(false)
+  })
+
   it('progress_update is NOT ephemeral (MF4 — dropped from the set)', () => {
     expect(isEphemeralTool('progress_update')).toBe(false)
     expect(isEphemeralTool('mcp__switchroom-telegram__progress_update')).toBe(false)

package/telegram-plugin/tests/framework-fallback-duration-guard.test.ts

@@ -0,0 +1,125 @@
+/**
+ * M0 metric-corruption regression — the framework_fallback `turn_ended` emitter
+ * must never write an absolute Unix-epoch value as `duration_ms`.
+ *
+ * ROOT CAUSE (fixed by this change): the 300 s framework-fallback unwedge in
+ * `liveness-wiring.ts` read the turn's start from `activeTurnStartedAt.get(key)`
+ * and, guarded only by a `!= null` presence check, computed
+ * `Date.now() - turnStartedAt` inline. When the map held `0` (a bogus / not-yet
+ * stamped start — reproduced here exactly as the parked-turn fixture does with
+ * `activeTurnStartedAt.set(KEY, 0)`), it emitted `duration_ms = Date.now() - 0`,
+ * i.e. the current epoch-ms — a ~56,000-year "duration". The analysed dataset
+ * carried 110 such rows (`duration_ms === ts`, `ended_via: "framework_fallback"`),
+ * making every latency aggregate unusable.
+ *
+ * The two `stream-render.ts` turn_ended paths already guarded with
+ * `startedAt > 0 ? … : 0`; this path had drifted. The fix routes all emitters
+ * through the shared `computeTurnDurationMs`, which returns 0 for a non-positive
+ * start.
+ *
+ * This test drives the REAL `onFrameworkFallback` (via `buildSilencePokeOptions`,
+ * same standard as the other liveness-wiring tests) with a 0 start and asserts on
+ * the ACTUAL emitted `turn_ended` row (captured through the real runtime-metrics
+ * JSONL sink, pinned to a temp file). It asserts the OUTCOME — the emitted
+ * `duration_ms` — not a code path.
+ *
+ * Pre-fix: `duration_ms` ≈ `Date.now()` (~1.78e12). Post-fix: `duration_ms === 0`.
+ */
+import { describe, it, expect, beforeEach, afterEach } from 'vitest'
+import { mkdtempSync, readFileSync, existsSync } from 'node:fs'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { buildSilencePokeOptions } from '../gateway/liveness-wiring.js'
+import {
+  __setRuntimeMetricsPathForTests,
+} from '../runtime-metrics.js'
+import { makeLivenessFixture, makeTurn, statusKeyForTests } from './helpers/liveness-wiring-fixture.js'
+
+const CHAT = '-100999'
+
+function readTurnEndedRows(path: string): Array<Record<string, unknown>> {
+  if (!existsSync(path)) return []
+  return readFileSync(path, 'utf-8')
+    .split('\n')
+    .filter((l) => l.trim() !== '')
+    .map((l) => JSON.parse(l) as Record<string, unknown>)
+    .filter((r) => r.kind === 'turn_ended')
+}
+
+describe('framework_fallback turn_ended never emits an epoch value as duration_ms', () => {
+  let metricsPath: string
+
+  beforeEach(() => {
+    const dir = mkdtempSync(join(tmpdir(), 'fallback-duration-'))
+    metricsPath = join(dir, 'runtime-metrics.jsonl')
+    __setRuntimeMetricsPathForTests(metricsPath)
+  })
+
+  afterEach(() => {
+    __setRuntimeMetricsPathForTests(null)
+  })
+
+  it('emits duration_ms === 0 for a zero/bogus start instead of Date.now()', async () => {
+    const KEY = statusKeyForTests(CHAT, null)
+    const fx = makeLivenessFixture()
+
+    // The wedged turn's start is 0 — the exact corruption trigger. Before the
+    // fix this made the fallback emit `Date.now() - 0`.
+    fx.activeTurnStartedAt.set(KEY, 0)
+    fx.setCurrentTurn(
+      makeTurn({ sessionChatId: CHAT, sessionThreadId: undefined, turnId: `${KEY}#42` }),
+    )
+
+    const opts = buildSilencePokeOptions(fx.deps)
+    await opts.onFrameworkFallback({
+      key: KEY,
+      chatId: CHAT,
+      threadId: null,
+      fallbackKind: 'working',
+      silenceMs: 302_000,
+      inFlightTools: [],
+    })
+
+    const rows = readTurnEndedRows(metricsPath)
+    const fallbackRow = rows.find((r) => r.ended_via === 'framework_fallback')
+    expect(fallbackRow, 'framework_fallback turn_ended row was emitted').toBeDefined()
+
+    const duration = fallbackRow!.duration_ms as number
+    // The falsifying assertion: pre-fix this is ~Date.now() (an epoch-ms value,
+    // ~1.78e12), and in particular equals the row's own `ts`. Post-fix it is 0.
+    expect(duration).toBe(0)
+    // Belt-and-braces: a duration can never be an absolute epoch stamp, and can
+    // never equal the emission timestamp.
+    expect(duration).not.toBe(fallbackRow!.ts as number)
+    expect(duration).toBeLessThan(365 * 24 * 60 * 60 * 1000) // < 1 year, sane bound
+  })
+
+  it('emits a real elapsed duration for a valid positive start', async () => {
+    const KEY = statusKeyForTests(CHAT, null)
+    const fx = makeLivenessFixture()
+
+    const startedAt = Date.now() - 302_000 // ~5 min ago
+    fx.activeTurnStartedAt.set(KEY, startedAt)
+    fx.setCurrentTurn(
+      makeTurn({ sessionChatId: CHAT, sessionThreadId: undefined, turnId: `${KEY}#43` }),
+    )
+
+    const opts = buildSilencePokeOptions(fx.deps)
+    await opts.onFrameworkFallback({
+      key: KEY,
+      chatId: CHAT,
+      threadId: null,
+      fallbackKind: 'working',
+      silenceMs: 302_000,
+      inFlightTools: [],
+    })
+
+    const fallbackRow = readTurnEndedRows(metricsPath).find(
+      (r) => r.ended_via === 'framework_fallback',
+    )
+    const duration = fallbackRow!.duration_ms as number
+    // Around 302 s, with generous slack for test-runtime jitter.
+    expect(duration).toBeGreaterThanOrEqual(302_000)
+    expect(duration).toBeLessThan(360_000)
+  })
+})

package/telegram-plugin/tests/pin-message-tool-retired.test.ts

@@ -0,0 +1,64 @@
+/**
+ * pin_message tool retirement (#4452).
+ *
+ * The agent-facing `pin_message` MCP tool was removed: agents may no longer
+ * hand-pin arbitrary messages. The framework's OWN auto-pin
+ * (`pin_status_while_working` — the status/activity card and the 🛠 Worker
+ * card) is unaffected; that is the one sanctioned pin and is exercised by
+ * status-pin-lifecycle.test.ts.
+ *
+ * These are OUTCOME assertions on the actual offered surface — they fail if the
+ * tool is ever re-registered in the bridge schema, re-wired into the gateway
+ * dispatch, or re-granted in the agent scaffold. bridge.ts and gateway.ts each
+ * run boot side-effects at import (a top-level `await main()` / the gateway boot
+ * IIFE), so they cannot be imported here; we assert against their source, which
+ * IS the registration surface.
+ */
+import { describe, it, expect } from 'vitest'
+import { readFileSync } from 'node:fs'
+import { fileURLToPath } from 'node:url'
+
+const here = fileURLToPath(new URL('.', import.meta.url))
+const read = (rel: string) => readFileSync(new URL(rel, import.meta.url), 'utf8')
+
+describe('pin_message MCP tool is retired (#4452)', () => {
+  it('is NOT registered as a bridge tool schema', () => {
+    const bridge = read('../bridge/bridge.ts')
+    // The tool-schema registration form is `name: 'pin_message'`. Its absence
+    // means ListTools no longer offers it to the agent.
+    expect(bridge).not.toMatch(/name:\s*['"]pin_message['"]/)
+  })
+
+  it('is NOT in the gateway IPC tool allowlist and has no dispatch case', () => {
+    const gateway = read('../gateway/gateway.ts')
+    // ALLOWED_TOOLS gate: a bridge could not invoke it even by name.
+    expect(gateway).not.toMatch(/['"]pin_message['"]/)
+    // No dispatch arm and no handler.
+    expect(gateway).not.toMatch(/case\s+['"]pin_message['"]/)
+    expect(gateway).not.toContain('executePinMessage')
+  })
+
+  it('is NOT granted in the agent scaffold permission surface', () => {
+    const scaffold = read('../../src/agents/scaffold.ts')
+    expect(scaffold).not.toContain('mcp__switchroom-telegram__pin_message')
+  })
+
+  // Sanity: prove the assertions above are meaningful by confirming a tool that
+  // SURVIVED is still present in each surface (a test that can't fail is not a
+  // test — this pins the read paths to real content).
+  it('a surviving tool (delete_message) is still registered — guards false-green', () => {
+    expect(read('../bridge/bridge.ts')).toMatch(/name:\s*['"]delete_message['"]/)
+    expect(read('../gateway/gateway.ts')).toContain('executeDeleteMessage')
+    expect(read('../../src/agents/scaffold.ts')).toContain(
+      'mcp__switchroom-telegram__delete_message',
+    )
+  })
+
+  it('the framework auto status-pin machinery is untouched', () => {
+    // Change 1 must not disturb pin_status_while_working (the ONE sanctioned pin).
+    const gateway = read('../gateway/gateway.ts')
+    expect(gateway).toContain('PIN_STATUS_WHILE_WORKING')
+    expect(gateway).toContain('runStatusPinBootCleanup')
+    void here
+  })
+})

package/telegram-plugin/tests/status-pin-boot-recovery.test.ts

@@ -259,6 +259,44 @@ describe("status-pin boot recovery (gateway wiring)", () => {
     expect(idOnly(loadStatusPins(PATH, fs))).toEqual([]);
   });
 
+  it("(SAFETY) boot cleanup NEVER unpins a message the framework did not record (a user's manual pin survives)", async () => {
+    // The hard safety constraint of the boot reap: it reaps ONLY the framework's
+    // own pins (the status/activity card, the 🛠 Worker card — the rows this
+    // process itself wrote to status-pins.json). A message the USER deliberately
+    // pinned is never recorded there, so the reap must leave it completely
+    // untouched. A boot that nuked a user's real pin is a regression worse than a
+    // stranded orphan. This test makes that structural guarantee an assertion:
+    // the store never sees the user's id, so the reap can never target it.
+    const { fs } = memFs();
+    const tg = fakeTelegram();
+
+    // Session 1: the framework pins its OWN work-scoped status card (recorded).
+    const gw1 = makeGateway(fs, tg);
+    await gw1.reconcileStatusPin("fg:c:3", "-100123", { pinned: true, messageId: 715 });
+
+    // A user manually pins their own message in the SAME chat. It lives in the
+    // Telegram pin stack but is NOT in status-pins.json — the framework has no
+    // record of it and no business touching it.
+    tg.pinned.add("-100123:999");
+
+    // The framework's pin is the ONLY recorded row; the user's is not present.
+    expect(idOnly(loadStatusPins(PATH, fs))).toEqual([
+      { pinKey: "fg:c:3", chatId: "-100123", messageId: 715 },
+    ]);
+    expect(loadStatusPins(PATH, fs).some((r) => r.messageId === 999)).toBe(false);
+
+    // ── CRASH, then a fresh boot runs the reap. ──
+    const gw2 = makeGateway(fs, tg);
+    const res = await gw2.bootCleanup();
+
+    // Exactly the framework's OWN pin was cleared …
+    expect(res).toEqual({ cleared: 1, retained: 0, kept: 0, total: 1 });
+    expect(tg.pinned.has("-100123:715")).toBe(false);
+    // … and the user's manual pin is untouched — never unpinned.
+    expect(tg.pinned.has("-100123:999")).toBe(true);
+    expect(idOnly(loadStatusPins(PATH, fs))).toEqual([]);
+  });
+
   it("clean shutdown (sweep DID run) leaves nothing for boot cleanup to do", async () => {
     // Contrast: when the SIGTERM sweep runs (unpin each key), the store is
     // emptied and the pin removed — boot cleanup is a no-op. This guards the

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

@@ -304,6 +304,45 @@ describe('createWorkerActivityFeed', () => {
     expect(feed.has('w1')).toBe(true)
   })
 
+  it('defaults firstPaintMin to 4000ms (no explicit firstPaintMinMs)', async () => {
+    // Guards the module default. A prose-silent worker's first card must paint
+    // once it has run ≥4000ms and NOT before — asserting the actual default so
+    // this fails on the old 8000. #fix/worker-feed-first-paint.
+    const bot = makeFakeBot()
+    let clock = 0
+    const feed = createWorkerActivityFeed({ bot, now: () => clock })
+    // Just below the 4000 default: still held.
+    clock = 3999
+    await feed.update('w1', 'chat', view({ elapsedMs: 3999 }))
+    expect(bot.sent).toHaveLength(0)
+    expect(feed.has('w1')).toBe(false)
+    // At/above 4000: paints. (On the old 8000 default this would still be held
+    // and bot.sent would be empty — so this assertion pins the new value.)
+    clock = 4000
+    await feed.update('w1', 'chat', view({ elapsedMs: 4000 }))
+    expect(bot.sent).toHaveLength(1)
+    expect(feed.has('w1')).toBe(true)
+  })
+
+  it('honors an explicit firstPaintMinMs override (env plumbing shape)', async () => {
+    // The gateway threads SWITCHROOM_TG_WORKER_FEED_FIRST_PAINT_MS through as
+    // firstPaintMinMs; an operator override (e.g. reverting to 8000) must hold
+    // first paint until that value, overriding the 4000 default.
+    const bot = makeFakeBot()
+    let clock = 0
+    const feed = createWorkerActivityFeed({ bot, now: () => clock, firstPaintMinMs: 8000 })
+    // Past the 4000 default but below the override: still held.
+    clock = 5000
+    await feed.update('w1', 'chat', view({ elapsedMs: 5000 }))
+    expect(bot.sent).toHaveLength(0)
+    expect(feed.has('w1')).toBe(false)
+    // At the override threshold: paints.
+    clock = 8000
+    await feed.update('w1', 'chat', view({ elapsedMs: 8000 }))
+    expect(bot.sent).toHaveLength(1)
+    expect(feed.has('w1')).toBe(true)
+  })
+
   it('messageIdOf exposes the posted message id (for status-pin) and is null before paint / after finish', async () => {
     const bot = makeFakeBot()
     let clock = 0
@@ -706,7 +745,7 @@ describe('createWorkerActivityFeed — heartbeat', () => {
       setInterval: () => 1,
       clearInterval: () => {},
     })
-    // First paint at elapsed 0 (firstPaintMin default 8000 — use 9000). The
+    // First paint at elapsed 0 (firstPaintMin default 4000 — use 9000). The
     // narrative line 'pulling data' lands here, so the current step starts now.
     clock = 19_000
     await feed.update('w1', 'chat', view({ elapsedMs: 9000, latestSummary: 'pulling data' }))

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

@@ -800,7 +800,7 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
   const floodWaitRemainingMs = opts.floodWaitRemainingMs ?? (() => 0)
   const minEditInterval = opts.minEditIntervalMs ?? 2500
   const elapsedRefreshMs = Math.max(minEditInterval, Math.floor(opts.elapsedRefreshMs ?? 15000))
-  const firstPaintMin = opts.firstPaintMinMs ?? 8000
+  const firstPaintMin = opts.firstPaintMinMs ?? 4000
   const heartbeatTickMs = opts.heartbeatTickMs ?? 6000
   const maxRows = Math.max(1, Math.floor(opts.maxRows ?? 8))
   const staleWorkerTtlMs = Math.max(1, Math.floor(opts.staleWorkerTtlMs ?? 50 * 60_000))

package/vendor/hindsight-memory/scripts/recall.py

@@ -1037,6 +1037,116 @@ def _write_recall_log(entry: dict) -> None:
         pass
 
 
+# Switchroom recall-latency instrumentation — full-hook wall-time.
+#
+# recall.py is the UserPromptSubmit hook that sits in front of EVERY reply
+# (pre-first-token), yet it was the one hook with no wall-time record: it is a
+# DIRECT Claude Code plugin hook (hooks/hooks.json), NOT wrapped by
+# bin/run-hook.sh, so it never emitted a `hook-timings-<Ddd>.log` row the way
+# every wrapped hook does, and `recall_log.jsonl` measured only the recall
+# critical path (`total_elapsed_ms`, from `recall_start_monotonic`) — never the
+# hook's own import + stdin + cache-check + gate overhead.
+#
+# Routing it through run-hook.sh was rejected as the mechanism: the vendored
+# hooks.json is re-copied verbatim into every agent's plugin dir on `switchroom
+# apply`, and run-hook.sh lives in the switchroom repo's bin/, not under
+# CLAUDE_PLUGIN_ROOT — coupling the vendor snapshot to switchroom's bin layout is
+# fragile, and the os._exit(0) fast-path (which skips atexit / thread-join to
+# return control the instant stdout is flushed) would have to be reconciled with
+# the wrapper. Instead the hook emits the SAME JSON line, into the SAME weekday-
+# ring file, honouring the SAME env knobs, from inside the process at exit — so
+# `grep duration_ms hook-timings-*.log` sees this hook next to every other one.
+HOOK_TIMING_SOURCE = "hook:hindsight-recall"
+HOOK_TIMING_CODE = "recall.py"
+
+
+def _hook_duration_ms() -> int:
+    """Milliseconds since this hook process began doing work.
+
+    Anchored at import start (`_IMPORT_START_MONOTONIC`, taken before any of this
+    hook's own imports ran — recall.py line ~48), so the number spans the WHOLE
+    hook: dependency import, the stdin read, the cache check, the gate
+    short-circuits, and — when it got that far — the recall round-trips. That is
+    deliberately WIDER than `total_elapsed_ms` (the recall critical path only,
+    measured from `recall_start_monotonic`): `duration_ms - total_elapsed_ms` is
+    therefore the pre-recall LOCAL overhead, and the per-bank
+    `bank_timings[].elapsed_ms` remain the Hindsight server round-trips — so the
+    log already separates server time from local overhead without a new field.
+    """
+    return int((time.monotonic() - _IMPORT_START_MONOTONIC) * 1000)
+
+
+def _emit_hook_timing_log(duration_ms: int, status: int) -> None:
+    """Append one timing line to `hook-timings-<Ddd>.log`, matching run-hook.sh.
+
+    STDOUT-SAFE by construction: writes only to a log file, NEVER to the hook's
+    stdout contract that Claude Code consumes. Failure-tolerant — any error is
+    swallowed so instrumentation can never take the hook down. Honours the same
+    env knobs as bin/run-hook.sh (`SWITCHROOM_HOOK_TIMING`,
+    `SWITCHROOM_HOOK_TIMING_DIR`, `SWITCHROOM_HOOK_TIMING_MIN_MS`) and reproduces
+    its 7-day self-truncating weekday ring and JSON line shape exactly, so a
+    consumer cannot tell this row apart from a wrapped hook's.
+
+    NOTE on the 12s ceiling: if Claude Code kills this hook at the
+    UserPromptSubmit timeout, the process is terminated before any exit path runs
+    and NO timing line (nor recall_log row) is written — the MISSING line is the
+    breach signal, consistent with the two-signal baseline documented at the
+    recall_log write. This records every invocation that returns under budget,
+    including a fully-degraded/timed-out recall that still exits cleanly.
+    """
+    try:
+        if os.environ.get("SWITCHROOM_HOOK_TIMING", "1") == "0":
+            return
+        timing_dir = os.environ.get("SWITCHROOM_HOOK_TIMING_DIR") or os.environ.get(
+            "TELEGRAM_STATE_DIR", ""
+        )
+        if not timing_dir or not os.path.isdir(timing_dir):
+            return
+        try:
+            duration_ms = int(duration_ms)
+        except (TypeError, ValueError):
+            return
+        if duration_ms < 0:
+            duration_ms = 0
+        try:
+            min_ms = int(os.environ.get("SWITCHROOM_HOOK_TIMING_MIN_MS", "0"))
+        except (TypeError, ValueError):
+            min_ms = 0
+        if duration_ms < min_ms:
+            return
+        # Local wall clock, matching run-hook.sh's builtin `%(...)T` formatting so
+        # both writers agree on which weekday-ring file today lands in.
+        now = time.localtime()
+        today = time.strftime("%Y-%m-%d", now)
+        dow = time.strftime("%a", now)
+        ts = time.strftime("%Y-%m-%dT%H:%M:%S%z", now)
+        logfile = os.path.join(timing_dir, f"hook-timings-{dow}.log")
+        # 7-day self-truncating ring: the weekday-named file is either today's or
+        # exactly a week stale. If its first line does not carry today's date,
+        # reset it before appending (same rule as run-hook.sh).
+        try:
+            if os.path.getsize(logfile) > 0:
+                with open(logfile, encoding="utf-8") as f:
+                    first = f.readline()
+                if f'"date":"{today}"' not in first:
+                    open(logfile, "w", encoding="utf-8").close()
+        except OSError:
+            pass
+        # HOOK_TIMING_SOURCE / HOOK_TIMING_CODE are fixed constants with no JSON
+        # metacharacters, so no escape pass is needed (unlike run-hook.sh, whose
+        # source/code are caller-supplied).
+        line = (
+            '{"ts":"%s","date":"%s","source":"%s","code":"%s",'
+            '"duration_ms":%d,"status":%d}\n'
+            % (ts, today, HOOK_TIMING_SOURCE, HOOK_TIMING_CODE, duration_ms, status)
+        )
+        with open(logfile, "a", encoding="utf-8") as f:
+            f.write(line)
+    except Exception:
+        # Instrumentation is never load-bearing — swallow everything.
+        pass
+
+
 def _read_transcript_lines(transcript_path: str, tail_bytes: int):
     """Yield the transcript's trailing lines, byte-bounded.
 
@@ -1824,6 +1934,12 @@ def main():
                 # timed out"; `deadline_hit is None` means "no banks ran"
                 # (review finding 3).
                 "total_elapsed_ms": None,
+                # Switchroom recall-latency instrumentation — full-hook wall time
+                # (import + stdin + cache check), measured to this log write. A
+                # cache hit issues no bank HTTP, so `total_elapsed_ms` is None and
+                # this is pure local overhead — the cheap path this cache exists
+                # to create, now visible per-row.
+                "duration_ms": _hook_duration_ms(),
                 "directives_elapsed_ms": None,
                 "bank_timings": [],
                 "deadline_hit": None,
@@ -2542,6 +2658,16 @@ def main():
         # parallelism change measures against; the 17-26% figure it replaces is
         # the stale 2026-05-24 pre-fix audit.
         "total_elapsed_ms": int((time.monotonic() - recall_start_monotonic) * 1000),
+        # Switchroom recall-latency instrumentation — FULL-HOOK wall time to this
+        # log write: dependency import + stdin read + cache check + the gate
+        # short-circuits + the whole recall critical path. `total_elapsed_ms`
+        # above is the recall critical path ONLY, so `duration_ms -
+        # total_elapsed_ms` is the pre-recall LOCAL overhead this row could not
+        # see before, while `bank_timings[].elapsed_ms` stay the server round-
+        # trips — the log now separates server time from local overhead. Written
+        # here (with the rest of the row, before the empty-block return) so even a
+        # fully-timed-out / degraded recall that reaches this line gets a duration.
+        "duration_ms": _hook_duration_ms(),
         "directives_elapsed_ms": directives_elapsed_ms,
         "bank_timings": bank_timings,
         # Switchroom hindsight-leverage A3 — FINALIZED `deadline_hit` semantics
@@ -2795,6 +2921,12 @@ if __name__ == "__main__":
             sys.stdout.flush()
         except Exception:
             pass
+        # Switchroom recall-latency instrumentation — emit the full-hook timing
+        # line AFTER stdout is flushed (Claude Code already has the bytes) and
+        # BEFORE os._exit, which skips atexit and would otherwise drop it. Adds
+        # ~0.5ms (one file append) before the process exits — the same budget
+        # run-hook.sh spends per wrapped hook. Stdout is untouched.
+        _emit_hook_timing_log(_hook_duration_ms(), 0)
         os._exit(0)
     except Exception as e:
         # Switchroom #1070 (redo per #1085 review).
@@ -2844,6 +2976,10 @@ if __name__ == "__main__":
             import traceback
 
             traceback.print_exc(file=sys.stderr)
+            # Instrumentation: record the failed invocation's wall time too
+            # (status 2, the debug-mode block behaviour) so a crash-looping
+            # hook is visible in the timing log, not just a silent gap.
+            _emit_hook_timing_log(_hook_duration_ms(), 2)
             # Debug-mode exit 2 is intentional and unchanged —
             # operators with HINDSIGHT_DEBUG=1 are chasing a broken
             # recall and want the hook to surface its failure.
@@ -2853,4 +2989,8 @@ if __name__ == "__main__":
         # 0 with no stdout (agent's prompt assembly treats absent
         # additionalContext as "no recall this turn").
         _record_issue_safely(_detail, _class)
+        # Instrumentation: the non-debug exit code is 0 (the safe-empty stdout
+        # posture), so log status 0 — the accompanying issue-sink record is where
+        # the failure detail lives; this row just makes the latency observable.
+        _emit_hook_timing_log(_hook_duration_ms(), 0)
         sys.exit(0)