switchroom 0.19.29 → 0.19.31

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

@@ -91,7 +91,8 @@ import {
   NESTED_PREFIX,
   WORKER_STEP_INDENT,
 } from './status-no-truncate.js'
-import { escapeMarkdown, truncate } from './card-format.js'
+import { cleanWorkerResultParagraph, escapeMarkdown, truncate } from './card-format.js'
+import { redact } from './secret-detect/redact.js'
 import { isTelegramSurfaceTool } from './tool-names.js'
 // The card layout core. Header composition (`metricsRun` /
 // `renderActivityHeader`), the per-line escape pipeline (`escapeStepLine`), the
@@ -158,6 +159,15 @@ export interface SessionActivityHeader {
    *  line via `tokenSegment`. Omitted (0/undefined) → no token segment, same
    *  clean-omit behavior as the worker feed. */
   totalTokens?: number
+  /**
+   * RAW final-summary text for the terminal `✅ <summary>` footer — the agent
+   * card's analogue of the worker card's `latestSummary` (the gateway passes
+   * the turn's delivered answer, `turn.lastReplyText`). Rendered ONLY on a
+   * final render, through the SHARED `deriveCardResult` the worker card uses,
+   * so both surfaces clean/cap/emoji it identically. Absent or empty → no
+   * footer block (the worker card's own fallback), never a fabricated line.
+   */
+  resultText?: string
 }
 
 /**
@@ -456,32 +466,71 @@ const WORKER_RESULT_RULE = '─────'
 const WORKER_RESULT_MAX = 320
 
 /**
- * Render the accumulated feed as ready Telegram HTML — one action per line,
- * newest last. The current (newest) step is bold with a `→`; finished steps
- * are italic with a `✓`. Capped to the last STATUS_ROLLING_LINES with a dim
- * `✓ +N earlier…` header when the turn ran longer. Returns null when empty.
- * Callers send the result verbatim — do NOT re-escape or re-wrap it.
+ * The ONE derivation of a card's terminal `✅/⚠️ <summary>` footer block, shared
+ * by the 🤖 agent card and the 🛠 worker card (#3844 unified the card BODY; the
+ * footer stayed forked until this landed — the agent card silently had no
+ * result block at all, so it ended on `✓ N steps` while the worker card ended
+ * on the green tick + summary sentence).
  *
- * Thin adapter over `renderStatusCard` (emoji 🤖, label 'Agent').
+ * Contract (the worker card's long-standing behaviour, now the spec for both):
+ *   - `running`     → no block. The card is not finished.
+ *   - `incomplete`  → NEVER a block, whatever `summary` carries. Truthful-no-
+ *                     result invariant: a reaped/abandoned unit produced no
+ *                     result, so it must not render a `⚠️`-prefixed paragraph
+ *                     out of stray summary text. Enforced HERE (deterministic
+ *                     mechanism) rather than left to caller discipline.
+ *   - `done`        → `✅` + the cleaned paragraph.
+ *   - `failed`      → `⚠️` + the cleaned paragraph.
+ *   - empty/absent summary, or one that cleans to nothing → no block. Omitting
+ *     is the fallback; the card never fabricates a sentence.
  *
- * `stepCount` (optional): when `final=true` and `stepCount > 0`, appends a
- * `✓ N steps` footer line.
+ * `summary` is RAW model-authored text (markdown, multi-line). It is scrubbed
+ * with `redact()` and cleaned with `cleanWorkerResultParagraph`;
+ * `renderStatusCard` does the final truncate + escape when it emits the block.
  *
- * `header` (optional): when provided, the two-line activity header carries
- * elapsed + tool count.
+ * The `redact()` is load-bearing, not belt-and-braces: status cards are sent
+ * via `sendRichMessage` and BYPASS the outbound redact chokepoint
+ * (`normalizeOutboundBody` → `redact`, outbound-send-path.ts:192) that scrubs
+ * every ordinary reply — the same gap `emitGatewayOperatorEvent` closes in
+ * gateway.ts. The agent card's summary is the turn's delivered answer text
+ * taken PRE-redaction, so scrubbing here is what keeps a token smuggled into a
+ * summary from reaching Telegram verbatim. It runs BEFORE markdown stripping /
+ * escaping, which is the order the outbound pipeline requires (redacting
+ * already-escaped text lets url-query-param secrets slip past url-redact).
  */
