switchroom 0.19.25 → 0.19.27

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

@@ -2,8 +2,59 @@ import { describe, it, expect } from 'vitest'
 import { GrammyError } from 'grammy'
 import { decidePinAction, isPinRightsError, isUnpinTerminalError, PinRightsCache } from '../status-pin.js'
 import { makeFloodWaitActiveError, GIVE_UP_MESSAGE } from '../retry-api-call.js'
-import { reconcilePin, type PinBotApi } from '../status-pin-driver.js'
-import type { PinState } from '../status-pin.js'
+import { executePinLeg, type PinBotApi } from '../status-pin-driver.js'
+import type { DesiredPin, PinState, PinRightsCache as _RightsCache } from '../status-pin.js'
+import {
+  runStatusPinReconcile,
+  type StatusPinClaim,
+} from '../gateway/status-pin-retarget.js'
+
+/**
+ * Drive a whole desired-state reconcile through the REAL unified path — the
+ * orchestrator (`runStatusPinReconcile`, which owns the single retarget
+ * expansion) composed with the driver (`executePinLeg`), exactly as gateway.ts
+ * wires them. `persist: null` mirrors the STATIC / feature-off binding.
+ *
+ * These cases used to call `reconcilePin(prev, desired)` directly, back when the
+ * driver re-decided the action itself and carried its OWN copy of the retarget
+ * expansion (#3831). The driver can no longer express a retarget, so exercising
+ * the same behaviours now means exercising the composition — which is what
+ * production actually runs.
+ */
+async function reconcilePin(args: {
+  api: PinBotApi
+  chatId: string
+  prevState: PinState | null
+  desired: DesiredPin
+  rightsCache?: _RightsCache
+  onError?: (phase: 'pin' | 'unpin', err: unknown) => void
+  onPinRightsDisabled?: (chatId: string) => void
+}): Promise<PinState | null> {
+  const claims = new Map<string, StatusPinClaim>()
+  if (args.prevState != null) {
+    claims.set('k', { messageId: args.prevState.messageId, chatId: args.chatId, pinnedAt: 1 })
+  }
+  await runStatusPinReconcile({
+    pinKey: 'k',
+    chatId: args.chatId,
+    prev: args.prevState,
+    desired: args.desired,
+    persist: null,
+    runPin: (action, from) =>
+      executePinLeg({
+        api: args.api,
+        chatId: args.chatId,
+        prevState: from,
+        action,
+        rightsCache: args.rightsCache,
+        onError: args.onError,
+        onPinRightsDisabled: args.onPinRightsDisabled,
+      }),
+    claims,
+  })
+  const claim = claims.get('k')
+  return claim == null ? null : { messageId: claim.messageId }
+}
 
 /** A real GrammyError with the given code + description, mirroring the wire
  *  shape Telegram returns for the pin-rights failure that crashed marko. */
@@ -37,9 +88,14 @@ describe('decidePinAction (pure)', () => {
     expect(action.kind).toBe('noop')
   })
 
-  it('unpins the stale claim when the wanted message id changed (feed re-posted)', () => {
+  it('RETARGETS (unpin old + pin new) when the wanted message id changed (surface re-posted)', () => {
+    // Regression: this used to report a bare `unpin`, on the assumption that a
+    // later reconcile would pin the new message. Single-shot callers (the
+    // foreground activity card, which reconciles only when a card OPENs) have
+    // no later reconcile, so the new card was left unpinned for the rest of
+    // the turn. The decision must carry BOTH message ids.
     const action = decidePinAction({ messageId: 42 }, { pinned: true, messageId: 99 })
-    expect(action).toEqual({ kind: 'unpin', messageId: 42 })
+    expect(action).toEqual({ kind: 'repin', unpinMessageId: 42, pinMessageId: 99 })
   })
 })
 
@@ -59,7 +115,7 @@ function fakeApi(opts: { pinThrows?: boolean; unpinThrows?: boolean } = {}) {
   return { api, calls }
 }
 
