switchroom 0.15.45 → 0.16.4

package/telegram-plugin/tests/repo-context-pretool.test.ts

@@ -420,6 +420,68 @@ describe('repo-context-pretool e2e', () => {
     expect(res.stdout ?? '').toBe('')
   })
 
+  it('suppresses the agent own CLAUDE.md when SWITCHROOM_AGENT_START_CWD is set', () => {
+    // The agent's own CLAUDE.md is already in the system prompt — re-injecting
+    // it wastes ~30KB per session. The marker-path guard must exit 0 silently.
+    const agentDir = join(sb.root, '.switchroom', 'agents', 'myagent')
+    const agentWorkspace = join(agentDir, 'workspace')
+    mkdirSync(agentWorkspace, { recursive: true })
+    writeFileSync(join(agentDir, 'CLAUDE.md'), '# own agent claude md')
+    writeFileSync(join(agentWorkspace, 'note.md'), 'x')
+
+    const sid = `e2e-own-marker-${Date.now()}`
+    repoStateDir(sid)
+    const res = runHook(
+      {
+        session_id: sid,
+        cwd: agentDir,
+        hook_event_name: 'PreToolUse',
+        tool_name: 'Read',
+        tool_input: { file_path: join(agentDir, 'workspace', 'note.md') },
+      },
+      {
+        home: sb.root,
+        agent: 'myagent',
+        env: { SWITCHROOM_AGENT_START_CWD: agentDir },
+      },
+    )
+    expect(res.code).toBe(0)
+    // Own CLAUDE.md must NOT be injected
+    expect(res.stdout).toBe('')
+  })
+
+  it('still injects a worktree repo CLAUDE.md even when SWITCHROOM_AGENT_START_CWD is set', () => {
+    // A repo checked out outside the agent start dir must still inject.
+    const agentDir = join(sb.root, '.switchroom', 'agents', 'myagent')
+    mkdirSync(agentDir, { recursive: true })
+    writeFileSync(join(agentDir, 'CLAUDE.md'), '# own agent')
+    const worktree = join(sb.root, 'workspace', 'myrepo')
+    mkdirSync(worktree, { recursive: true })
+    writeFileSync(join(worktree, 'CLAUDE.md'), '# worktree repo')
+    writeFileSync(join(worktree, 'src.ts'), 'x')
+
+    const sid = `e2e-worktree-${Date.now()}`
+    repoStateDir(sid)
+    const res = runHook(
+      {
+        session_id: sid,
+        cwd: worktree,
+        hook_event_name: 'PreToolUse',
+        tool_name: 'Read',
+        tool_input: { file_path: join(worktree, 'src.ts') },
+      },
+      {
+        home: sb.root,
+        agent: 'myagent',
+        env: { SWITCHROOM_AGENT_START_CWD: agentDir },
+      },
+    )
+    expect(res.code).toBe(0)
+    expect(res.stdout.length).toBeGreaterThan(0)
+    const parsed = JSON.parse(res.stdout)
+    expect(parsed.hookSpecificOutput.additionalContext).toContain('# worktree repo')
+  })
+
   it('no marker → no output', () => {
     // tmpdir, no CLAUDE.md anywhere up the chain
     const file = join(sb.root, 'nothing.ts')

package/telegram-plugin/tests/represent-guard.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect } from "vitest";
+import {
+  shouldSuppressRepresent,
+  type RepresentGuardObligation,
+} from "../gateway/represent-guard.js";
+import { ObligationLedger } from "../gateway/obligation-ledger.js";
+
+// Executable verification of the #2472 fix: obligation_represent must NOT re-fire
+// for an origin_turn_id that has already been answered by a reply since the last
+// represent (the satisfied-but-misdetected case that produced the near-identical
+// duplicate), while the genuine "plain text, never replied" case still represents
+// ONCE and the represent_count cap is honored.
+
+const CHAT = "12345";
+const ORIGIN = "12345:_#10605";
+
+function obligation(over: Partial<RepresentGuardObligation> = {}): RepresentGuardObligation {
+  return { originTurnId: ORIGIN, chatId: CHAT, ...over };
+}
+
+/** A hasOutboundDeliveredSince stub that returns true only for queries whose
+ *  cutoff falls at/after `replyTs` — modelling a reply delivered at replyTs. */
+function replyDeliveredAt(replyTs: number) {
+  return (_chat: string, sinceMs: number) => replyTs >= sinceMs;
+}
+
+describe("shouldSuppressRepresent — #2472 duplicate-represent guard", () => {
+  it("suppresses the SECOND represent once a reply landed since the FIRST represent", () => {
+    // The exact #2472 sequence: represent_count=1 fired at t=1000, the agent
+    // answered with a reply at t=1500, the sweep is about to fire count=2.
+    const o = obligation({ lastRepresentedAt: 1000 });
+    const suppress = shouldSuppressRepresent(o, {
+      historyEnabled: true,
+      hasOutboundDeliveredSince: replyDeliveredAt(1500),
+    });
+    expect(suppress).toBe(true); // do NOT re-fire → no duplicate 10609
+  });
+
+  it("does NOT suppress the FIRST represent — genuine plain-text-no-reply still represents once", () => {
+    // First represent: lastRepresentedAt is undefined. Even though an assistant
+    // message (the original plain-text answer) exists in history, the single
+    // re-ask must still fire — the agent never called the reply tool.
+    const o = obligation({ lastRepresentedAt: undefined });
+    const suppress = shouldSuppressRepresent(o, {
+      historyEnabled: true,
+      // history WOULD report an outbound exists, but the first represent ignores it
+      hasOutboundDeliveredSince: () => true,
+    });
+    expect(suppress).toBe(false); // represent fires exactly once
+  });
+
+  it("does NOT suppress a later represent when NO reply landed since the last one", () => {
+    // count=1 fired at t=1000, nothing answered it → count=2 must still fire.
+    const o = obligation({ lastRepresentedAt: 1000 });
+    const suppress = shouldSuppressRepresent(o, {
+      historyEnabled: true,
+      hasOutboundDeliveredSince: () => false,
+    });
+    expect(suppress).toBe(false);
+  });
+
+  it("a reply that PREDATES the last represent does not count (cutoff is lastRepresentedAt, not openedAt)", () => {
+    // The original plain-text answer landed at t=500, before the represent at
+    // t=1000. That is not evidence the represent itself was answered → fire.
+    const o = obligation({ lastRepresentedAt: 1000 });
+    const suppress = shouldSuppressRepresent(o, {
+      historyEnabled: true,
+      hasOutboundDeliveredSince: replyDeliveredAt(500),
+    });
+    expect(suppress).toBe(false);
+  });
+
+  it("never suppresses when history is unavailable (safe: re-ask rather than silently drop)", () => {
+    const o = obligation({ lastRepresentedAt: 1000 });
+    const suppress = shouldSuppressRepresent(o, {
+      historyEnabled: false,
+      hasOutboundDeliveredSince: () => true,
+    });
+    expect(suppress).toBe(false);
+  });
+});
+
+// #2474 follow-up — the terse-reply gap. PR #2474 suppressed the duplicate
+// represent only when the satisfied-check saw a >=200-char "substantive" reply
+// (the 200-char proxy borrowed from the ESCALATE branch). A GENUINE but SHORT
+// reply (e.g. "Yes — done.") therefore did NOT suppress the duplicate, leaving
+// the #2472 duplicate-message bug alive for terse answers. The guard itself is
+// pure: the gateway now binds hasOutboundDeliveredSince with a LOW minChars so a
+// terse-but-real reply reports true. These tests model the wired predicate's
+// behavior at the guard boundary.
+describe("represent guard — terse genuine reply suppresses the duplicate (#2474 follow-up)", () => {
+  /** Models the gateway-wired predicate AFTER the fix: reports true for ANY real
+   *  reply at/after the cutoff regardless of length (minChars=1 inside history).
+   *  `replyChars` is the length of the terse reply; included to make the intent
+   *  explicit — the predicate no longer gates on length. */
+  function terseReplyDeliveredAt(replyTs: number, replyChars: number) {
+    expect(replyChars).toBeGreaterThan(0); // a real, non-empty reply
+    return (_chat: string, sinceMs: number) => replyTs >= sinceMs;
+  }
+
+  it("suppresses the duplicate when a SHORT genuine reply landed since the last represent", () => {
+    // count=1 fired at t=1000; the agent answered with a terse 11-char reply
+    // ("Yes — done.") at t=1500. The duplicate (count=2) must now be suppressed —
+    // before the fix the 200-char gate let it through.
+    const o = obligation({ lastRepresentedAt: 1000 });
+    const suppress = shouldSuppressRepresent(o, {
+      historyEnabled: true,
+      hasOutboundDeliveredSince: terseReplyDeliveredAt(1500, "Yes — done.".length),
+    });
+    expect(suppress).toBe(true);
+  });
+
+  it("does NOT suppress when only framework noise occurred since the last represent", () => {
+    // Typing indicators and progress-card edits never call recordOutbound, so no
+    // assistant row exists for them → the wired predicate reports false. A real
+    // answer never landed, so the represent SHOULD still fire (no false suppress).
+    const o = obligation({ lastRepresentedAt: 1000 });
+    const suppress = shouldSuppressRepresent(o, {
+      historyEnabled: true,
+      // No assistant row for typing/progress edits → predicate is false.
+      hasOutboundDeliveredSince: () => false,
+    });
+    expect(suppress).toBe(false);
+  });
+
+  it("does NOT suppress when the terse reply PREDATES the last represent", () => {
+    // A terse reply at t=500 answered an EARLIER ask, not the represent at t=1000.
+    // The cutoff is lastRepresentedAt, so a pre-cutoff terse reply must not count.
+    const o = obligation({ lastRepresentedAt: 1000 });
+    const suppress = shouldSuppressRepresent(o, {
+      historyEnabled: true,
+      hasOutboundDeliveredSince: terseReplyDeliveredAt(500, "ok".length),
+    });
+    expect(suppress).toBe(false);
+  });
+});
+
+describe("represent_count cap is honored by the ledger — a misdetected obligation cannot loop", () => {
+  it("escalates (stops re-presenting) once representCount reaches maxRepresents", () => {
+    const L = new ObligationLedger(2); // maxRepresents = 2
+    L.openIfAbsent({
+      originTurnId: ORIGIN,
+      chatId: CHAT,
+      messageId: 10605,
+      text: "Check there was a bug raised…",
+      openedAt: 0,
+    });
+
+    // count 0 -> represent
+    expect(L.decideAtIdle().action).toBe("represent");
+    L.markRepresented(ORIGIN, 1000);
+    // count 1 -> represent
+    expect(L.decideAtIdle().action).toBe("represent");
+    L.markRepresented(ORIGIN, 2000);
+    // count 2 == cap -> escalate, NOT another represent
+    expect(L.decideAtIdle().action).toBe("escalate");
+
+    // and the ladder terminates: closing on escalate ends it
+    L.close(ORIGIN);
+    expect(L.decideAtIdle().action).toBe("none");
+  });
+});

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

@@ -5,6 +5,7 @@ import { join } from 'path'
 import {
   projectTranscriptLine,
   projectSubagentLine,
+  projectAssistantTextBlocks,
   sanitizeCwdToProjectName,
   getProjectsDirForCwd,
   startSessionTail,
@@ -208,10 +209,67 @@ describe('projectTranscriptLine', () => {
       },
     })
     expect(projectTranscriptLine(line)).toEqual([
-      { kind: 'text', text: 'Replied with comparison' },
+      // Shared narrative contract: a lone text block (no tool_use after it)
+      // is lastInMessage:true at blockIndex 0.
+      { kind: 'text', text: 'Replied with comparison', blockIndex: 0, lastInMessage: true },
     ])
   })
 