-export function renderActivityFeed(
+export function deriveCardResult(
+  state: CardState,
+  summary: string | undefined,
+): { emoji: string; text: string } | undefined {
+  if (state !== 'done' && state !== 'failed') return undefined
+  const text = cleanWorkerResultParagraph(redact(summary ?? ''))
+  if (text.length === 0) return undefined
+  return { emoji: state === 'done' ? '✅' : '⚠️', text }
+}
+
+/** Leading emoji for the main-session (🤖 Agent) card. */
+const AGENT_CARD_EMOJI = '🤖'
+
+/**
+ * The single 🤖-agent-card configuration of `renderStatusCard`. Both public
+ * agent-card entrypoints (`renderActivityFeed`, `renderActivityFeedWithNested`)
+ * funnel through this so the header mapping, the empty-guard, and the terminal
+ * result footer cannot drift between the flat and nested renders — they used
+ * to be two byte-copies of the same object literal.
+ */
+function renderAgentCard(
   lines: string[],
-  final = false,
-  liveSuffix = "",
-  stepCount?: number,
-  header?: SessionActivityHeader,
+  children: string[],
+  final: boolean,
+  liveSuffix: string,
+  stepCount: number | undefined,
+  header: SessionActivityHeader | undefined,
 ): string | null {
-  if (lines.length === 0 && header == null) return null;
+  if (lines.length === 0 && children.length === 0 && header == null) return null
   return renderStatusCard({
     header: header != null
       ? {
-          emoji: '🤖',
+          emoji: AGENT_CARD_EMOJI,
           label: header.label,
           elapsedMs: header.elapsedMs,
           toolCount: header.toolCount,
@@ -491,12 +540,46 @@ export function renderActivityFeed(
         }
       : undefined,
     steps: lines,
+    ...(children.length > 0 ? { childSteps: children } : {}),
     final,
     liveSuffix,
     stepCount,
+    // Same footer derivation the 🛠 worker card uses — one code path, so the
+    // two surfaces cannot drift apart again. Only a FINAL render can carry a
+    // result; a live render passes 'running' through and gets undefined.
+    result: final && header != null
+      ? deriveCardResult(header.state, header.resultText)
+      : undefined,
   })
 }
 
+/**
+ * Render the accumulated feed as ready Telegram HTML — one action per line,
+ * newest last. The current (newest) step is bold with a `→`; finished steps
+ * are italic with a `✓`. Capped to the last STATUS_ROLLING_LINES with a dim
+ * `✓ +N earlier…` header when the turn ran longer. Returns null when empty.
+ * Callers send the result verbatim — do NOT re-escape or re-wrap it.
+ *
+ * Thin adapter over `renderStatusCard` (emoji 🤖, label 'Agent') via the shared
+ * `renderAgentCard` configuration.
+ *
+ * `stepCount` (optional): when `final=true` and `stepCount > 0`, appends a
+ * `✓ N steps` footer line.
+ *
+ * `header` (optional): when provided, the two-line activity header carries
+ * elapsed + tool count — and, on a final render, `header.resultText` supplies
+ * the terminal `✅ <summary>` footer (identical derivation to the worker card).
+ */
+export function renderActivityFeed(
+  lines: string[],
+  final = false,
+  liveSuffix = "",
+  stepCount?: number,
+  header?: SessionActivityHeader,
+): string | null {
+  return renderAgentCard(lines, [], final, liveSuffix, stepCount, header)
+}
+
 // ─── Foreground sub-agent nesting (Model A) ─────────────────────────────────
 //
 // A foreground sub-agent (Task/Agent with no `run_in_background`) runs INSIDE
@@ -519,7 +602,8 @@ export const NESTED_MAX_LINES = 4;
  * a `↳ +N earlier…` header when it overflows. Returns ready Telegram HTML
  * (callers must NOT re-escape) or null when there is nothing to show.
  *
- * Thin adapter over `renderStatusCard` (emoji 🤖, label 'Agent', childSteps).
+ * Thin adapter over `renderStatusCard` (emoji 🤖, label 'Agent', childSteps) via
+ * the shared `renderAgentCard` configuration.
  */
 export function renderActivityFeedWithNested(
   lines: string[],
@@ -530,25 +614,7 @@ export function renderActivityFeedWithNested(
   header?: SessionActivityHeader,
 ): string | null {
   const children = childLines.map((s) => s.trim()).filter((s) => s.length > 0);
-  if (children.length === 0) return renderActivityFeed(lines, final, liveSuffix, stepCount, header);
-  return renderStatusCard({
-    header: header != null
-      ? {
-          emoji: '🤖',
-          label: header.label,
-          elapsedMs: header.elapsedMs,
-          toolCount: header.toolCount,
-          state: header.state,
-          model: header.model,
-          totalTokens: header.totalTokens,
-        }
-      : undefined,
-    steps: lines,
-    childSteps: children,
-    final,
-    liveSuffix,
-    stepCount,
-  })
+  return renderAgentCard(lines, children, final, liveSuffix, stepCount, header)
 }
 
 // ─── Combined multi-worker feed (coalesced one-message-per-chat) ────────────

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

@@ -50,13 +50,13 @@
  */
 
 import {
-  cleanWorkerResultParagraph,
   stripMarkdown,
   truncate,
 } from './card-format.js'
 import { WORKER_HISTORY_MAX } from './status-no-truncate.js'
 import { renderCardTitleLine } from './card-layout.js'
 import {
+  deriveCardResult,
   renderStatusCard,
   formatStepSuffix,
   renderCombinedWorkerFeed,
@@ -274,17 +274,12 @@ export function renderWorkerActivity(v: WorkerActivityView, liveSuffix = ''): st
   // Terminal: latestSummary carries the worker's final result text (gateway
   // onFinish), distinct from the running narrative steps. Pass it as `result`.
   //
-  // Truthful-no-result invariant (deterministic control, not caller-discipline):
-  // an `incomplete` worker produced NO result, so it must NEVER render a result
-  // block regardless of whatever `latestSummary` happens to carry. The current
-  // call site (terminateWorker) always sets latestSummary:'' for incomplete, but
-  // enforce the invariant HERE so any future/direct caller can't fabricate a
-  // `⚠️`-prefixed result paragraph out of stray summary text.
-  let result: { emoji: string; text: string } | undefined
-  if (finished && v.state !== 'incomplete') {
-    const text = cleanWorkerResultParagraph(v.latestSummary)
-    if (text.length > 0) result = { emoji: v.state === 'done' ? '✅' : '⚠️', text }
-  }
+  // The whole derivation — state gating, the truthful-no-result invariant for
+  // `incomplete`, ✅/⚠️ selection, and omission on an empty summary — lives ONCE
+  // in `deriveCardResult` and is SHARED with the 🤖 agent card. It used to be
+  // inline here, which is precisely why the agent card had no result footer at
+  // all: the logic was unreachable from the other surface.
+  const result = deriveCardResult(v.state, v.latestSummary)
 
   const card = renderStatusCard({
     header,
@@ -581,7 +576,7 @@ interface WorkerRow {
  * a 2+ worker group renders the combined `renderCombinedWorkerFeed` body.
  */
 interface FeedGroup {
-  /** Stable key `${chatId} ${threadId ?? ''}`. */
+  /** Stable `(chat, thread)` key — see `feedKeyOf`: `<chatId>:<threadId|->`. */
   feedKey: string
   chatId: string
   threadId?: number
@@ -735,7 +730,7 @@ export interface WorkerActivityFeed {
    *  re-post). Lets the gateway pin the EXISTING `🛠 Worker` message. Note:
    *  siblings sharing the chat/thread return the SAME id (one message). */
   messageIdOf(agentId: string): number | null
-  /** True while the feed group `feedKey` (`${chatId} ${threadId ?? ''}`) still
+  /** True while the feed group `feedKey` (see `feedKeyOf` — `<chatId>:<threadId|->`) still
    *  tracks live work — used by the gateway's `wk:group:` pin reaper to exempt
    *  a live group's pin from the stale-TTL sweep (#3207). */
   hasRunningInFeed(feedKey: string): boolean
@@ -822,7 +817,7 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
     })
   const clearIntervalFn = opts.clearInterval ?? ((handle: unknown) => clearInterval(handle as ReturnType<typeof setInterval>))
 
-  /** Feed groups keyed by `${chatId} ${threadId ?? ''}`. */
+  /** Feed groups keyed by `feedKeyOf(chatId, threadId)` — `<chatId>:<threadId|->`. */
   const groups = new Map<string, FeedGroup>()
   /** Reverse index agentId → feedKey, so the agentId-keyed public API resolves
    *  its group in O(1). Cleared when a worker's row is removed. */
@@ -849,8 +844,30 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
   }
   let heartbeatTimer: unknown = null
 
+  /**
+   * The `(chat, thread)` identity of a feed group — and, prefixed with
+   * `wk:group:`, the pin key that gets PERSISTED into status-pins.json.
+   *
+   * The separator and the topic-less sentinel are both load-bearing. This used
+   * to be `` `${chatId} ${threadId ?? ''}` ``, which for a topic-less group
+   * rendered as `-1004223464247 ` — a key ending in a bare space. On disk that
+   * became `"pinKey": "wk:group:-1004223464247 "`: trailing whitespace that
+   * survives JSON round-trips, is invisible in every log line and grep, and
+   * cannot be distinguished by eye from the same chat WITH a topic. Any operator
+   * or tool reconciling rows by chat would silently treat the two as one.
+   *
+   * `<chatId>:<threadId|->` is unambiguous in both directions: the topic-less
+   * case is spelled explicitly (`-`), and a topic key can never be confused with
+   * a topic-less one. Note chat ids are negative, so the `-` sentinel and the
+   * sign of the id never occupy the same position.
+   *
+   * The value is opaque to every consumer (it round-trips through the pin key
+   * and back into `hasRunningInFeed`), so the format may change; a key written
+   * by an older build is work-scoped and is unpinned unconditionally by the next
+   * boot's cleanup, so there is nothing to migrate.
+   */
   function feedKeyOf(chatId: string, threadId?: number): string {
-    return `${chatId} ${threadId ?? ''}`
+    return `${chatId}:${threadId ?? '-'}`
   }
   function groupOfAgent(agentId: string): FeedGroup | undefined {
     const key = agentIndex.get(agentId)

package/telegram-plugin/gateway/dm-pin-sweep.test.ts

@@ -1,251 +0,0 @@
-import { describe, expect, it, vi } from 'vitest'
-import {
-  isDmChatId,
-  collectDmChatIdsFromStores,
-  createDmPinSweeper,
-  unexpiredStoreRepinIds,
-  type DmPinSweeperDeps,
-} from './dm-pin-sweep'
-
-// Synthetic chat IDs only (check-no-pii-secrets): positive = DM, negative =
-// group/supergroup.
-const DM_A = '5000001'
-const DM_B = '5000002'
-const GROUP = '-1002000000001'
-
-describe('isDmChatId', () => {
-  it('true for positive integer DM ids', () => {
-    expect(isDmChatId(DM_A)).toBe(true)
-    expect(isDmChatId('1')).toBe(true)
-  })
-  it('false for group/supergroup (negative), zero, non-integer, non-numeric', () => {
-    expect(isDmChatId(GROUP)).toBe(false)
-    expect(isDmChatId('-1')).toBe(false)
-    expect(isDmChatId('0')).toBe(false)
-    expect(isDmChatId('1.5')).toBe(false)
-    expect(isDmChatId('abc')).toBe(false)
-    expect(isDmChatId('')).toBe(false)
-    expect(isDmChatId('Infinity')).toBe(false)
-  })
-})
-
-describe('collectDmChatIdsFromStores', () => {
-  it('collects distinct DM chat ids across all three stores and drops non-DMs', () => {
-    const ids = collectDmChatIdsFromStores({
-      statusPins: [{ chatId: DM_A }, { chatId: GROUP }, { chatId: DM_A }],
-      activityCards: [{ chatId: DM_B }, { chatId: '0' }],
-      queuedCards: [{ chatId: DM_A }, { chatId: '-77' }],
-    })
-    expect(new Set(ids)).toEqual(new Set([DM_A, DM_B]))
-    expect(ids).toHaveLength(2)
-  })
-  it('handles missing store arrays', () => {
-    expect(collectDmChatIdsFromStores({})).toEqual([])
-    expect(collectDmChatIdsFromStores({ statusPins: [{ chatId: GROUP }] })).toEqual([])
-  })
-})
-
-function makeDeps(overrides: Partial<DmPinSweeperDeps> = {}): {
-  deps: DmPinSweeperDeps
-  unpinAll: ReturnType<typeof vi.fn>
-  pinSilent: ReturnType<typeof vi.fn>
-} {
-  const unpinAll = vi.fn(async () => undefined)
-  const pinSilent = vi.fn(async () => undefined)
-  const deps: DmPinSweeperDeps = {
-    unpinAll,
-    pinSilent,
-    liveTrackedMessageIds: () => [],
-    eligible: () => true,
-    log: () => {},
-    ...overrides,
-  }
-  return { deps, unpinAll, pinSilent }
-}
-
-describe('createDmPinSweeper', () => {
-  it('DM with tracked pins: unpin-all exactly once, then re-pin exactly the live ids', async () => {
-    const { deps, unpinAll, pinSilent } = makeDeps({
-      liveTrackedMessageIds: (chatId) => (chatId === DM_A ? [111, 222] : []),
-    })
-    const sweeper = createDmPinSweeper(deps)
-    await sweeper.sweep(DM_A)
-
-    expect(unpinAll).toHaveBeenCalledTimes(1)
-    expect(unpinAll).toHaveBeenCalledWith(DM_A)
-    expect(pinSilent.mock.calls).toEqual([
-      [DM_A, 111],
-      [DM_A, 222],
-    ])
-    expect(sweeper.hasSwept(DM_A)).toBe(true)
-  })
-
-  it('DM with no tracked pins: unpin-all once, no re-pin', async () => {
-    const { deps, unpinAll, pinSilent } = makeDeps()
-    const sweeper = createDmPinSweeper(deps)
-    await sweeper.sweep(DM_A)
-    expect(unpinAll).toHaveBeenCalledTimes(1)
-    expect(pinSilent).not.toHaveBeenCalled()
-  })
-
-  it('group/supergroup id: never unpin-all (keeps human pins)', async () => {
-    const { deps, unpinAll, pinSilent } = makeDeps()
-    const sweeper = createDmPinSweeper(deps)
-    await sweeper.sweep(GROUP)
-    await sweeper.sweep('-1')
-    expect(unpinAll).not.toHaveBeenCalled()
-    expect(pinSilent).not.toHaveBeenCalled()
-  })
-
-  it('not eligible (lost startup mutex): does nothing', async () => {
-    const { deps, unpinAll } = makeDeps({ eligible: () => false })
-    const sweeper = createDmPinSweeper(deps)
-    await sweeper.sweep(DM_A)
-    expect(unpinAll).not.toHaveBeenCalled()
-    expect(sweeper.hasSwept(DM_A)).toBe(false)
-  })
-
-  it('second sweep of same chat does not re-sweep', async () => {
-    const { deps, unpinAll } = makeDeps()
-    const sweeper = createDmPinSweeper(deps)
-    await sweeper.sweep(DM_A)
-    await sweeper.sweep(DM_A)
-    expect(unpinAll).toHaveBeenCalledTimes(1)
-  })
-
-  it('concurrent triggers on the same chat fire unpin-all only once', async () => {
-    let resolveUnpin: () => void = () => {}
-    const unpinAll = vi.fn(
-      () =>
-        new Promise<void>((res) => {
-          resolveUnpin = res
-        }),
-    )
-    const { deps } = makeDeps({ unpinAll })
-    const sweeper = createDmPinSweeper(deps)
-    const p1 = sweeper.sweep(DM_A)
-    const p2 = sweeper.sweep(DM_A)
-    resolveUnpin()
-    await Promise.all([p1, p2])
-    expect(unpinAll).toHaveBeenCalledTimes(1)
-  })
-
-  it('429 / unpin-all rejects: degrades without throwing, still re-pins live ids', async () => {
-    const unpinAll = vi.fn(async () => {
-      throw new Error('429: Too Many Requests: retry after 30')
-    })
-    const { deps, pinSilent } = makeDeps({
-      unpinAll,
-      liveTrackedMessageIds: () => [333],
-    })
-    const sweeper = createDmPinSweeper(deps)
-    // Must not reject.
-    await expect(sweeper.sweep(DM_A)).resolves.toBeUndefined()
-    expect(unpinAll).toHaveBeenCalledTimes(1)
-    expect(pinSilent).toHaveBeenCalledWith(DM_A, 333)
-  })
-
-  it('re-pin failure is absorbed and does not reject', async () => {
-    const pinSilent = vi.fn(async () => {
-      throw new Error('pin failed')
-    })
-    const { deps } = makeDeps({
-      pinSilent,
-      liveTrackedMessageIds: () => [444],
-    })
-    const sweeper = createDmPinSweeper(deps)
-    await expect(sweeper.sweep(DM_A)).resolves.toBeUndefined()
-  })
-
-  it('no unhandled rejection escapes a failing sweep (fire-and-forget safe)', async () => {
-    const unhandled: unknown[] = []
-    const onUnhandled = (r: unknown): void => {
-      unhandled.push(r)
-    }
-    process.on('unhandledRejection', onUnhandled)
-    try {
-      const { deps } = makeDeps({
-        unpinAll: async () => {
-          throw new Error('boom')
-        },
-        liveTrackedMessageIds: () => [555],
-      })
-      const sweeper = createDmPinSweeper(deps)
-      // Fire-and-forget, as the gateway does.
-      void sweeper.sweep(DM_A)
-      await new Promise((r) => setTimeout(r, 10))
-    } finally {
-      process.off('unhandledRejection', onUnhandled)
-    }
-    expect(unhandled).toEqual([])
-  })
-})
-
-describe('tool-pin survival (#3001 contract, review blocker on #3074)', () => {
-  const NOW = 1_752_000_000_000
-
-  it('unexpiredStoreRepinIds keeps unexpired tool rows for the chat, drops expired / work-scoped / other-chat rows', () => {
-    const rows = [
-      // Unexpired tool pin in this chat — MUST survive.
-      { chatId: DM_A, messageId: 10, expiresAt: NOW + 60_000 },
-      // Expired tool pin — due for sweeping, NOT re-pinned.
-      { chatId: DM_A, messageId: 11, expiresAt: NOW - 1 },
-      // Work-scoped row (no expiresAt) — stale after restart, NOT re-pinned.
-      { chatId: DM_A, messageId: 12 },
-      // Unexpired tool pin in a DIFFERENT chat — not this chat's re-pin set.
-      { chatId: DM_B, messageId: 13, expiresAt: NOW + 60_000 },
-    ]
-    expect(unexpiredStoreRepinIds(rows, DM_A, NOW)).toEqual([10])
-    expect(unexpiredStoreRepinIds(rows, DM_B, NOW)).toEqual([13])
-  })
-
-  // Composition test mirroring the gateway wiring: liveTrackedMessageIds
-  // unions in-memory claims with unexpired store rows.
-  function gatewayStyleDeps(args: {
-    inMemory: number[]
-    storeRows: { chatId: string; messageId: number; expiresAt?: number }[]
-  }): ReturnType<typeof makeDeps> {
-    return makeDeps({
-      liveTrackedMessageIds: (chatId) => [
-        ...args.inMemory,
-        ...unexpiredStoreRepinIds(args.storeRows, chatId, NOW),
-      ],
-    })
-  }
-
-  it('(a) boot sweep: DM with an unexpired tool: row → unpinAll once, then that messageId re-pinned', async () => {
-    const { deps, unpinAll, pinSilent } = gatewayStyleDeps({
-      inMemory: [], // fresh boot — in-memory claims empty
-      storeRows: [{ chatId: DM_A, messageId: 777, expiresAt: NOW + 60_000 }],
-    })
-    const sweeper = createDmPinSweeper(deps)
-    await sweeper.sweep(DM_A)
-    expect(unpinAll).toHaveBeenCalledTimes(1)
-    expect(pinSilent.mock.calls).toEqual([[DM_A, 777]])
-  })
-
-  it('(b) expired tool: row is NOT re-pinned', async () => {
-    const { deps, unpinAll, pinSilent } = gatewayStyleDeps({
-      inMemory: [],
-      storeRows: [{ chatId: DM_A, messageId: 778, expiresAt: NOW - 1 }],
-    })
-    const sweeper = createDmPinSweeper(deps)
-    await sweeper.sweep(DM_A)
-    expect(unpinAll).toHaveBeenCalledTimes(1)
-    expect(pinSilent).not.toHaveBeenCalled()
-  })
-
-  it('(c) first-inbound sweep preserves an unexpired tool pin alongside a live in-memory claim, deduped', async () => {
-    const { deps, pinSilent } = gatewayStyleDeps({
-      inMemory: [500, 777], // live fg: claim + the tool pin also claimed in-memory
-      storeRows: [{ chatId: DM_A, messageId: 777, expiresAt: NOW + 60_000 }],
-    })
-    const sweeper = createDmPinSweeper(deps)
-    await sweeper.sweep(DM_A)
-    // 777 appears in BOTH sources but is re-pinned exactly once.
-    expect(pinSilent.mock.calls).toEqual([
-      [DM_A, 500],
-      [DM_A, 777],
-    ])
-  })
-})