switchroom 0.20.5 → 0.20.6

package/dist/cli/switchroom.js

@@ -2120,7 +2120,7 @@ var init_esm = __esm(() => {
 });
 
 // src/build-info.ts
-var VERSION = "0.20.5", COMMIT_SHA = "fc40cc8e";
+var VERSION = "0.20.6", COMMIT_SHA = "4b1ad9b1";
 
 // src/cli/resolve-version.ts
 import { existsSync, readFileSync } from "node:fs";

package/dist/host-control/main.js

@@ -21432,7 +21432,7 @@ function allocateAgentUid(name) {
 }
 
 // src/build-info.ts
-var VERSION = "0.20.5";
+var VERSION = "0.20.6";
 
 // src/setup/hindsight-recall-tunables.ts
 var RECALL_DEADLINE_HEADROOM_SECONDS = 2;

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "switchroom",
   "//version": "NOT the release version — source of truth is the git tag, resolved by scripts/build.mjs:resolveVersion() (see CLAUDE.md > Standard release process). This field is stale by design and only the Layer-4 dev/non-tag fallback for build.mjs + src/cli/resolve-version.ts; do NOT bump it expecting a release to pick it up. npm-pack tarball naming needs a real version — do that as an UNCOMMITTED pack-time bump (see release step 6), never a committed one.",
-  "version": "0.20.5",
+  "version": "0.20.6",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/telegram-plugin/dist/gateway/gateway.js

@@ -89491,6 +89491,7 @@ async function runBootPinSweepSteps(deps) {
   await step("status-pin-cleanup", deps.statusPinCleanup, log);
   await step("activity-card-reaper", deps.activityCardReaper, log);
   await step("queued-card-reaper", deps.queuedCardReaper, log);
+  await step("seed-prune-sweep-cursors", async () => deps.seedPruneSweepCursors(), log);
   await step("enable-sweep", async () => deps.enableSweep(), log);
   for (const t of targets) {
     await step(`stale-pin-sweep:${sweepTargetKey(t.chatId, t.threadId)}`, () => deps.sweepTarget(t), log);
@@ -90303,6 +90304,56 @@ function createGatewayStalePinSweeper(w) {
   });
 }
 
+// gateway/stale-pin-sweep-store.ts
+var SWEEP_ENVELOPE_VERSION2 = 1;
+function isCursorRow2(x) {
+  if (x == null || typeof x !== "object")
+    return false;
+  const o = x;
+  return typeof o.chatId === "string" && o.chatId.length > 0 && (o.threadId === undefined || typeof o.threadId === "number") && (o.kind === "dm" || o.kind === "forum-topic" || o.kind === "supergroup") && typeof o.popped === "number" && typeof o.done === "boolean" && typeof o.attempts === "number" && (o.doneIds === undefined || Array.isArray(o.doneIds) && o.doneIds.every((n) => typeof n === "number")) && (o.lastStatus === undefined || typeof o.lastStatus === "string") && typeof o.updatedAt === "number";
+}
+function loadSweepCursors2(path2, fs2) {
+  if (!fs2.existsSync(path2))
+    return [];
+  let raw = "";
+  try {
+    raw = fs2.readFileSync(path2);
+  } catch {
+    return [];
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return [];
+  }
+  if (parsed == null || typeof parsed !== "object")
+    return [];
+  const env = parsed;
+  if (!Number.isInteger(env.v) || env.v < 1 || !Array.isArray(env.cursors)) {
+    return [];
+  }
+  return env.cursors.filter(isCursorRow2);
+}
+function persistSweepCursors2(path2, fs2, cursors, log = (l) => process.stderr.write(l)) {
+  const env = { v: SWEEP_ENVELOPE_VERSION2, cursors: [...cursors] };
+  try {
+    fs2.writeFileSync(path2, JSON.stringify(env));
+  } catch (err) {
+    log(`stale-pin-sweep-store: persist FAILED path=${path2}: ${err.message} \u2014 ` + `durability degraded; a restart mid-sweep will re-seed instead of resume
+`);
+  }
+}
+function pruneSweepCursors(cursors) {
+  return cursors.filter((c) => !c.done);
+}
+function reseedSweepLedger(path2, fs2, log = (l) => process.stderr.write(l)) {
+  const rows = loadSweepCursors2(path2, fs2);
+  const pruned = pruneSweepCursors(rows);
+  if (pruned.length !== rows.length)
+    persistSweepCursors2(path2, fs2, pruned, log);
+}
+
 // gateway/webhook-ingest-server.ts
 import net4 from "node:net";
 import { chmodSync as chmodSync10, existsSync as existsSync39, unlinkSync as unlinkSync18 } from "node:fs";