+  it('drops empty/whitespace-only text blocks (shared narrative contract)', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        content: [
+          { type: 'text', text: '   \n  ' },
+          { type: 'tool_use', id: 'toolu_a', name: 'Read', input: { file_path: '/a' } },
+        ],
+      },
+    })
+    // The empty text block is dropped; only the tool_use survives.
+    expect(projectTranscriptLine(line)).toEqual([
+      { kind: 'tool_use', toolName: 'Read', toolUseId: 'toolu_a', input: { file_path: '/a' } },
+    ])
+  })
+
+  it('text block preceding a tool_use in the same message is lastInMessage:false', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        content: [
+          { type: 'text', text: 'Found both:' },
+          { type: 'tool_use', id: 'toolu_a', name: 'Read', input: { file_path: '/a' } },
+        ],
+      },
+    })
+    const events = projectTranscriptLine(line)
+    expect(events[0]).toEqual({ kind: 'text', text: 'Found both:', blockIndex: 0, lastInMessage: false })
+  })
+
+  it('text block AFTER the last tool_use is lastInMessage:true', () => {
+    const line = JSON.stringify({
+      type: 'assistant',
+      message: {
+        content: [
+          { type: 'tool_use', id: 'toolu_a', name: 'Read', input: { file_path: '/a' } },
+          { type: 'text', text: 'Done.' },
+        ],
+      },
+    })
+    const events = projectTranscriptLine(line)
+    const textEv = events.find((e) => e.kind === 'text')
+    expect(textEv).toEqual({ kind: 'text', text: 'Done.', blockIndex: 1, lastInMessage: true })
+  })
+
+  it('the dead sub_agent_narrative kind is never emitted', () => {
+    // The union member was removed; nothing in either projector emits it.
+    const subLine = JSON.stringify({
+      type: 'assistant',
+      message: { content: [{ type: 'text', text: 'prose' }] },
+    })
+    const events = projectSubagentLine(subLine, 'X', { hasEmittedStart: true })
+    expect(events.some((e) => (e as { kind: string }).kind === 'sub_agent_narrative')).toBe(false)
+  })
+
   it('parses assistant message with multiple blocks (thinking + tool_use)', () => {
     const line = JSON.stringify({
       type: 'assistant',
@@ -471,7 +529,8 @@ describe('projectSubagentLine', () => {
     })
     const events = projectSubagentLine(line, 'X', st)
     expect(events).toEqual([
-      { kind: 'sub_agent_text', agentId: 'X', text: 'Reading the reducer' },
+      // text precedes a tool_use in the same message → lastInMessage:false
+      { kind: 'sub_agent_text', agentId: 'X', text: 'Reading the reducer', blockIndex: 0, lastInMessage: false },
       {
         kind: 'sub_agent_tool_use',
         agentId: 'X',
@@ -511,8 +570,9 @@ describe('projectSubagentLine', () => {
       st,
     )
     // Text first (so the final summary still renders), turn_end last.
+    // A lone trailing text block (no tool_use after it) is lastInMessage:true.
     expect(events).toEqual([
-      { kind: 'sub_agent_text', agentId: 'X', text: 'Done. Fixed the bug.' },
+      { kind: 'sub_agent_text', agentId: 'X', text: 'Done. Fixed the bug.', blockIndex: 0, lastInMessage: true },
       { kind: 'sub_agent_turn_end', agentId: 'X' },
     ])
   })
@@ -565,3 +625,87 @@ describe('idle sub-tail reap (MEM2)', () => {
     expect(src).toMatch(/rescanSubagents\(\)\s*[\s\S]*?reapIdleSubTails\(\)/)
   })
 })
+
+describe('projectAssistantTextBlocks (shared text→narrative kernel)', () => {
+  // Direct unit coverage for the now-live projection kernel. Both
+  // projectTranscriptLine and projectSubagentLine derive their text events
+  // through this one function; these tests pin its contract independently of
+  // either caller. The `make` adapter here uses the main-agent `text` kind.
+  const makeText = (text: string, blockIndex: number, lastInMessage: boolean): SessionEvent => ({
+    kind: 'text',
+    text,
+    blockIndex,
+    lastInMessage,
+  })
+
+  it('emits one narration event per non-empty text block, keyed by source index', () => {
+    const out = projectAssistantTextBlocks(
+      [
+        { type: 'text', text: 'hello' },
+        { type: 'tool_use', name: 'Read', id: 't1' },
+        { type: 'text', text: 'world' },
+      ],
+      makeText,
+    )
+    expect(out.size).toBe(2)
+    expect(out.get(0)).toEqual({ kind: 'text', text: 'hello', blockIndex: 0, lastInMessage: false })
+    expect(out.get(2)).toEqual({ kind: 'text', text: 'world', blockIndex: 2, lastInMessage: true })
+  })
+
+  it('drops empty and whitespace-only text blocks', () => {
+    const out = projectAssistantTextBlocks(
+      [
+        { type: 'text', text: '' },
+        { type: 'text', text: '   \n\t  ' },
+        { type: 'text', text: 'kept' },
+      ],
+      makeText,
+    )
+    expect(out.size).toBe(1)
+    expect(out.has(0)).toBe(false)
+    expect(out.has(1)).toBe(false)
+    expect(out.get(2)).toEqual({ kind: 'text', text: 'kept', blockIndex: 2, lastInMessage: true })
+  })
+
+  it('lastInMessage is false when a tool_use follows the text block in the same message', () => {
+    const out = projectAssistantTextBlocks(
+      [
+        { type: 'text', text: 'preamble' },
+        { type: 'tool_use', name: 'Bash', id: 't1' },
+      ],
+      makeText,
+    )
+    expect(out.get(0)).toEqual({ kind: 'text', text: 'preamble', blockIndex: 0, lastInMessage: false })
+  })
+
+  it('lastInMessage is true for a text block after the last tool_use (trailing narration)', () => {
+    const out = projectAssistantTextBlocks(
+      [
+        { type: 'tool_use', name: 'Bash', id: 't1' },
+        { type: 'text', text: 'done' },
+      ],
+      makeText,
+    )
+    expect(out.get(1)).toEqual({ kind: 'text', text: 'done', blockIndex: 1, lastInMessage: true })
+  })
+
+  it('the make adapter controls the wire kind (sub_agent_text tier)', () => {
+    const out = projectAssistantTextBlocks(
+      [{ type: 'text', text: 'sub preamble' }],
+      (text, blockIndex, lastInMessage): SessionEvent => ({
+        kind: 'sub_agent_text',
+        agentId: 'A',
+        text,
+        blockIndex,
+        lastInMessage,
+      }),
+    )
+    expect(out.get(0)).toEqual({
+      kind: 'sub_agent_text',
+      agentId: 'A',
+      text: 'sub preamble',
+      blockIndex: 0,
+      lastInMessage: true,
+    })
+  })
+})

package/telegram-plugin/tests/silence-liveness-wiring.test.ts

@@ -64,4 +64,22 @@ describe('silence-poke production-liveness — heartbeat safety', () => {
   it('production-liveness is behind the default-ON SWITCHROOM_SILENCE_LIVENESS_PRODUCTION kill switch', () => {
     expect(gatewaySrc).toMatch(/SWITCHROOM_SILENCE_LIVENESS_PRODUCTION !== '0'/)
   })
+
+  it('the 300s fallback send gates disable_notification on blockedOnApproval (approval re-ping pings, liveness stays silent)', () => {
+    // The 300s fallback is normally a pure-liveness "still working…" status
+    // notice and stays SILENT. But the SAME send carries a user-gating re-ping
+    // ("waiting for your approval — tap Approve or Deny …") when the turn is
+    // parked on an approval card — that must PING. The send site must therefore
+    // gate disable_notification on blockedOnApproval, NOT hard-code `true`.
+    // Structural guard so a refactor can't silently re-silence the re-ping
+    // (the gateway IIFE can't be instantiated in-process — same pattern as the
+    // heartbeat-safety assertions above).
+    const block = between(gatewaySrc, 'onFrameworkFallback: async (ctx) => {', '\nfunction trackRedeliveredInbound')
+    expect(block.length).toBeGreaterThan(100) // sanity: slice found the handler body
+    // The signal is derived once, hoisted above the update-status branch so it's
+    // in scope at the send site.
+    expect(block).toMatch(/const blockedOnApproval = activeStatusReactions/)
+    // The send gates on it rather than hard-coding silent.
+    expect(block).toMatch(/disable_notification: blockedOnApproval \? false : true/)
+  })
 })

package/telegram-plugin/tests/status-card-budget-parity.test.ts

@@ -0,0 +1,72 @@
+import { describe, it, expect } from 'vitest'
+import { renderStatusCard } from '../tool-activity-summary.js'
+import { STATUS_CARD_CHAR_BUDGET } from '../status-no-truncate.js'
+
+// Both status surfaces (🤖 agent + 🛠 worker) render through the single
+// `renderStatusCard` primitive. Given the SAME raw steps, the rendered step
+// BODY (everything below the two-line header) must be byte-identical regardless
+// of the header emoji/label — the truncation pipeline, rolling window, and
+// char-budget backstop are surface-agnostic. This pins that parity so the two
+// surfaces can never drift apart again.
+
+/** Strip the two header lines, returning just the step/result body. */
+function body(card: string | null): string {
+  if (card == null) return ''
+  const lines = card.split('\n')
+  return lines.slice(2).join('\n')
+}
+
+function agent(steps: string[], final = false) {
+  return renderStatusCard({
+    header: { emoji: '🤖', label: 'Agent', elapsedMs: 12_000, toolCount: 4, state: final ? 'done' : 'running' },
+    steps,
+    final,
+  })
+}
+
+function worker(steps: string[], final = false) {
+  return renderStatusCard({
+    header: { emoji: '🛠', label: 'Worker', description: 'a task', elapsedMs: 12_000, toolCount: 4, state: final ? 'done' : 'running' },
+    steps,
+    final,
+  })
+}
+
+describe('status-card body byte-parity: agent vs worker', () => {
+  it('identical raw steps → identical body length and bytes (running)', () => {
+    const steps = ['read the brief', 'scanned vendor A', 'scanned vendor B']
+    const a = body(agent(steps))
+    const w = body(worker(steps))
+    expect(a).toBe(w)
+    expect(a.length).toBe(w.length)
+  })
+
+  it('identical raw steps → identical body (final)', () => {
+    const steps = ['compiled', 'linked', 'shipped']
+    expect(body(agent(steps, true))).toBe(body(worker(steps, true)))
+  })
+
+  it('overflow window → identical body + same +N earlier marker', () => {
+    const steps = Array.from({ length: 11 }, (_, i) => `step ${String(i + 1).padStart(2, '0')}`)
+    const a = body(agent(steps))
+    const w = body(worker(steps))
+    expect(a).toBe(w)
+    expect(a).toContain('earlier…')
+  })
+
+  it('char-budget backstop → identical body length under the fitter', () => {
+    const big = 'z'.repeat(900)
+    const steps = Array.from({ length: 6 }, () => big)
+    const a = agent(steps)!
+    const w = worker(steps)!
+    expect(body(a).length).toBe(body(w).length)
+    // Both whole cards stay within the wire budget.
+    expect(a.length).toBeLessThanOrEqual(STATUS_CARD_CHAR_BUDGET)
+    expect(w.length).toBeLessThanOrEqual(STATUS_CARD_CHAR_BUDGET)
+  })
+
+  it('escape parity: special chars escape identically on both surfaces', () => {
+    const steps = ['run build && deploy <prod> & verify']
+    expect(body(agent(steps))).toBe(body(worker(steps)))
+  })
+})

package/telegram-plugin/tests/status-surface-log.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect } from 'vitest'
+import { formatTurnLifecycle, detectStatusSurfaceDegraded } from '../gateway/status-surface-log.js'
+import type { StatusSurfaceTurnView } from '../gateway/status-surface-log.js'
+
+/**
+ * Tests for status-surface-log.ts (issue #2461).
+ *
+ * Verifies that:
+ *   - `formatTurnLifecycle` uses `labeledToolCount` (not `toolCallCount`) for
+ *     the `tools=` lifecycle log field — so the log reflects the accurate
+ *     surfaced count, not the raw tool_use count that includes surface tools.
+ *   - `detectStatusSurfaceDegraded` uses `labeledToolCount` to determine
+ *     whether to check for the feed-never-opened degraded state.
+ */
+
+function makeTurn(overrides: Partial<StatusSurfaceTurnView> = {}): StatusSurfaceTurnView {
+  return {
+    turnId: 'turn-abc',
+    sessionChatId: '123456',
+    sessionThreadId: undefined,
+    startedAt: 1000,
+    toolCallCount: 10,      // raw tool_use count — includes surface tools
+    labeledToolCount: 5,    // surfaced count — only non-surface, non-suppressed
+    activityMessageId: null,
+    activityEverOpened: false,
+    activityDrainFailures: 0,
+    replyCalled: false,
+    finalAnswerDelivered: false,
+    ...overrides,
+  }
+}
+
+describe('formatTurnLifecycle — tools= field uses labeledToolCount (#2461)', () => {
+  it('set action: tools= reports labeledToolCount, not toolCallCount', () => {
+    const t = makeTurn({ toolCallCount: 10, labeledToolCount: 5 })
+    const line = formatTurnLifecycle('set', 'enqueue', t, 1000)
+    expect(line).toContain('tools=5')
+    // The raw toolCallCount (10) must NOT appear in the tools= field.
+    expect(line).not.toMatch(/tools=10/)
+  })
+
+  it('clear action: tools= also uses labeledToolCount', () => {
+    const t = makeTurn({ toolCallCount: 7, labeledToolCount: 3 })
+    const line = formatTurnLifecycle('clear', 'turn_end', t, 2000)
+    expect(line).toContain('tools=3')
+    expect(line).not.toMatch(/tools=7/)
+  })
+
+  it('clear action: age_ms is computed from startedAt', () => {
+    const t = makeTurn({ startedAt: 1000 })
+    const line = formatTurnLifecycle('clear', 'turn_end', t, 3500)
+    expect(line).toContain('age_ms=2500')
+  })
+
+  it('set action: age_ms is always 0', () => {
+    const t = makeTurn({ startedAt: 1000 })
+    const line = formatTurnLifecycle('set', 'enqueue', t, 9999)
+    expect(line).toContain('age_ms=0')
+  })
+
+  it('includes turnId, chat, thread, feedOpened, drainFailures, replyCalled, finalAnswer', () => {
+    const t = makeTurn({
+      turnId: 'turn-xyz',
+      sessionChatId: '777',
+      sessionThreadId: 42,
+      activityMessageId: 99,
+      activityEverOpened: true,
+      activityDrainFailures: 2,
+      replyCalled: true,
+      finalAnswerDelivered: true,
+    })
+    const line = formatTurnLifecycle('clear', 'turn_end', t, 2000)
+    expect(line).toContain('turnId=turn-xyz')
+    expect(line).toContain('chat=777')
+    expect(line).toContain('thread=42')
+    expect(line).toContain('activityMsgId=99')
+    expect(line).toContain('feedOpened=true')
+    expect(line).toContain('drainFailures=2')
+    expect(line).toContain('replyCalled=true')
+    expect(line).toContain('finalAnswer=true')
+  })
+
+  it('thread=- when sessionThreadId is undefined', () => {
+    const t = makeTurn({ sessionThreadId: undefined })
+    const line = formatTurnLifecycle('set', 'enqueue', t, 1000)
+    expect(line).toContain('thread=-')
+  })
+
+  it('labeledToolCount=0 reports tools=0', () => {
+    const t = makeTurn({ labeledToolCount: 0, toolCallCount: 3 })
+    const line = formatTurnLifecycle('set', 'enqueue', t, 1000)
+    expect(line).toContain('tools=0')
+  })
+})
+
+describe('detectStatusSurfaceDegraded — uses labeledToolCount (#2461)', () => {
+  it('returns null when labeledToolCount=0 (no surfaced tool work this turn)', () => {
+    // Even if the raw toolCallCount is non-zero (surface-only tools like
+    // reply/react fired), labeledToolCount=0 means nothing to surface → null.
+    const t = makeTurn({ labeledToolCount: 0, toolCallCount: 5 })
+    expect(detectStatusSurfaceDegraded(t)).toBeNull()
+  })
+
+  it('H-2: reply-only turn — all tools surface-suppressed, drain failures present — no false-positive DEGRADED', () => {
+    // Scenario: agent sent a reply but all 5 tool_uses were surface tools
+    // (reply/react/etc) so labeledToolCount=0. Three activity-feed drain
+    // failures occurred (e.g. Telegram 400s from a stale anchor), but since
+    // there was nothing to surface, DEGRADED must NOT fire — the exemption is
+    // `labeledToolCount === 0`. This is the critical missing coverage case for
+    // the `labeledToolCount === 0` short-circuit in detectStatusSurfaceDegraded.
+    const t = makeTurn({
+      toolCallCount: 5,
+      labeledToolCount: 0,
+      activityDrainFailures: 3,
+      activityEverOpened: false,
+      replyCalled: true,
+    })
+    expect(detectStatusSurfaceDegraded(t)).toBeNull()
+  })
+
+  it('returns null when feed opened fine (activityEverOpened=true)', () => {
+    const t = makeTurn({ labeledToolCount: 3, activityEverOpened: true, activityDrainFailures: 2 })
+    expect(detectStatusSurfaceDegraded(t)).toBeNull()
+  })
+
+  it('returns null when no drain failures (feed never tried to open — not degraded)', () => {
+    const t = makeTurn({ labeledToolCount: 3, activityEverOpened: false, activityDrainFailures: 0 })
+    expect(detectStatusSurfaceDegraded(t)).toBeNull()
+  })
+
+  it('returns degraded when labeledToolCount>0, feed never opened, and drain failures>0', () => {
+    const t = makeTurn({
+      labeledToolCount: 4,
+      toolCallCount: 6,
+      activityEverOpened: false,
+      activityDrainFailures: 3,
+    })
+    const result = detectStatusSurfaceDegraded(t)
+    expect(result).not.toBeNull()
+    expect(result!.reason).toBe('feed-never-opened')
+    // detail uses labeledToolCount, not toolCallCount
+    expect(result!.detail).toContain('tools=4')
+    expect(result!.detail).not.toMatch(/tools=6/)
+    expect(result!.detail).toContain('drainFailures=3')
+  })
+})