switchroom 0.19.26 → 0.19.27

package/telegram-plugin/tests/test-runner-coverage.test.ts

@@ -0,0 +1,133 @@
+/**
+ * Fence for the "test file runs in NEITHER CI runner" class (#3756).
+ *
+ * The repo has two runners wired independently — vitest (everything minus
+ * `vitest.config.ts`'s `exclude`) and `bun test` with an explicit target list
+ * in `telegram-plugin/scripts/bun-test-ci.sh`. A file excluded from vitest and
+ * never named in the bun list is executed by nothing, and nothing goes red.
+ * That is how `telegram-plugin/uat/feed-matcher.test.ts` — a file whose own
+ * docblock calls it "the CI-verifiable floor" for the worker-feed matcher, and
+ * which #3821 extended with `stripCardNesting` assertions — sat unexecuted.
+ *
+ * The regression assertions below read the REAL config off disk, so they fail
+ * on `origin/main` at f9314b89e and can only be made green by actually giving
+ * those files a runner.
+ */
+import { describe, it, expect } from "vitest";
+// @ts-expect-error — plain .mjs lint script, no type declarations by design.
+import { findOrphanTestFiles, loadRepoInputs } from "../../scripts/check-test-runner-coverage.mjs";
+
+type Inputs = {
+  files: string[];
+  excludeGlobs: string[];
+  bunTargets: string[];
+  allowGlobs: string[];
+};
+
+const findOrphans = findOrphanTestFiles as (i: Inputs) => string[];
+const realInputs = loadRepoInputs as () => Inputs;
+
+describe("findOrphanTestFiles (detection logic)", () => {
+  const base: Inputs = { files: [], excludeGlobs: [], bunTargets: [], allowGlobs: [] };
+
+  it("flags a vitest-excluded file that no bun target names", () => {
+    expect(
+      findOrphans({
+        ...base,
+        files: ["telegram-plugin/uat/feed-matcher.test.ts"],
+        excludeGlobs: ["**/telegram-plugin/uat/**"],
+      }),
+    ).toEqual(["telegram-plugin/uat/feed-matcher.test.ts"]);
+  });
+
+  it("does not flag a file vitest still runs", () => {
+    expect(
+      findOrphans({ ...base, files: ["telegram-plugin/tests/status-pin.test.ts"] }),
+    ).toEqual([]);
+  });
+
+  it("does not flag a vitest-excluded file the bun job names by path", () => {
+    expect(
+      findOrphans({
+        ...base,
+        files: ["telegram-plugin/uat/feed-matcher.test.ts"],
+        excludeGlobs: ["**/telegram-plugin/uat/**"],
+        bunTargets: ["uat/feed-matcher.test.ts"],
+      }),
+    ).toEqual([]);
+  });
+
+  it("does not flag a vitest-excluded file the bun job covers by directory", () => {
+    expect(
+      findOrphans({
+        ...base,
+        files: ["telegram-plugin/tests/history.test.ts"],
+        excludeGlobs: ["**/telegram-plugin/tests/history.test.ts"],
+        bunTargets: ["tests"],
+      }),
+    ).toEqual([]);
+  });
+
+  it("a bun target only covers files UNDER telegram-plugin/ (that is the job's cwd)", () => {
+    // The bun job runs `working-directory: telegram-plugin`, so a repo-root
+    // path can never be matched by its filters — the exact reason the whole
+    // src/vault bun suite is orphaned.
+    expect(
+      findOrphans({
+        ...base,
+        files: ["src/vault/broker/server.test.ts"],
+        excludeGlobs: ["**/src/vault/broker/server.test.ts"],
+        bunTargets: ["src/vault/broker/server.test.ts"],
+      }),
+    ).toEqual(["src/vault/broker/server.test.ts"]);
+  });
+
+  it("honours the allowlist", () => {
+    expect(
+      findOrphans({
+        ...base,
+        files: ["telegram-plugin/uat/scenarios/smoke-dm-reply.test.ts"],
+        excludeGlobs: ["**/telegram-plugin/uat/**"],
+        allowGlobs: ["**/telegram-plugin/uat/scenarios/**"],
+      }),
+    ).toEqual([]);
+  });
+});
+
+describe("real repo configuration", () => {
+  it("has no un-allowlisted orphans", () => {
+    expect(findOrphans(realInputs())).toEqual([]);
+  });
+
+  // The specific regression. All five are hosted (no creds, no live Telegram)
+  // and were swallowed wholesale by vitest's `**/telegram-plugin/uat/**`
+  // exclude with nothing on the bun side naming them.
+  it.each([
+    "telegram-plugin/uat/feed-matcher.test.ts",
+    "telegram-plugin/uat/load-env.test.ts",
+    "telegram-plugin/uat/uat-driver.test.ts",
+    "telegram-plugin/uat/runners/scorer.test.ts",
+    "telegram-plugin/uat/runners/skill-coverage.test.ts",
+  ])("%s is executed by a CI runner", (file) => {
+    const inputs = realInputs();
+    expect(inputs.files).toContain(file);
+    // Not merely allowlisted away — genuinely covered by a runner.
+    expect(findOrphans({ ...inputs, allowGlobs: [] })).not.toContain(file);
+  });
+
+  it("no bun target is broad enough to drag in the live-Telegram scenarios", () => {
+    // The other half of the contract. `uat/scenarios/**` drives a real MTProto
+    // session; a bare `uat` filter in BUN_TEST_ARGS would pull every scenario
+    // into the ordinary bun-test job, where it would fail (or worse, message a
+    // real chat). Assert no scenario file is reachable from the bun list.
+    const inputs = realInputs();
+    const scenarios = inputs.files.filter((f) =>
+      f.startsWith("telegram-plugin/uat/scenarios/"),
+    );
+    expect(scenarios.length).toBeGreaterThan(50);
+    const reachable = scenarios.filter((f) =>
+      inputs.bunTargets.some((t) => f.slice("telegram-plugin/".length).includes(t)),
+    );
+    expect(reachable).toEqual([]);
+  });
+});

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