@@ -102428,10 +102479,10 @@ function startOutboxSweep(deps) {
 }
 
 // ../src/build-info.ts
-var VERSION2 = "0.20.5";
-var COMMIT_SHA = "fc40cc8e";
-var COMMIT_DATE = "2026-08-04T04:03:52Z";
-var LATEST_PR = 4338;
+var VERSION2 = "0.20.6";
+var COMMIT_SHA = "4b1ad9b1";
+var COMMIT_DATE = "2026-08-04T07:34:19Z";
+var LATEST_PR = 4340;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -108140,19 +108191,17 @@ async function unpinAllStatusPins() {
 }
 var stalePinSweepEligible = false;
 var STALE_PIN_SWEEP_STORE_PATH = join71(STATE_DIR, "stale-pin-sweep.json");
+var sweepStoreFs = {
+  readFileSync: (p) => readFileSync64(p, "utf-8"),
+  writeFileSync: (p, data) => atomicWriteFileSync(p, data, 384),
+  existsSync: (p) => existsSync61(p)
+};
 var stalePinSweeper = createGatewayStalePinSweeper({
   telegram: { handle: () => lockedBot, call: robustApiCall },
   claims: () => statusPinClaims.values(),
   loadPinRows: () => statusPinPersistEnabled || bannerPinPersistEnabled || toolPinPersistEnabled ? loadStatusPins2(STATUS_PIN_STORE_PATH, statusPinStoreFs) : [],
   eligible: () => stalePinSweepEligible,
-  store: {
-    path: STALE_PIN_SWEEP_STORE_PATH,
-    fs: {
-      readFileSync: (p) => readFileSync64(p, "utf-8"),
-      writeFileSync: (p, data) => atomicWriteFileSync(p, data, 384),
-      existsSync: (p) => existsSync61(p)
-    }
-  },
+  store: { path: STALE_PIN_SWEEP_STORE_PATH, fs: sweepStoreFs },
   allowUnpinAllForumTopic: process.env.SWITCHROOM_PIN_SWEEP_UNPIN_ALL_TOPIC == null ? undefined : process.env.SWITCHROOM_PIN_SWEEP_UNPIN_ALL_TOPIC === "1"
 });
 function runBootPinCleanupAndStalePinSweep() {
@@ -108168,6 +108217,7 @@ function runBootPinCleanupAndStalePinSweep() {
     enableSweep: () => {
       stalePinSweepEligible = true;
     },
+    seedPruneSweepCursors: () => reseedSweepLedger(STALE_PIN_SWEEP_STORE_PATH, sweepStoreFs),
     sweepTarget: (t) => stalePinSweeper.sweepTarget(t),
     log: (line) => process.stderr.write(line)
   });

package/telegram-plugin/gateway/boot-sweep-gate.ts

@@ -103,6 +103,21 @@ export interface BootPinSweepSteps {
   /** Flips the flag authorising the stale-pin drain — for this sweep AND for
    *  later lazy first-inbound sweeps. */
   enableSweep: () => void
+  /**
+   * BOOT-SEED PRUNE (#3953 regression fix). Drops discharged (`done: true`)
+   * cursor rows from the sweep ledger so a `(chat, thread)` that drained in a
+   * PRIOR session is re-evaluated live this boot, instead of short-circuiting
+   * forever on a stale `done`. Kind-agnostic — clears DM, forum-topic and
+   * supergroup rows alike. Forfeited rows (`attempts >= SWEEP_MAX_ATTEMPTS`)
+   * are RETAINED by the underlying `pruneSweepCursors`, so a chat the bot
+   * cannot pin does not re-burn its attempt budget every boot.
+   *
+   * MUST stay BOOT-scoped. The lazy first-inbound sweep fires on EVERY message;
+   * pruning there would re-arm a full re-drain per message = a Telegram flood.
+   * Runs once here, before the `sweepTarget` loop, so the loop re-evaluates the
+   * freshly-reseeded ledger.
+   */
+  seedPruneSweepCursors: () => void
   sweepTarget: (target: SweepTarget) => Promise<unknown>
   log?: (line: string) => void
 }
@@ -161,6 +176,15 @@ export async function runBootPinSweepSteps(deps: BootPinSweepSteps): Promise<voi
   await step('activity-card-reaper', deps.activityCardReaper, log)
   await step('queued-card-reaper', deps.queuedCardReaper, log)
 