-describe('reconcilePin (driver)', () => {
+describe('unified reconcile path (orchestrator + driver)', () => {
   it('pin on in-progress: pins the EXISTING message SILENTLY and claims it', async () => {
     const { api, calls } = fakeApi()
     const next = await reconcilePin({
@@ -177,6 +233,127 @@ describe('reconcilePin (driver)', () => {
     expect(attempts).toBe(2)
   })
 
+  // ── Retarget (`repin`) — the single-shot-caller leak ──────────────────────
+  // The foreground activity card reconciles its `fg:` pin EXACTLY ONCE, when a
+  // card OPENs (narrative-lane.ts; the edit branch never touches the pin). When
+  // the ack-first reopen path (feed-reopen-gate.ts) nulls `activityMessageId`
+  // and a FRESH card opens mid-turn, that single reconcile must leave the NEW
+  // card pinned. Previously it emitted only an unpin and the turn ran on with
+  // nothing pinned.
+  it('RETARGET: one reconcile unpins the stale message AND pins the new one', async () => {
+    const { api, calls } = fakeApi()
+    const next = await reconcilePin({
+      api,
+      chatId: '123',
+      prevState: { messageId: 42 },
+      desired: { pinned: true, messageId: 99 },
+    })
+    expect(next).toEqual({ messageId: 99 })
+    expect(calls.map((c) => [c.verb, c.messageId])).toEqual([
+      ['unpin', 42],
+      ['pin', 99],
+    ])
+    // The new pin must still be silent.
+    expect((calls[1].opts as Record<string, unknown>).disable_notification).toBe(true)
+  })
+
+  it('RETARGET: a TERMINAL unpin failure still pins the new message', async () => {
+    // "message to unpin not found" means the old surface is already gone — the
+    // retarget must complete, not abort.
+    const calls: { verb: string; messageId: number }[] = []
+    const next = await reconcilePin({
+      api: {
+        pinChatMessage: async (_c, message_id) => {
+          calls.push({ verb: 'pin', messageId: message_id })
+        },
+        unpinChatMessage: async (_c, message_id) => {
+          calls.push({ verb: 'unpin', messageId: message_id })
+          throw grammyError(400, 'Bad Request: message to unpin not found')
+        },
+      },
+      chatId: '123',
+      prevState: { messageId: 42 },
+      desired: { pinned: true, messageId: 99 },
+    })
+    expect(next).toEqual({ messageId: 99 })
+    expect(calls).toEqual([
+      { verb: 'unpin', messageId: 42 },
+      { verb: 'pin', messageId: 99 },
+    ])
+  })
+
+  it('RETARGET: a NEVER-CONFIRMED unpin retains the OLD claim and does NOT pin the new one', async () => {
+    // The old message is provably still pinned (#3664 Defect B). Pinning the
+    // new one now would leave two pins in the chat with a durable record of
+    // only one — the exact orphan class the retain rule exists to prevent.
+    const calls: { verb: string; messageId: number }[] = []
+    const next = await reconcilePin({
+      api: {
+        pinChatMessage: async (_c, message_id) => {
+          calls.push({ verb: 'pin', messageId: message_id })
+        },
+        unpinChatMessage: async (_c, message_id) => {
+          calls.push({ verb: 'unpin', messageId: message_id })
+          throw makeFloodWaitActiveError(300, Date.now() + 300_000, null)
+        },
+      },
+      chatId: '123',
+      prevState: { messageId: 42 },
+      desired: { pinned: true, messageId: 99 },
+    })
+    expect(next).toEqual({ messageId: 42 })
+    expect(calls).toEqual([{ verb: 'unpin', messageId: 42 }])
+  })
+
+  it('RETARGET: a failed pin leg drops the claim (nothing is pinned, nothing is tracked)', async () => {
+    const calls: { verb: string; messageId: number }[] = []
+    const next = await reconcilePin({
+      api: {
+        pinChatMessage: async (_c, message_id) => {
+          calls.push({ verb: 'pin', messageId: message_id })
+          throw new Error('fetch failed')
+        },
+        unpinChatMessage: async (_c, message_id) => {
+          calls.push({ verb: 'unpin', messageId: message_id })
+        },
+      },
+      chatId: '123',
+      prevState: { messageId: 42 },
+      desired: { pinned: true, messageId: 99 },
+    })
+    // prevState for the pin leg is null (the unpin landed), so a failed pin
+    // returns null — no phantom claim on a message we never pinned.
+    expect(next).toBeNull()
+    expect(calls).toEqual([
+      { verb: 'unpin', messageId: 42 },
+      { verb: 'pin', messageId: 99 },
+    ])
+  })
+
+  it('RETARGET: a pin-rights-blocked chat makes NO API calls and drops the claim', async () => {
+    const calls: string[] = []
+    const cache = new PinRightsCache()
+    cache.block('123')
+    const next = await reconcilePin({
+      api: {
+        pinChatMessage: async () => {
+          calls.push('pin')
+        },
+        unpinChatMessage: async () => {
+          calls.push('unpin')
+        },
+      },
+      chatId: '123',
+      prevState: { messageId: 42 },
+      desired: { pinned: true, messageId: 99 },
+      rightsCache: cache,
+    })
+    expect(calls).toEqual([])
+    // unpin leg returns null (claim dropped, nothing worth tracking); the pin
+    // leg is skipped from a null prev and returns null too.
+    expect(next).toBeNull()
+  })
+
   it('does NOT claim a message whose pin failed (retries next reconcile)', async () => {
     const errors: string[] = []
     const { api } = fakeApi({ pinThrows: true })
@@ -207,7 +384,7 @@ describe('reconcilePin (driver)', () => {
 // the whole gateway down. Auto status-pin is best-effort/cosmetic — a
 // pin-rights failure must be absorbed, never fatal, and never reach the
 // process-level unhandledRejection handler.
-describe('reconcilePin — pin-rights 400 must never crash (marko 2026-07-01)', () => {
+describe('unified reconcile path — pin-rights 400 must never crash (marko 2026-07-01)', () => {
   it('absorbs the "not enough rights" 400 via onError and never rejects', async () => {
     const rightsErr = grammyError(
       400,
@@ -342,7 +519,7 @@ function countingApi(pinError?: unknown) {
   }
 }
 
-describe('reconcilePin — rights-aware negative cache (#3024)', () => {
+describe('unified reconcile path — rights-aware negative cache (#3024)', () => {
   const rightsErr = () =>
     grammyError(400, 'Bad Request: not enough rights to manage pinned messages in the chat')
 

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

@@ -661,7 +661,7 @@ describe('renderCombinedWorkerFeed (pure)', () => {
 
   it('renders one row-block per worker with a running count header', () => {
     const body = renderCombinedWorkerFeed([row(1, 'alpha step'), row(2, 'beta step')], { maxRows: 8 })!
-    expect(body).toContain('Workers')
+    expect(body).toContain('WORKERS')
     expect(body).toContain('2 running')
     expect(body).toContain('task number 1')
     expect(body).toContain('task number 2')
@@ -756,7 +756,7 @@ describe('renderCombinedWorkerFeed (pure)', () => {
       .map((l) => l.trim())
       .filter((l) => l.length > 0)
     const headerAndHistory = bodyLines.filter(
-      (l) => !l.startsWith('🛠') && !l.includes('more working'),
+      (l) => !l.includes('**WORKERS**') && !l.includes('more working'),
     )
     expect(headerAndHistory.length).toBeLessThanOrEqual(24)
   })
@@ -775,7 +775,7 @@ describe('renderCombinedWorkerFeed (pure)', () => {
       .map((l) => l.trim())
       .filter((l) => l.length > 0)
     const headerAndHistory = bodyLines.filter(
-      (l) => !l.startsWith('🛠') && !l.includes('more working'),
+      (l) => !l.includes('**WORKERS**') && !l.includes('more working'),
     )
     expect(headerAndHistory.length).toBeLessThanOrEqual(24)
     expect(body).toContain('+2 more working')
@@ -1287,14 +1287,21 @@ 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.
+    // #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(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 at the left margin so the nesting reads as nesting.
-    for (const l of headerLines) expect(l.startsWith(BLANK)).toBe(false)
+    // Workers stay one level ABOVE their steps so the nesting reads as nesting.
+    for (const l of headerLines) {
+      expect(l.startsWith(WORKER_STEP_INDENT)).toBe(false)
+    }
     expect(lines[0].startsWith('🛠')).toBe(true)
   })
 
@@ -1306,6 +1313,7 @@ describe('combined worker card — steps indent under their worker (U+2800)', ()
     // 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 = 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
@@ -1314,14 +1322,14 @@ 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([
-      `🛠 **Workers** · _3 running · oldest 3m00s · 9 tools_${S}`,
-      `**1. worker task 1** _· 1m00s · 3 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}`,
-      `**2. worker task 2** _· 2m00s · 3 tools_${S}`,
+      `${N}**2. worker task 2** _· 2m00s · 3 tools_${S}`,
       `${I}~~_✓ w2 step a_~~${S}`,
       `${I}**→ w2 step b**${S}`,
-      `**3. worker task 3** _· 3m00s · 3 tools_${S}`,
+      `${N}**3. worker task 3** _· 3m00s · 3 tools_${S}`,
       `${I}~~_✓ w3 step a_~~${S}`,
       `${I}**→ w3 step b**`, // last line: nothing follows it to collide with
     ])
@@ -1442,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 is untouched (no indent on its step lines)', () => {
+  it('the SINGLE-worker 🛠 card is entirely FLUSH — no card indent, no step indent (#3842)', () => {
     const single = renderWorkerActivity({
       workerId: 'w1',
       description: 'lone worker',
@@ -1454,16 +1462,18 @@ describe('combined worker card — steps indent under their worker (U+2800)', ()
     })
     expect(single).toContain('~~_✓ step a_~~')
     expect(single).toContain('**→ step b**')
-    // No LEADING indent: the single-worker card has nothing to nest under, so
-    // its step lines must sit flush at the left margin. 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. A regression that
-    // leaked WORKER_STEP_INDENT onto these lines still fails here.
-    for (const l of single.split('\n')) {
-      expect(l.startsWith(BLANK)).toBe(false)
-      expect(l.startsWith(NBSP)).toBe(false)
+    // 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('🛠 **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)
     }
   })
 })