@@ -76,7 +76,8 @@ describe('renderWorkerActivity', () => {
 
   it('renders the native header + running status + step feed', () => {
     const out = renderWorkerActivity(view())
-    expect(out).toContain('└─ 🛠 **WORKER** · _research competitors_')
+    // #3842: flush at the left margin — no `└─ ` card-level prefix.
+    expect(out.startsWith('🛠 **WORKER** · _research competitors_')).toBe(true)
     // Unified header: running shows "<elapsed> · N tools" (no "running ·" word).
     expect(out).toContain('_10s · 3 tools_')
     expect(out).toContain('3 tools')
@@ -100,7 +101,8 @@ describe('renderWorkerActivity', () => {
 
   it('shows a "starting…" line when no step has run yet', () => {
     const out = renderWorkerActivity(view({ lastTool: null, latestSummary: '' }))
-    expect(out).toContain('└─ 🛠 **WORKER**')
+    // #3842: flush at the left margin — no `└─ ` card-level prefix.
+    expect(out.startsWith('🛠 **WORKER**')).toBe(true)
     expect(out).toContain('starting…')
     expect(out).not.toContain('→')
   })
@@ -121,7 +123,7 @@ describe('renderWorkerActivity', () => {
     const out = renderWorkerActivity(
       view({ state: 'done', toolCount: 5, latestSummary: 'PR #21 opened' }),
     )
-    expect(out).toContain('└─ 🛠 **WORKER** · _research competitors_')
+    expect(out).toContain('🛠 **WORKER** · _research competitors_')
     // Unified done header: "done · N tools · <elapsed>".
     expect(out).toContain('_done · 5 tools · ')
     expect(out).toContain('─────')
@@ -227,7 +229,7 @@ describe('renderWorkerActivity', () => {
         narrativeLines: ['- ran the **full** suite', '`git push`'],
       }),
     )
-    expect(running).toContain('└─ 🛠 **WORKER** · _Build the sync_')
+    expect(running).toContain('🛠 **WORKER** · _Build the sync_')
     expect(running).toContain('ran the full suite')
     expect(running).toContain('git push')
     // The CONTENT bold/code markers were stripped — no `**full**`, no backticks.
@@ -298,7 +300,7 @@ describe('createWorkerActivityFeed', () => {
     // #2669: the worker feed body is raw GFM markdown sent through the rich
     // path (the gateway wires sendMessage → sendRichMessage). No parse_mode.
     expect(bot.sent[0].opts?.parse_mode).toBeUndefined()
-    expect(bot.sent[0].text).toContain('└─ 🛠 **WORKER**')
+    expect(bot.sent[0].text).toContain('🛠 **WORKER**')
     expect(feed.has('w1')).toBe(true)
   })
 
@@ -932,7 +934,7 @@ describe('createWorkerActivityFeed — heartbeat', () => {
     await drain()
     expect(bot.sent).toHaveLength(1)
     expect(feed.messageIdOf('w1')).toBe(1000)
-    expect(bot.sent[0].text).toContain('└─ 🛠 **WORKER**')
+    expect(bot.sent[0].text).toContain('🛠 **WORKER**')
 
     // And it keeps updating: a later heartbeat edits the message with a
     // climbing `· Ns` suffix so the still-alive worker visibly advances.
@@ -1328,7 +1330,7 @@ describe('header row + rolling overflow survive in the unified worker render', (
     )
     const out = renderWorkerActivity(view({ narrativeLines, toolCount: 7 }))
 
-    expect(out).toContain('└─ 🛠 **WORKER**')
+    expect(out).toContain('🛠 **WORKER**')
     // Unified running status line.
     expect(out).toContain('_10s · 7 tools_')
     expect(out).toContain('7 tools')
@@ -1344,7 +1346,7 @@ describe('header row + rolling overflow survive in the unified worker render', (
 
     expect(out.length).toBeLessThanOrEqual(4096)
     expect(out).toContain('earlier…')
-    expect(out).toContain('└─ 🛠 **WORKER**')
+    expect(out).toContain('🛠 **WORKER**')
     expect(out).toContain('_10s · ')
   })
 
@@ -1359,7 +1361,7 @@ describe('header row + rolling overflow survive in the unified worker render', (
     expect(out.length).toBeLessThanOrEqual(4096)
     const hasBullet = out.includes('→') || out.includes('✓')
     expect(hasBullet).toBe(true)
-    expect(out).toContain('└─ 🛠 **WORKER**')
+    expect(out).toContain('🛠 **WORKER**')
     expect(out).toContain('_10s · ')
     expect(isValidWorkerMarkdown(out)).toBe(true)
   })
@@ -1525,7 +1527,7 @@ describe('worker-feed send-gate shed contract', () => {
     await feed.update('w1', 'chat', view({ elapsedMs: clock }))
     expect(bot.sendCalls).toBe(1)
     expect(bot.sent).toHaveLength(1)
-    expect(bot.sent[0].text).toContain('└─ 🛠 **WORKER**')
+    expect(bot.sent[0].text).toContain('🛠 **WORKER**')
     expect(feed.has('w1')).toBe(true)
   })
 

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

@@ -6,12 +6,7 @@ import {
   type WorkerActivityView,
 } from '../worker-activity-feed.js'
 import { renderCombinedWorkerFeed, combinedHistoryDepth } from '../tool-activity-summary.js'
-import {
-  STATUS_CARD_CHAR_BUDGET,
-  WORKER_STEP_INDENT,
-  SUBORDINATE_HEADER_PREFIX,
-  SUBORDINATE_LINE_INDENT,
-} from '../status-no-truncate.js'
+import { STATUS_CARD_CHAR_BUDGET, WORKER_STEP_INDENT } from '../status-no-truncate.js'
 import { COLLAPSE_SAFE_SEPARATOR } from '../card-format.js'
 import { richMessage } from '../rich-send.js'
 import { parseRichEntities, validateRichMarkdown } from './rich-markdown-oracle.js'
@@ -1292,22 +1287,22 @@ describe('combined worker card — steps indent under their worker (U+2800)', ()
     // Load-bearing: the exact indent bytes. `WORKER_STEP_INDENT` is U+2800 ×3;
     // a plain-ASCII `'   '` indent fails this assertion, so does the U+00A0 run
     // #3662 shipped, and so does flat output with no prefix at all.
-    // Since #3820 the whole card is nested one level under the 🤖 agent card,
-    // so a step sits at SUBORDINATE_LINE_INDENT + WORKER_STEP_INDENT while its
-    // worker header sits at SUBORDINATE_LINE_INDENT alone — the RELATIVE
-    // one-level nesting this test guards is unchanged, just shifted right.
+    // #3842 removed the whole-card nesting #3820 added, so a step sits at
+    // EXACTLY one WORKER_STEP_INDENT — not two — and its worker header sits
+    // flush at the left margin. The RELATIVE one-level nesting this test guards
+    // is unchanged; the whole block shifted back left.
     for (const l of stepLines) {
-      expect(l.startsWith(SUBORDINATE_LINE_INDENT + WORKER_STEP_INDENT)).toBe(true)
+      expect(l.startsWith(WORKER_STEP_INDENT)).toBe(true)
+      expect(l.startsWith(WORKER_STEP_INDENT + WORKER_STEP_INDENT)).toBe(false)
       expect(l.startsWith(BLANK)).toBe(true)
       expect(l.startsWith(' ')).toBe(false)
       expect(l.startsWith(NBSP)).toBe(false)
     }
     // Workers stay one level ABOVE their steps so the nesting reads as nesting.
     for (const l of headerLines) {
-      expect(l.startsWith(SUBORDINATE_LINE_INDENT)).toBe(true)
-      expect(l.startsWith(SUBORDINATE_LINE_INDENT + WORKER_STEP_INDENT)).toBe(false)
+      expect(l.startsWith(WORKER_STEP_INDENT)).toBe(false)
     }
-    expect(lines[0].startsWith(`${SUBORDINATE_HEADER_PREFIX}🛠`)).toBe(true)
+    expect(lines[0].startsWith('🛠')).toBe(true)
   })
 
   it('golden body — each worker header is immediately followed by ITS indented steps', () => {
@@ -1317,8 +1312,8 @@ describe('combined worker card — steps indent under their worker (U+2800)', ()
     // would still pass every one of them. This pins the full line ORDER, which
     // is the actual thing the fix is for: a step must sit under its own worker.
     const body = renderCombinedWorkerFeed(rowsFor(3), { maxRows: 8 })!
-    const I = SUBORDINATE_LINE_INDENT + WORKER_STEP_INDENT
-    const N = SUBORDINATE_LINE_INDENT
+    const I = WORKER_STEP_INDENT
+    const N = ''
     // `S` is the pinned-bar collapse separator (#3666): every line that is
     // followed by a hard break carries one trailing U+00A0 so the pinned-message
     // bar (which drops the newline and substitutes nothing) does not mash the
@@ -1327,7 +1322,7 @@ describe('combined worker card — steps indent under their worker (U+2800)', ()
     // `WORKER_STEP_INDENT`, which is what this golden is really pinning.
     const S = COLLAPSE_SAFE_SEPARATOR
     expect(linesOf(body)).toEqual([
-      `${SUBORDINATE_HEADER_PREFIX}🛠 **WORKERS** · _3 running · oldest 3m00s · 9 tools_${S}`,
+      `🛠 **WORKERS** · _3 running · oldest 3m00s · 9 tools_${S}`,
       `${N}**1. worker task 1** _· 1m00s · 3 tools_${S}`,
       `${I}~~_✓ w1 step a_~~${S}`,
       `${I}**→ w1 step b**${S}`,
@@ -1455,7 +1450,7 @@ describe('combined worker card — steps indent under their worker (U+2800)', ()
     expect(ents.every((e) => !e.text.includes(NBSP))).toBe(true)
   })
 
-  it('the SINGLE-worker 🛠 card nests ONE level (card-level only, no per-worker indent)', () => {
+  it('the SINGLE-worker 🛠 card is entirely FLUSH — no card indent, no step indent (#3842)', () => {
     const single = renderWorkerActivity({
       workerId: 'w1',
       description: 'lone worker',
@@ -1467,18 +1462,17 @@ describe('combined worker card — steps indent under their worker (U+2800)', ()
     })
     expect(single).toContain('~~_✓ step a_~~')
     expect(single).toContain('**→ step b**')
-    // The lone-worker card has no worker HEADER to nest steps under, so it must
-    // never carry the per-worker indent — but since #3820 the whole card nests
-    // ONE level under the 🤖 agent card, so its body lines sit at exactly
-    // SUBORDINATE_LINE_INDENT and never at two levels. Asserted per line on the
-    // leading edge rather than as "no U+00A0 anywhere in the card", because
-    // #3666 puts one TRAILING U+00A0 on every hard-broken line of every pinned
-    // card (this one included) as the collapse separator.
+    // The lone-worker card has no worker HEADER to nest steps under, so there is
+    // nothing for an indent to distinguish — and #3842 removed the whole-card
+    // nesting #3820 added, so EVERY line sits at the left margin. Asserted per
+    // line on the leading edge rather than as "no U+2800 anywhere in the card",
+    // because #3666 puts one TRAILING U+00A0 on every hard-broken line of every
+    // pinned card (this one included) as the collapse separator.
     const ls = single.split('\n')
-    expect(ls[0].startsWith(SUBORDINATE_HEADER_PREFIX)).toBe(true)
-    for (const l of ls.slice(1)) {
-      expect(l.startsWith(SUBORDINATE_LINE_INDENT)).toBe(true)
-      expect(l.startsWith(SUBORDINATE_LINE_INDENT + WORKER_STEP_INDENT)).toBe(false)
+    expect(ls[0].startsWith('🛠 **WORKER**')).toBe(true)
+    for (const l of ls) {
+      expect(l.startsWith(WORKER_STEP_INDENT)).toBe(false)
+      expect(l.startsWith('└─')).toBe(false)
       expect(l.startsWith(NBSP)).toBe(false)
     }
   })

package/telegram-plugin/tests/worker-feed-pin-persistence.test.ts

@@ -4,13 +4,22 @@ import {
   type WorkerActivityView,
   type BotApiForWorkerFeed,
 } from '../worker-activity-feed.js'
-import { reconcilePin, type PinBotApi } from '../status-pin-driver.js'
-import { decidePinAction, type PinState, type DesiredPin } from '../status-pin.js'
+import { executePinLeg, type PinBotApi } from '../status-pin-driver.js'
+import type { PinState, DesiredPin } from '../status-pin.js'
 import {
-  reconcileAndPersistStatusPin,
   loadStatusPins,
+  type PersistedStatusPin,
   type StatusPinStoreFsSeam,
 } from '../gateway/status-pin-store.js'
+import {
+  runStatusPinReconcile,
+  type StatusPinClaim,
+} from '../gateway/status-pin-retarget.js'
+
+/** Drop the #3810 claim-age stamp so a row's identity can be compared literally. */
+function idOnly(rows: PersistedStatusPin[]): Omit<PersistedStatusPin, 'pinnedAt'>[] {
+  return rows.map(({ pinnedAt: _age, ...rest }) => rest)
+}
 
 /**
  * Outcome tests for the invisible-worker-cards fix (2026-07-15).
@@ -21,9 +30,10 @@ import {
  * the pin was lost out-of-band (its in-memory claim dropped), the reused message
  * kept being edited live but was never re-pinned → scroll-buried / invisible.
  *
- * These tests wire the feed's `reconcilePin` hook into the REAL status-pin
- * driver + a claim map exactly as the gateway does (`wk:group:<feedKey>` key,
- * `void reconcileStatusPin`), and assert the PIN-CALL OUTCOMES:
+ * These tests wire the feed's `reconcilePin` hook into the REAL unified reconcile
+ * path (`runStatusPinReconcile` over `executePinLeg`) + a claim map exactly as
+ * the gateway does (`wk:group:<feedKey>` key, `void reconcileStatusPin`), and
+ * assert the PIN-CALL OUTCOMES:
  *   1. a steady-state edit re-pins when the claim was lost — and does NOT re-pin
  *      (no storm) when the claim is already correct.
  *   2. routing an unpin through the reconciler CLEARS the claim, so a later edit
@@ -68,13 +78,13 @@ function makeFakeBot(): FakeBot {
 }
 
 /**
- * Mirror the gateway's status-pin reconcile: a `Map<key,PinState>` claim store
- * driven through the real `reconcilePin` driver against a fake pin API that
- * records every pin/unpin call. This is the seam that turns a `reconcilePin`
- * hook call into an observable Telegram pin/unpin — proving OUTCOMES, not paths.
+ * Mirror the gateway's status-pin reconcile: ONE claim registry driven through
+ * the real orchestrator + driver against a fake pin API that records every
+ * pin/unpin call. This is the seam that turns a `reconcilePin` hook call into an
+ * observable Telegram pin/unpin — proving OUTCOMES, not paths.
  */
 function makePinHarness() {
-  const state = new Map<string, PinState>()
+  const claims = new Map<string, StatusPinClaim>()
   const pinCalls: number[] = []
   const unpinCalls: number[] = []
   let lastKey: string | null = null
@@ -87,10 +97,16 @@ function makePinHarness() {
     },
   }
   async function reconcile(key: string, chatId: string, desired: DesiredPin): Promise<void> {
-    const prev = state.get(key) ?? null
-    const next = await reconcilePin({ api, chatId, prevState: prev, desired })
-    if (next == null) state.delete(key)
-    else state.set(key, next)
+    const claim = claims.get(key)
+    await runStatusPinReconcile({
+      pinKey: key,
+      chatId,
+      prev: claim == null ? null : { messageId: claim.messageId },
+      desired,
+      persist: null,
+      runPin: (action, from) => executePinLeg({ api, chatId, prevState: from, action }),
+      claims,
+    })
   }
   const reconcilePinFn = (args: {
     feedKey: string
@@ -104,7 +120,8 @@ function makePinHarness() {
     else void reconcile(key, args.chatId, { pinned: false })
   }
   return {
-    state,
+    claims,
+    reconcile,
     pinCalls,
     unpinCalls,
     reconcilePinFn,
@@ -114,7 +131,7 @@ function makePinHarness() {
     },
     /** Directly drop the claim to simulate a pin lost out-of-band. */
     dropClaim(): void {
-      state.clear()
+      claims.clear()
     },
   }
 }
@@ -147,14 +164,15 @@ function memFs(): { fs: StatusPinStoreFsSeam; files: Map<string, string> } {
 
 /**
  * A pin harness that routes the feed's `reconcilePin` hook through the REAL
- * persistence path (`reconcileAndPersistStatusPin`) against a memFs-backed
- * status-pins.json — exactly as the gateway wires it: read prev claim → decide
- * → map to a persist op → reconcileAndPersistStatusPin(applyPin=reconcilePin).
- * This lets a test INSPECT THE FILE across steady-state edits (F1).
+ * persistence path against a memFs-backed status-pins.json — exactly as the
+ * gateway wires it: read prev claim → runStatusPinReconcile (which decides ONCE,
+ * maps each leg to a persist op, and drives executePinLeg through
+ * reconcileAndPersistStatusPin). This lets a test INSPECT THE FILE across
+ * steady-state edits (F1).
  */
 function makePersistingPinHarness(path: string) {
   const { fs } = memFs()
-  const claims = new Map<string, PinState>()
+  const claims = new Map<string, StatusPinClaim>()
   const pinCalls: number[] = []
   const unpinCalls: number[] = []
   const api: PinBotApi = {
@@ -166,22 +184,16 @@ function makePersistingPinHarness(path: string) {
     },
   }
   async function reconcile(key: string, chatId: string, desired: DesiredPin): Promise<void> {
-    const prev = claims.get(key) ?? null
-    const action = decidePinAction(prev, desired)
-    const op = action.kind === 'pin'
-      ? ({ kind: 'pin', messageId: action.messageId } as const)
-      : ({ kind: 'clear' } as const)
-    const next = await reconcileAndPersistStatusPin({
-      path,
-      fs,
+    const claim = claims.get(key)
+    await runStatusPinReconcile({
       pinKey: key,
       chatId,
-      op,
-      applyPin: () => reconcilePin({ api, chatId, prevState: prev, desired }),
-      log: () => {},
+      prev: claim == null ? null : { messageId: claim.messageId },
+      desired,
+      persist: { path, fs },
+      runPin: (action, from) => executePinLeg({ api, chatId, prevState: from, action }),
+      claims,
     })
-    if (next == null) claims.delete(key)
-    else claims.set(key, next)
   }
   const reconcilePinFn = (args: {
     feedKey: string
@@ -226,7 +238,7 @@ describe('worker-feed pin persistence — durable status-pins.json survives stea
     expect(pin.rows()).toHaveLength(1)
     const pinKey = pin.rows()[0].pinKey
     expect(pinKey).toMatch(/^wk:group:/)
-    expect(pin.rows()).toEqual([
+    expect(idOnly(pin.rows())).toEqual([
       { pinKey, chatId: 'chat', messageId: msgId },
     ])
 
@@ -241,7 +253,7 @@ describe('worker-feed pin persistence — durable status-pins.json survives stea
 
     // The durable row is STILL on disk (inspect the file), and no extra pin/
     // unpin API call was issued across all those steady-state edits.
-    expect(pin.rows()).toEqual([
+    expect(idOnly(pin.rows())).toEqual([
       { pinKey, chatId: 'chat', messageId: msgId },
     ])
     expect(pin.pinCalls).toEqual([msgId]) // exactly one pin, ever
@@ -269,7 +281,7 @@ describe('worker-feed pin persistence — steady-state re-pin (invisible-worker-
     expect(bot.sent).toHaveLength(1)
     const msgId = bot.sent[0].messageId
     expect(pin.pinCalls).toEqual([msgId])
-    expect(pin.state.get(pin.key())?.messageId).toBe(msgId)
+    expect(pin.claims.get(pin.key())?.messageId).toBe(msgId)
 
     // Steady-state edit while the pin is already correct → NO new pin (no storm).
     clock = 2000
@@ -284,7 +296,7 @@ describe('worker-feed pin persistence — steady-state re-pin (invisible-worker-
     await feed.update('w1', 'chat', view({ elapsedMs: 3000, toolCount: 9 }))
     await flush()
     expect(pin.pinCalls).toEqual([msgId, msgId]) // re-pinned the SAME live message
-    expect(pin.state.get(pin.key())?.messageId).toBe(msgId)
+    expect(pin.claims.get(pin.key())?.messageId).toBe(msgId)
   })
 })
 
@@ -306,27 +318,12 @@ describe('worker-feed pin persistence — unpin clears the claim', () => {
     await flush()
     const msgId = bot.sent[0].messageId
     const key = pin.key()
-    expect(pin.state.get(key)?.messageId).toBe(msgId)
+    expect(pin.claims.get(key)?.messageId).toBe(msgId)
 
     // Route an unpin of the worker message through the reconciler (the sanctioned
     // path): the claim is dropped AND the Telegram unpin is issued.
-    await (async () => {
-      const prev = pin.state.get(key) ?? null
-      const next = await reconcilePin({
-        api: {
-          pinChatMessage: async () => {},
-          unpinChatMessage: async (_c, id) => {
-            pin.unpinCalls.push(id)
-          },
-        },
-        chatId: 'chat',
-        prevState: prev,
-        desired: { pinned: false },
-      })
-      if (next == null) pin.state.delete(key)
-      else pin.state.set(key, next)
-    })()
-    expect(pin.state.has(key)).toBe(false) // claim cleared
+    await pin.reconcile(key, 'chat', { pinned: false })
+    expect(pin.claims.has(key)).toBe(false) // claim cleared
     expect(pin.unpinCalls).toContain(msgId)
 
     // A later steady edit now re-pins (the claim being clear is what lets
@@ -335,7 +332,7 @@ describe('worker-feed pin persistence — unpin clears the claim', () => {
     await feed.update('w1', 'chat', view({ elapsedMs: 2000, toolCount: 7 }))
     await flush()
     expect(pin.pinCalls).toContain(msgId)
-    expect(pin.state.get(key)?.messageId).toBe(msgId)
+    expect(pin.claims.get(key)?.messageId).toBe(msgId)
   })
 })
 
@@ -378,7 +375,7 @@ describe('worker-feed pin persistence — group-message lifetime cap rotation',
     // re-established on the new id (deterministic, no burst: one unpin + one pin).
     expect(pin.unpinCalls).toContain(msgA)
     expect(pin.pinCalls).toContain(msgB)
-    expect(pin.state.get(pin.key())?.messageId).toBe(msgB)
+    expect(pin.claims.get(pin.key())?.messageId).toBe(msgB)
 
     // FIX 1: the retired message was collapsed to the honest "moved" note with
     // exactly ONE edit (not left frozen showing live rows, not re-edited per tick).