+  // Boot-seed prune (#3953): reseed the cursor ledger so a chat that drained in
+  // a prior session is re-evaluated live below, rather than short-circuiting on
+  // a stale `done`. Boot-scoped ONLY — never on the per-inbound path. Runs
+  // BEFORE enableSweep so eligibility (which also gates the lazy first-inbound
+  // sweep) is granted only once the ledger is reseeded — no window where an
+  // inbound observes a stale `done`. Isolated: a throw here must not strand the
+  // drain, and enableSweep below still runs regardless.
+  await step('seed-prune-sweep-cursors', async () => deps.seedPruneSweepCursors(), log)
+
   // Unconditional: reached even when every step above threw. See the docblock.
   await step('enable-sweep', async () => deps.enableSweep(), log)
   for (const t of targets) {

package/telegram-plugin/gateway/gateway.ts

@@ -648,6 +648,7 @@ import { withDeadline } from './with-deadline.js'
 import { createStatusPinApi, type PinCapableBot, type RobustApiSeam } from './status-pin-api.js'
 import { collectSweepTargets, type StalePinSweeper, type SweepTarget } from './stale-pin-sweep.js'
 import { createGatewayStalePinSweeper } from './stale-pin-sweep-wiring.js'
+import { reseedSweepLedger } from './stale-pin-sweep-store.js'
 import { atomicWriteFileSync } from '../../src/util/atomic.js'
 import { startWebhookIngestServer } from './webhook-ingest-server.js'
 import { recordWebhookEvent } from '../../src/web/webhook-gateway-record.js'
@@ -9041,6 +9042,11 @@ let stalePinSweepEligible = false
 // the previous complete ledger or the new one — never a truncated file that
 // forgets an in-flight drain.
 const STALE_PIN_SWEEP_STORE_PATH = join(STATE_DIR, 'stale-pin-sweep.json')
+const sweepStoreFs = {
+  readFileSync: (p: string) => readFileSync(p, 'utf-8'),
+  writeFileSync: (p: string, data: string) => atomicWriteFileSync(p, data, 0o600),
+  existsSync: (p: string) => existsSync(p),
+}
 const stalePinSweeper: StalePinSweeper = createGatewayStalePinSweeper({
   telegram: { handle: () => lockedBot, call: robustApiCall },
   claims: () => statusPinClaims.values(),
@@ -9049,14 +9055,7 @@ const stalePinSweeper: StalePinSweeper = createGatewayStalePinSweeper({
       ? loadStatusPins(STATUS_PIN_STORE_PATH, statusPinStoreFs)
       : [],
   eligible: () => stalePinSweepEligible,
-  store: {
-    path: STALE_PIN_SWEEP_STORE_PATH,
-    fs: {
-      readFileSync: (p) => readFileSync(p, 'utf-8'),
-      writeFileSync: (p, data) => atomicWriteFileSync(p, data, 0o600),
-      existsSync: (p) => existsSync(p),
-    },
-  },
+  store: { path: STALE_PIN_SWEEP_STORE_PATH, fs: sweepStoreFs },
   // Per-deployment override only. UNSET (the normal case) means "take the
   // standing policy" — UNPIN_ALL_FORUM_TOPIC_ENABLED in stale-pin-sweep.ts,
   // i.e. the WHOLESALE topic drain stays off because it also removes pins this
@@ -9099,6 +9098,7 @@ function runBootPinCleanupAndStalePinSweep(): Promise<void> {
     enableSweep: () => {
       stalePinSweepEligible = true
     },
+    seedPruneSweepCursors: () => reseedSweepLedger(STALE_PIN_SWEEP_STORE_PATH, sweepStoreFs),
     sweepTarget: (t: SweepTarget) => stalePinSweeper.sweepTarget(t),
     log: (line) => process.stderr.write(line),
   })

package/telegram-plugin/gateway/stale-pin-sweep-store.ts

@@ -221,7 +221,44 @@ export function pendingSweepCursors(cursors: readonly SweepCursor[]): SweepCurso
   return cursors.filter((c) => !c.done && c.attempts < SWEEP_MAX_ATTEMPTS)
 }
 
-/** Drop discharged and forfeited rows — called once the ledger is reseeded. */
+/**
+ * Boot seed pass: drop DISCHARGED (`done: true`) rows ONLY, so a chat that
+ * drained in a prior session is re-evaluated LIVE on the next sweep instead of
+ * short-circuiting forever on a stale `done` (#3953 regression — the seed pass
+ * was never wired, so `done` was effectively permanent).
+ *
+ * FORFEITED rows (`attempts >= SWEEP_MAX_ATTEMPTS`, still `!done`) are
+ * deliberately RETAINED. Their whole purpose is to remember that a chat's
+ * attempt budget is spent (bot kicked, pin rights revoked, a chat that
+ * flood-waits forever). Pruning one would let the next boot re-seed it from the
+ * pin stores and re-burn the full 8-attempt budget on every boot for the rest
+ * of time — precisely the Telegram flood the attempt cap exists to prevent. So
+ * this filters on `done` ALONE; it must NOT also gate on `attempts`.
+ */
 export function pruneSweepCursors(cursors: readonly SweepCursor[]): SweepCursor[] {
-  return cursors.filter((c) => !c.done && c.attempts < SWEEP_MAX_ATTEMPTS)
+  return cursors.filter((c) => !c.done)
+}
+
+/**
+ * BOOT-SEED reseed of the durable ledger (#3953): drop discharged (`done:true`)
+ * rows so a `(chat, thread)` that drained in a prior session is re-evaluated
+ * LIVE on the next sweep instead of short-circuiting forever on a stale `done`.
+ * Forfeited rows are retained (see {@link pruneSweepCursors}).
+ *
+ * Writes ONLY when the prune changed the ledger, so a no-op boot never churns
+ * the durable file. Never throws — a reseed failure degrades to the pre-fix
+ * behaviour (the stale `done` survives one more boot), it must not break boot.
+ *
+ * BOOT-SCOPED BY CONTRACT: the caller must invoke this once at boot, never on
+ * the per-inbound path (which fires on every message — re-arming a full re-drain
+ * per message is a Telegram flood).
+ */
+export function reseedSweepLedger(
+  path: string,
+  fs: SweepStoreFsSeam,
+  log: (line: string) => void = (l) => process.stderr.write(l),
+): void {
+  const rows = loadSweepCursors(path, fs)
+  const pruned = pruneSweepCursors(rows)
+  if (pruned.length !== rows.length) persistSweepCursors(path, fs, pruned, log)
 }

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

@@ -32,6 +32,8 @@ import {
 import {
   SWEEP_MAX_ATTEMPTS,
   loadSweepCursors,
+  pruneSweepCursors,
+  reseedSweepLedger,
   upsertSweepCursor,
   type SweepCursor,
   type SweepStoreFsSeam,
@@ -907,3 +909,163 @@ describe('stale-pin sweep — classification and seeding', () => {
     expect(isNothingToUnpinError(new Error('something else'))).toBe(false)
   })
 })
+
+// ─── #3953: the boot-seed prune reseeds a discharged obligation ───────────────
+//
+// Regression #3953 replaced the per-boot DM self-heal with a cursor-gated stack
+// drain, but the boot "seed pass" that clears discharged cursors was never
+// wired — so `done:true` was effectively PERMANENT and every later boot /
+// first-inbound sweep short-circuited on `already-drained`, orphaning any pin
+// that leaked AFTER the first drain. These tests pin the reseed contract:
+//   1. `pruneSweepCursors` drops `done` rows ONLY and RETAINS forfeited
+//      (attempts-exhausted) rows — a store-level test that FAILS on the pre-fix
+//      filter (which also dropped forfeited rows, re-burning the attempt budget
+//      every boot = flood risk).
+//   2. Running that prune between two fresh-process sweeps re-arms the drain, so
+//      a pin leaked after a prior discharge is reaped — for a DM AND a
+//      supergroup (channel-class) target alike.
+
+/** The boot-seed reseed exactly as the gateway wires it (`gateway.ts`
+ *  `seedPruneSweepCursors` → `reseedSweepLedger`). */
+function bootSeedPrune(fs: SweepStoreFsSeam, path: string): void {
+  reseedSweepLedger(path, fs, () => {})
+}
+
+/** A sweeper over a SHARED durable store — a distinct instance models a fresh
+ *  process (reboot), so the only state carried across is the on-disk ledger. */
+function sweeperOver(
+  fs: SweepStoreFsSeam,
+  path: string,
+  fake: ReturnType<typeof fakeChat>,
+  opts: { recordedPinIds?: number[] } = {},
+) {
+  let clock = 1_000_000
+  const deps: StalePinSweepDeps = {
+    getTopPinnedMessageId: fake.getTopPinnedMessageId,
+    pinSilent: fake.pinSilent,
+    unpin: fake.unpin,
+    unpinAllForumTopicMessages: fake.unpinAllForumTopicMessages,
+    canPinInChat: fake.canPinInChat,
+    protectedMessageIds: () => [],
+    recordedPinIds: () => opts.recordedPinIds ?? [],
+    eligible: () => true,
+    sleep: async (ms) => {
+      clock += ms
+    },
+    now: () => clock,
+    store: { path, fs },
+    log: () => {},
+  }
+  return createStalePinSweeper(deps)
+}
+
+describe('pruneSweepCursors — boot-seed reseed (#3953)', () => {
+  const now = 1_000_000
+
+  it('drops discharged rows but RETAINS forfeited (attempts-exhausted) rows', () => {
+    const discharged: SweepCursor = {
+      chatId: DM,
+      kind: 'dm',
+      popped: 3,
+      done: true,
+      attempts: 1,
+      updatedAt: now,
+    }
+    // A no-rights group that spent its whole attempt budget: `done` is false,
+    // but re-seeding it would re-burn all 8 attempts on the NEXT boot, and every
+    // boot after — the exact Telegram flood the attempt cap exists to stop.
+    const forfeited: SweepCursor = {
+      chatId: GROUP,
+      kind: 'supergroup',
+      popped: 0,
+      done: false,
+      attempts: SWEEP_MAX_ATTEMPTS,
+      lastStatus: 'skipped-no-rights',
+      updatedAt: now,
+    }
+    const stillOwed: SweepCursor = {
+      chatId: '900000002',
+      kind: 'dm',
+      popped: 0,
+      done: false,
+      attempts: 2,
+      updatedAt: now,
+    }
+
+    const keys = pruneSweepCursors([discharged, forfeited, stillOwed]).map((c) => c.chatId)
+
+    expect(keys).not.toContain(DM) // discharged → reseeded (dropped)
+    expect(keys).toContain(GROUP) // forfeited no-rights → RETAINED (no re-burn)
+    expect(keys).toContain('900000002') // still owed → retained untouched
+  })
+
+  it('clears discharged rows for EVERY surface — dm, forum-topic, supergroup', () => {
+    // The prune must be kind-agnostic: a stuck `done` on a topic or a channel is
+    // the same regression as on a DM, so none may be left short-circuiting.
+    const rows: SweepCursor[] = [
+      { chatId: '1', kind: 'dm', popped: 1, done: true, attempts: 1, updatedAt: now },
+      { chatId: '2', kind: 'forum-topic', threadId: 5, popped: 1, done: true, attempts: 1, updatedAt: now },
+      { chatId: '3', kind: 'supergroup', popped: 1, done: true, attempts: 1, updatedAt: now },
+    ]
+    expect(pruneSweepCursors(rows)).toEqual([])
+  })
+})
+
+describe('stale-pin sweep — re-drain after the boot-seed prune (#3953)', () => {
+  it('re-drains a DM whose obligation was discharged in a prior session', async () => {
+    const fs = memFs()
+    const path = '/state/stale-pin-sweep.json'
+
+    // Session 1: an orphan bot pin is drained and the obligation discharged.
+    const s1 = await sweeperOver(fs, path, fakeChat({ stack: [11] })).sweepTarget({ chatId: DM })
+    expect(s1.status).toBe('drained')
+    expect(loadSweepCursors(path, fs).find((c) => c.chatId === DM)?.done).toBe(true)
+
+    // A NEW orphan pin leaks in after that drain.
+    // Fresh process, no prune: the sweep short-circuits on the stale `done` —
+    // the #3953 regression, verbatim. The orphan is left pinned.
+    const stuckChat = fakeChat({ stack: [99] })
+    const stuck = await sweeperOver(fs, path, stuckChat).sweepTarget({ chatId: DM })
+    expect(stuck.status).toBe('already-drained')
+    expect(stuck.popped).toBe(0)
+    expect(stuckChat.stack).toEqual([99])
+
+    // Reboot WITH the boot-seed prune: the discharged row is reseeded, so the
+    // next sweep re-evaluates the chat LIVE and reaps the orphan.
+    bootSeedPrune(fs, path)
+    const rebootChat = fakeChat({ stack: [99] })
+    const redrain = await sweeperOver(fs, path, rebootChat).sweepTarget({ chatId: DM })
+    expect(redrain.status).toBe('drained')
+    expect(redrain.popped).toBe(1)
+    expect(rebootChat.stack).toEqual([])
+  })
+
+  it('re-drains a supergroup (channel-class) discharged in a prior session', async () => {
+    const fs = memFs()
+    const path = '/state/stale-pin-sweep.json'
+
+    // Session 1: the one recorded orphan is reaped, obligation discharged.
+    const s1 = await sweeperOver(fs, path, fakeChat({ stack: [77], canPin: true }), {
+      recordedPinIds: [77],
+    }).sweepTarget({ chatId: GROUP })
+    expect(s1.status).toBe('drained')
+    expect(loadSweepCursors(path, fs).find((c) => c.chatId === GROUP)?.done).toBe(true)
+
+    // A fresh recorded orphan leaks in; a fresh process short-circuits on `done`.
+    const stuckChat = fakeChat({ stack: [88], canPin: true })
+    const stuck = await sweeperOver(fs, path, stuckChat, { recordedPinIds: [88] }).sweepTarget({
+      chatId: GROUP,
+    })
+    expect(stuck.status).toBe('already-drained')
+    expect(stuckChat.stack).toEqual([88])
+
+    // Reboot + prune: the supergroup row is reseeded and re-swept.
+    bootSeedPrune(fs, path)
+    const rebootChat = fakeChat({ stack: [88], canPin: true })
+    const redrain = await sweeperOver(fs, path, rebootChat, { recordedPinIds: [88] }).sweepTarget({
+      chatId: GROUP,
+    })
+    expect(redrain.status).toBe('drained')
+    expect(rebootChat.stack).toEqual([])
+  })
+})

package/telegram-plugin/tests/boot-sweep-gate.test.ts

@@ -161,6 +161,7 @@ describe('runBootPinSweepSteps (#3664 salvage S2)', () => {
         order.push('queued-cards')
       },
       enableSweep: () => order.push('enable-sweep'),
+      seedPruneSweepCursors: () => order.push('seed-prune'),
       sweepTarget: async (t) => {
         order.push(`sweep:${t.chatId}:${t.threadId ?? '-'}`)
       },
@@ -177,6 +178,7 @@ describe('runBootPinSweepSteps (#3664 salvage S2)', () => {
       'status-pins',
       'activity-cards',
       'queued-cards',
+      'seed-prune',
       'enable-sweep',
       'sweep:900000001:-',
     ])
@@ -194,6 +196,7 @@ describe('runBootPinSweepSteps (#3664 salvage S2)', () => {
       'scan',
       'status-pins',
       'queued-cards',
+      'seed-prune',
       'enable-sweep',
       'sweep:900000001:-',
     ])
@@ -210,7 +213,7 @@ describe('runBootPinSweepSteps (#3664 salvage S2)', () => {
       queuedCardReaper: boom,
     })
     await runBootPinSweepSteps(d.deps)
-    expect(d.order).toEqual(['scan', 'enable-sweep', 'sweep:900000001:-'])
+    expect(d.order).toEqual(['scan', 'seed-prune', 'enable-sweep', 'sweep:900000001:-'])
   })
 
   it('a failing store scan still lets the reapers and the DM enable run', async () => {
@@ -221,7 +224,13 @@ describe('runBootPinSweepSteps (#3664 salvage S2)', () => {
     })
     await runBootPinSweepSteps(d.deps)
     // No targets to sweep, but nothing behind the scan is stranded.
-    expect(d.order).toEqual(['status-pins', 'activity-cards', 'queued-cards', 'enable-sweep'])
+    expect(d.order).toEqual([
+      'status-pins',
+      'activity-cards',
+      'queued-cards',
+      'seed-prune',
+      'enable-sweep',
+    ])
     expect(d.logs.join('')).toContain("step 'sweep-target-scan' failed: ENOENT")
   })
 
@@ -272,6 +281,7 @@ describe('runBootPinSweepSteps (#3664 salvage S2)', () => {
           order.push('queued-cards')
         },
         enableSweep: () => order.push('enable-sweep'),
+        seedPruneSweepCursors: () => {},
         sweepTarget: async () => {},
         log: () => {
           throw new Error('EPIPE')
@@ -296,6 +306,9 @@ describe('runBootPinSweepSteps (#3664 salvage S2)', () => {
         enableSweep: () => {
           throw new Error('boom')
         },
+        seedPruneSweepCursors: () => {
+          throw new Error('boom')
+        },
         sweepTarget: boom,
         log: () => {},
       }),