switchroom 0.18.30 → 0.18.32

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

@@ -754,6 +754,48 @@ describe('renderCombinedWorkerFeed (pure)', () => {
     expect(combinedHistoryDepth(6)).toBe(1)
     expect(combinedHistoryDepth(8)).toBe(1)
   })
+
+  // ── Worker numbering (#3298): stable ordinal prefix at 2+ workers ──────────
+  const rowN = (i: number, ordinal: number) => ({ ...row(i, `step ${i}`), ordinal })
+
+  it('numbers the workers with a literal "N. " prefix inside the bold header when 2+ run', () => {
+    const body = renderCombinedWorkerFeed([rowN(1, 1), rowN(2, 2)], { maxRows: 8 })!
+    // The literal `1. ` must survive markdown rendering, inside the bold span
+    // before the escaped description.
+    expect(body).toContain('**1. task number 1**')
+    expect(body).toContain('**2. task number 2**')
+  })
+
+  it('renders non-contiguous ordinals as-is (survivors keep their numbers after a finish)', () => {
+    // Worker 1 finished upstream — the surviving rows arrive with their
+    // ORIGINAL ordinals. Positional numbering would render 1./2. here; the
+    // stable scheme must render 2./3. and never a `1. `.
+    const body = renderCombinedWorkerFeed([rowN(2, 2), rowN(3, 3)], { maxRows: 8 })!
+    expect(body).toContain('**2. task number 2**')
+    expect(body).toContain('**3. task number 3**')
+    expect(body).not.toContain('**1. ')
+  })
+
+  it('a single row is never numbered, even when it carries an ordinal', () => {
+    const body = renderCombinedWorkerFeed([rowN(1, 1)], { maxRows: 8 })!
+    expect(body).toContain('**task number 1**')
+    expect(body).not.toContain('**1. ')
+  })
+
+  it('rows without ordinals render unnumbered (back-compat for direct callers)', () => {
+    const body = renderCombinedWorkerFeed([row(1, 'alpha'), row(2, 'beta')], { maxRows: 8 })!
+    expect(body).toContain('**task number 1**')
+    expect(body).toContain('**task number 2**')
+    expect(body).not.toContain('1. task')
+  })
+
+  it('spilled rows take their ordinals with them; visible ordinals do not shift', () => {
+    const rows = Array.from({ length: 10 }, (_, i) => rowN(i + 1, i + 1))
+    const body = renderCombinedWorkerFeed(rows, { maxRows: 4 })!
+    expect(body).toContain('+6 more working')
+    for (let n = 1; n <= 4; n++) expect(body).toContain(`**${n}. task number ${n}**`)
+    expect(body).not.toContain('**5. ')
+  })
 })
 
 /**
@@ -1019,3 +1061,87 @@ describe('worker-feed ghost-leak — deterministic terminal removal + backstop',
     expect(edits.length).toBe(afterPaint)
   })
 })
+
+describe('worker numbering — stable per-card ordinals end to end (#3298)', () => {
+  const doneView = (desc: string, elapsedMs: number): WorkerActivityView => ({
+    description: desc,
+    lastTool: null,
+    toolCount: 3,
+    latestSummary: `${desc} result`,
+    elapsedMs,
+    state: 'done',
+  })
+  const lastBody = (h: { sends: { text: string }[]; edits: { messageId: number; text: string }[] }): string => {
+    if (h.edits.length > 0) return h.edits[h.edits.length - 1].text
+    return h.sends[h.sends.length - 1].text
+  }
+
+  it('assigns 1./2./3. at dispatch and survivors KEEP their numbers when an earlier worker finishes', async () => {
+    let clock = 1000
+    const h = ghostHarness({ now: () => clock })
+    await h.feed.update('a', 'chat', view('task alpha', 'a-doing', 0))
+    await h.feed.update('b', 'chat', view('task beta', 'b-doing', 0))
+    await h.feed.update('c', 'chat', view('task gamma', 'c-doing', 0))
+    await drain()
+
+    let body = lastBody(h)
+    expect(body).toContain('**1. task alpha**')
+    expect(body).toContain('**2. task beta**')
+    expect(body).toContain('**3. task gamma**')
+
+    // Worker 1 finishes: the survivors must STILL be 2. and 3. — positional
+    // numbering would renumber them 1./2. and this assertion would fail.
+    clock = 2000
+    await h.feed.finish('a', doneView('task alpha', 1000))
+    await drain()
+    body = lastBody(h)
+    expect(body).toContain('2 running')
+    expect(body).toContain('**2. task beta**')
+    expect(body).toContain('**3. task gamma**')
+    expect(body).not.toContain('**1. ')
+  })
+
+  it('a single running worker is never numbered (single-worker layout)', async () => {
+    const h = ghostHarness({ now: () => 1000 })
+    await h.feed.update('solo', 'chat', view('task solo', 'working', 0))
+    await drain()
+    const body = lastBody(h)
+    expect(body).toContain('task solo')
+    expect(body).not.toContain('1. task solo')
+  })
+
+  it('a fresh card after ALL workers finish numbers from 1 again', async () => {
+    let clock = 1000
+    const h = ghostHarness({ now: () => clock })
+    await h.feed.update('a', 'chat', view('task alpha', 'a-doing', 0))
+    await h.feed.update('b', 'chat', view('task beta', 'b-doing', 0))
+    await drain()
+    clock = 2000
+    await h.feed.finish('a', doneView('task alpha', 1000))
+    await h.feed.finish('b', doneView('task beta', 1000))
+    await drain()
+    expect(h.feed.size).toBe(0)
+
+    // New fan-out in the same chat → a NEW card that starts at 1., not 3.
+    clock = 3000
+    await h.feed.update('c', 'chat', view('task gamma', 'c-doing', 0))
+    await h.feed.update('d', 'chat', view('task delta', 'd-doing', 0))
+    await drain()
+    const body = lastBody(h)
+    expect(body).toContain('**1. task gamma**')
+    expect(body).toContain('**2. task delta**')
+  })
+
+  it('introducing ordinals causes no dedup churn (same substance → edit still skipped)', async () => {
+    const h = ghostHarness({ now: () => 1000 })
+    await h.feed.update('a', 'chat', view('task alpha', 'same step', 0))
+    await h.feed.update('b', 'chat', view('task beta', 'same step', 0))
+    await drain()
+    const landed = h.edits.length
+    // Byte-identical substance re-update: the dedup/no-op skip must still fire
+    // (a stable ordinal never varies the substance between identical renders).
+    await h.feed.update('a', 'chat', view('task alpha', 'same step', 0))
+    await drain()
+    expect(h.edits.length).toBe(landed)
+  })
+})

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

@@ -646,6 +646,15 @@ export interface CombinedWorkerRow {
   /** Running total tokens for this worker — rendered as `· {N} tok` on the row
    *  header. Omitted (0/undefined) → no token segment. */
   totalTokens?: number
+  /**
+   * Stable per-card ordinal (1-based), assigned when the worker joins its feed
+   * group and KEPT for the card's lifetime — survivors keep their numbers when
+   * an earlier worker finishes (the card may show `2.`/`3.` with no `1.`; the
+   * `N running` chrome carries the count). Rendered as a `{ordinal}. ` prefix
+   * inside the bold header when the card has 2+ rows. Omitted → unnumbered
+   * (back-compat for direct callers).
+   */
+  ordinal?: number
 }
 
 export interface CombinedWorkerFeedOpts {
@@ -687,13 +696,19 @@ export function combinedHistoryDepth(w: number): number {
  * markdown; callers send verbatim — do NOT re-escape). Layout:
  *
  *   🛠 **Workers** · _N running_
- *   **{desc1}** _· {elapsed} · {n} tools_
+ *   **1. {desc1}** _· {elapsed} · {n} tools_
  *   ~~_✓ {earlier step}_~~
  *   **→ {newest step}**
- *   **{desc2}** _· {elapsed} · {n} tools_
+ *   **2. {desc2}** _· {elapsed} · {n} tools_
  *   **→ {newest step}**
  *   _+M more working…_
  *
+ * NUMBERING (#3298): when the card tracks 2+ rows AND a row carries `ordinal`,
+ * its header gets a stable `{ordinal}. ` prefix. Ordinals are assigned by the
+ * caller at dispatch and kept for the card's life — after an earlier worker
+ * finishes the survivors keep their numbers (`2.`, `3.` with no `1.`). A lone
+ * row, or rows without ordinals, render unnumbered.
+ *
  * ADAPTIVE DENSITY: each visible worker renders its last-K narrative lines as a
  * `✓`/`→` trail (prior steps struck, newest bold in-progress) — the single-
  * worker card's idiom — where K = `combinedHistoryDepth(visibleCount)` splits a
@@ -716,6 +731,11 @@ export function renderCombinedWorkerFeed(
   if (rows.length === 0) return null
   const maxRows = Math.max(1, Math.floor(opts.maxRows))
 
+  // Number the workers only when the CARD tracks 2+ (a lone worker stays
+  // unnumbered). Uses the total row count, not the visible count, so ordinals
+  // don't appear/vanish as the overflow backstop shrinks the visible set.
+  const numbered = rows.length >= 2
+
   const rowHeader = (r: CombinedWorkerRow): string => {
     const desc = escapeMarkdown(
       truncate(stripMarkdown(r.description).replace(/\s+/g, ' ').trim() || 'background task', COMBINED_ROW_DESC_MAX),
@@ -724,7 +744,11 @@ export function renderCombinedWorkerFeed(
     const tokPart = tokenSegment(r.totalTokens)
     const modelLabel = formatModelLabel(r.model)
     const modelPart = modelLabel != null ? ` · ${escapeMarkdown(modelLabel)}` : ''
-    return `**${desc}** _· ${formatFeedElapsed(r.elapsedMs)} · ${r.toolCount} ${toolWord}${tokPart}${modelPart}_`
+    // Stable ordinal prefix INSIDE the bold span, before the already-escaped
+    // description — no new escaping surface, and the gateway md→HTML conversion
+    // has no ordered-list auto-formatting on bolded text.
+    const num = numbered && r.ordinal != null ? `${r.ordinal}. ` : ''
+    return `**${num}${desc}** _· ${formatFeedElapsed(r.elapsedMs)} · ${r.toolCount} ${toolWord}${tokPart}${modelPart}_`
   }
 
   // Raw (unescaped) history for a worker, oldest→newest, empty lines stripped.

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

@@ -471,6 +471,14 @@ interface WorkerRow {
    * once past STEP_TIMER_MIN_MS.
    */
   stepStartedAtMs: number | null
+  /**
+   * Stable 1-based ordinal within the group's CURRENT card, assigned from the
+   * group's monotonic counter when the row is first registered and IMMUTABLE
+   * thereafter. The combined feed renders it as a `{n}. ` header prefix when
+   * 2+ workers are running; survivors keep their numbers when an earlier
+   * worker finishes (never renumbered positionally — #3298).
+   */
+  ordinal: number
 }
 
 /**
@@ -511,6 +519,14 @@ interface FeedGroup {
   chain: Promise<void>
   /** Live workers in this group, keyed by agentId (insertion ≈ dispatch order). */
   workers: Map<string, WorkerRow>
+  /**
+   * Monotonic per-card worker counter — `++counter` hands each newly
+   * registered row its stable {@link WorkerRow.ordinal}. Reset to 0 whenever a
+   * fresh card starts (group creation, and registration into an emptied group
+   * — which covers the group-reuse-after-terminal repaint, since finalize
+   * drops rows from `workers` immediately), so every new card numbers from 1.
+   */
+  workerOrdinalCounter: number
   /**
    * Terminal renders (per finishing worker's recap) staged because a 429
    * cooldown / flood window blocked the edit. Keyed by agentId so a SECOND
@@ -844,6 +860,9 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
       const currentStep = r.narrative.length > 0 ? r.narrative[r.narrative.length - 1] : v.latestSummary
       return {
         description: v.description,
+        // Stable per-card ordinal — assigned at registration, kept for the
+        // card's life (survivors don't renumber when an earlier worker ends).
+        ordinal: r.ordinal,
         elapsedMs: elapsedFor(r),
         toolCount: v.toolCount,
         totalTokens: v.totalTokens,
@@ -1488,6 +1507,7 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
           cooldownUntil: 0,
           chain: Promise.resolve(),
           workers: new Map(),
+          workerOrdinalCounter: 0,
           pendingFinalize: new Map(),
           terminalPainted: false,
         }
@@ -1512,8 +1532,12 @@ export function createWorkerActivityFeed(opts: WorkerActivityFeedOpts): WorkerAc
       }
       let row = g.workers.get(agentId)
       if (row == null) {
+        // A registration into an EMPTIED group starts a fresh card — number
+        // from 1 again rather than continuing the dead card's sequence.
+        if (g.workers.size === 0) g.workerOrdinalCounter = 0
         row = {
           agentId,
+          ordinal: ++g.workerOrdinalCounter,
           narrative: [],
           lastView: null,
           state: 'running',

package/telegram-plugin/gateway/busy-key-reaper.ts

@@ -1,113 +0,0 @@
-/**
- * #2787 Mechanism B — the `claudeBusyKeys` orphan-reaper lifecycle, extracted
- * so the gateway glue that mutates the busy-key set stays in lockstep with its
- * shadow insertion-timestamp map and is unit-testable WITHOUT importing
- * `gateway.ts` (which boots the bot + IPC listener on module load and so cannot
- * run inside a unit test). The gateway keeps ownership of the two containers
- * (`claudeBusyKeys: Set`, `claudeBusyKeySince: Map`) and calls these helpers at
- * every mark / reap site; `disconnect-flush.ts` clears them at bridge death.
- * The test harness (`tests/busy-key-reaper.test.ts`) wires the SAME containers,
- * the SAME delivery queue, and the real `flushOnAgentDisconnect` to reproduce
- * the disconnect → reconnect → re-mark and slow-vs-orphan delivery sequences.
- *
- * Two invariants this module enforces:
- *
- *  1. LOCKSTEP. The timestamp map shadows actual SET MEMBERSHIP, not its own
- *     prior presence. `markBusyKeyLockstep` stamps a fresh timestamp whenever a
- *     key transitions idle→busy (`claudeBusyKeys.has(key) === false`). Gating on
- *     the set — not on `since.has` — is load-bearing: a disconnect flush clears
- *     `claudeBusyKeys` directly, so if the shadow map ever lagged, a `!since.has`
- *     guard would decline to re-stamp on the reconnect→re-mark and leave a
- *     stale, >TTL-old timestamp on a freshly-marked key — which the reaper would
- *     then reap out from under a live delivery.
- *
- *  2. SLOW-DELIVERY SAFETY (the #1922 hazard). `busy` is marked EAGERLY at
- *     delivery, and the gateway→claude enqueue-ack lag can be up to ~5 MINUTES
- *     under load (#1922). During that eager-mark→enqueue window the gateway's
- *     `currentTurn` is null yet the turn is real-and-merely-slow. A bare
- *     time-grace reaper cannot tell "slow" from "orphaned" and would reap a
- *     genuine delivery, re-opening the idle-drain gate while claude is about to
- *     process the very inbound whose key it just reaped (duplicate / concurrent
- *     delivery on the CORE inbound path). So the reap is PROOF-GATED: a key is
- *     reaped ONLY when it has NO entry in the delivery-confirm queue. A
- *     slow-but-real inbound is tracked there from delivery until claude's
- *     `enqueue` ack (via the never-drop re-deliver loop), so any key still
- *     awaiting its turn is present and skipped — no matter how slow. The time
- *     grace is retained as defense-in-depth, defaulting well above the observed
- *     ack-lag tail. Only a busy-marked key with NO pending delivery AND age past
- *     the grace is a true orphan (its turn acked and should have cleared busy at
- *     turn_end, or it was a steer/interrupt inbound excluded from tracking that
- *     amends a now-absent turn) — reaping those can never clobber a slow one.
- */
-
-/** Lockstep mark: add to the busy set and, on the idle→busy transition only,
- *  stamp the insertion time. Keyed on set membership so a re-mark after a
- *  disconnect flush (which cleared the set directly) always re-stamps fresh. */
-export function markBusyKeyLockstep(
-  keys: Set<string>,
-  since: Map<string, number>,
-  key: string,
-  now: number,
-): void {
-  const wasBusy = keys.has(key)
-  keys.add(key)
-  if (!wasBusy) since.set(key, now)
-}
-
-/** Lockstep clear: delete from both containers. */
-export function clearBusyKeyLockstep(
-  keys: Set<string>,
-  since: Map<string, number>,
-  key: string,
-): void {
-  keys.delete(key)
-  since.delete(key)
-}
-
-export interface ReapOptions {
-  /** Grace before a busy-marked key with no pending delivery is a true orphan. */
-  ttlMs: number
-  /** True iff a delivery-confirm entry is still tracked for this key — i.e. a
-   *  slow-but-real inbound awaiting its enqueue ack. Such keys are NEVER reaped,
-   *  regardless of age (the #1922 slow-delivery guarantee). */
-  hasPendingDelivery: (key: string) => boolean
-  /** Optional line logger for each reaped key (observability). */
-  log?: (msg: string) => void
-}
-
-/**
- * Reap orphaned busy markers. Call ONLY once the gateway has asserted no turn is
- * in flight (`currentTurn == null`). Returns the keys reaped (for the caller's
- * metrics / assertions). Also prunes shadow-map entries whose key already left
- * the set, so the map can't grow unbounded.
- */
-export function reapOrphanBusyKeys(
-  keys: Set<string>,
-  since: Map<string, number>,
-  now: number,
-  opts: ReapOptions,
-): string[] {
-  const reaped: string[] = []
-  for (const key of [...since.keys()]) {
-    if (!keys.has(key)) {
-      since.delete(key)
-      continue
-    }
-    // Proof gate: a key with a pending delivery is a slow-but-real inbound still
-    // awaiting its enqueue ack (the never-drop re-deliver loop owns it) — NEVER
-    // an orphan, regardless of age. Skip so a multi-minute (#1922) delivery
-    // can't be reaped out from under claude.
-    if (opts.hasPendingDelivery(key)) continue
-    const stampedAt = since.get(key) ?? now
-    if (now - stampedAt >= opts.ttlMs) {
-      keys.delete(key)
-      since.delete(key)
-      reaped.push(key)
-      opts.log?.(
-        `telegram gateway: reaped orphan busy key=${key} (no turn in flight, ` +
-          `no pending delivery, >${opts.ttlMs}ms) — unwedging idle-drain`,
-      )
-    }
-  }
-  return reaped
-}

package/telegram-plugin/gateway/gate-parity-probe.ts

@@ -1,102 +0,0 @@
-/**
- * Gate-parity drift probe — scaffolding for the inbound-delivery
- * state-machine cutover (#2794, RFC PR3b→PR4).
- *
- * ## Why this exists
- *
- * The inbound-delivery pipeline is mid-migration and TRIPLE-maintained:
- *
- *   1. the pure state machine (`inbound-delivery-machine.ts`) — the model,
- *   2. the shadow (`inbound-delivery-machine-shadow.ts`) — module-scope
- *      machine state advanced by `shadowEmit`, now AUTHORITATIVE for the
- *      turn-in-flight gate via `isMachineInTurn()`,
- *   3. the legacy imperative `claudeBusyKeys` set — still fully maintained
- *      in parallel and read as the kill-switch fallback.
- *
- * Per #2794 the standing risk is DRIFT: because the same turn-lifecycle
- * fact ("is a turn in flight?") is tracked in two live places, a fix in
- * one can silently diverge from the other. The machine is authoritative
- * today, but `claudeBusyKeys` is still wired and still read on the
- * kill-switch path — so the two MUST NOT drift in the dangerous direction.
- *
- * ## What "agree" means (and the ONE intended divergence)
- *
- * The machine and `claudeBusyKeys` are designed to agree on every
- * WELL-FORMED schedule (every turnStart has a matching turnEnd). They are
- * deliberately allowed to diverge in exactly ONE direction on a MALFORMED
- * schedule — an orphaned turnStart (turn B opens before turn A's turnEnd
- * ever lands, the gymbro/clerk 5-min dangle of 2026-05-28):
- *
- *   - `busykeys_dangle`  — machine reads idle (self-healed via TTL tick or
- *                          single-activeTurn reopen) while `claudeBusyKeys`
- *                          still holds an orphan key. This is EXPECTED and
- *                          GOOD: it is precisely the wedge the machine was
- *                          made authoritative to kill. Not a drift alarm.
- *
- *   - `machine_over_holds` — machine reads in-flight while `claudeBusyKeys`
- *                            is empty. This is the DANGEROUS direction: the
- *                            now-authoritative gate would hold closed while
- *                            the imperative view says idle — a NEW wedge
- *                            class the cutover must never introduce. This
- *                            is the drift #2794 warns about; surface it.
- *
- * This module is a pure classifier plus a log-only runtime probe. It
- * performs NO I/O of its own beyond an optional injected log sink and
- * changes NO delivery behaviour — it only observes. Deleting it once the
- * `claudeBusyKeys` shadow is removed in PR4 is a no-op for behaviour.
- */
-
-export type GateParityDivergence = 'none' | 'busykeys_dangle' | 'machine_over_holds'
-
-/**
- * Classify the relationship between the machine's authoritative
- * turn-in-flight read and the legacy imperative `claudeBusyKeys` size.
- * Pure — no side effects.
- */
-export function gateParityDivergence(
-  machineInTurn: boolean,
-  busyKeysSize: number,
-): GateParityDivergence {
-  const busy = busyKeysSize > 0
-  if (machineInTurn === busy) return 'none'
-  // machine idle, busyKeys non-empty → the orphan dangle the machine heals.
-  if (!machineInTurn && busy) return 'busykeys_dangle'
-  // machine in-flight, busyKeys empty → the dangerous over-hold.
-  return 'machine_over_holds'
-}
-
-/**
- * True only for divergences that indicate a real cutover regression
- * (the machine holding a gate the imperative shadow believes is open).
- * The benign `busykeys_dangle` — the very wedge the machine fixes — is
- * NOT flagged, so this probe has zero false positives on the known-good
- * self-heal path.
- */
-export function isDangerousGateDivergence(d: GateParityDivergence): boolean {
-  return d === 'machine_over_holds'
-}
-
-/**
- * Log-only runtime drift canary. Call at the authoritative gate read.
- * Emits a single grep-friendly `gw-trace gate-drift` line ONLY on the
- * dangerous over-hold direction. Returns the machine value UNCHANGED so
- * it can wrap the gate read without altering behaviour:
- *
- *   return probeGateParity(isMachineInTurn(), claudeBusyKeys.size)
- *
- * @param log  optional sink (default stderr) — test hook.
- */
-export function probeGateParity(
-  machineInTurn: boolean,
-  busyKeysSize: number,
-  log: (line: string) => void = (line) => process.stderr.write(line),
-): boolean {
-  const d = gateParityDivergence(machineInTurn, busyKeysSize)
-  if (isDangerousGateDivergence(d)) {
-    log(
-      `gw-trace gate-drift kind=${d} machineInTurn=${machineInTurn} ` +
-        `busyKeys=${busyKeysSize} note=machine-authoritative-gate-holds-while-imperative-idle\n`,
-    )
-  }
-  return machineInTurn
-}

package/telegram-plugin/tests/busy-key-reaper.test.ts

@@ -1,192 +0,0 @@
-/**
- * #2787 Mechanism B — gateway-glue coverage for the `claudeBusyKeys` orphan
- * reaper and its lockstep shadow timestamp map.
- *
- * `gateway.ts` cannot be imported by a unit test — it boots the Telegram bot and
- * the IPC listener on module load. So this harness wires the SAME containers the
- * gateway owns (`claudeBusyKeys: Set`, `claudeBusyKeySince: Map`), the SAME
- * delivery-confirm queue used as the reaper's proof gate, and the REAL
- * `flushOnAgentDisconnect` used at bridge death — exactly as the gateway does
- * (see `markClaudeBusyForInbound`, `reapOrphanBusyKeysNow`, the delivery-confirm
- * sweep, and the `flushOnAgentDisconnect({ claudeBusyKeys, claudeBusyKeySince })`
- * call). It reproduces the two real defects the pure-helper tests could not:
- *
- *   1. Lockstep across a disconnect → reconnect → re-mark: a stale
- *      pre-disconnect timestamp must NOT survive to make a freshly-marked key
- *      look orphan-old.
- *   2. Slow-delivery safety: a merely-slow (up to ~5-min, #1922) delivery whose
- *      key is still tracked in the confirm queue must NOT be reaped even long
- *      past the grace, because `currentTurn == null` during the eager-mark→
- *      enqueue window is not proof of idle.
- */
-
-import { describe, it, expect, vi } from 'vitest'
-import {
-  markBusyKeyLockstep,
-  reapOrphanBusyKeys,
-  clearBusyKeyLockstep,
-} from '../gateway/busy-key-reaper.js'
-import { flushOnAgentDisconnect } from '../gateway/disconnect-flush.js'
-import {
-  createDeliveryQueue,
-  trackDelivery,
-  ackDelivery,
-} from '../gateway/inbound-delivery-confirm.js'
-
-const TTL = 30_000
-
-/** The gateway's `reapOrphanBusyKeysNow` glue, reproduced verbatim: no turn in
- *  flight, reap keyed on set membership + a delivery-queue proof gate. */
-function reap(
-  keys: Set<string>,
-  since: Map<string, number>,
-  q: ReturnType<typeof createDeliveryQueue>,
-  now: number,
-  ttlMs = TTL,
-): string[] {
-  return reapOrphanBusyKeys(keys, since, now, {
-    ttlMs,
-    hasPendingDelivery: (key) => q.pending.has(key),
-    log: () => {},
-  })
-}
-
-/** Minimal disconnect-flush deps carrying the two containers under test — the
- *  real bridge-death path that clears busy keys. Mirrors the gateway's call. */
-function flushDeps(claudeBusyKeys: Set<string>, claudeBusyKeySince: Map<string, number>) {
-  return {
-    agentName: 'clerk',
-    activeStatusReactions: new Map(),
-    activeReactionMsgIds: new Map(),
-    activeTurnStartedAt: new Map<string, number>(),
-    claudeBusyKeys,
-    claudeBusyKeySince,
-    activeDraftStreams: new Map(),
-    clearActiveReactions: vi.fn(),
-    disposeProgressDriver: vi.fn(),
-    stopTurnTypingLoops: vi.fn(), // #2650: required dep — turn-typing sweep on bridge death
-    log: vi.fn(),
-  }
-}
-
-describe('#2787 Mechanism B — orphan reaper (gateway glue)', () => {
-  it('does NOT reap a slow-but-real delivery still tracked in the confirm queue, even far past the grace', () => {
-    const keys = new Set<string>()
-    const since = new Map<string, number>()
-    const q = createDeliveryQueue<{ text: string }>()
-
-    // Eager mark at delivery + track for ack (the normal user-inbound glue).
-    markBusyKeyLockstep(keys, since, '-100:4', 0)
-    trackDelivery(q, '-100:4', { text: 'slow but real' }, 0, '9001')
-
-    // currentTurn is still null 6 MINUTES later (the #1922 tail) — but the
-    // delivery is still pending its enqueue ack. The proof gate must protect it.
-    expect(reap(keys, since, q, 360_000)).toEqual([])
-    expect(keys.has('-100:4')).toBe(true)
-
-    // Once claude finally acks (enqueue lands), the queue entry clears; the
-    // gateway would then hold currentTurn and clear busy at turn_end.
-    expect(ackDelivery(q, '-100:4', '9001')).toBe(true)
-  })
-
-  it('reaps a TRUE orphan — busy-marked, no pending delivery, past the grace', () => {
-    const keys = new Set<string>()
-    const since = new Map<string, number>()
-    const q = createDeliveryQueue()
-
-    // A steer/interrupt inbound marks busy but is excluded from tracking
-    // (shouldTrackDelivery=false) — no queue entry. Its turn vanished without
-    // clearing busy: a genuine stuck marker.
-    markBusyKeyLockstep(keys, since, '555:_', 0)
-    expect(reap(keys, since, q, TTL)).toEqual(['555:_'])
-    expect(keys.has('555:_')).toBe(false)
-    expect(since.has('555:_')).toBe(false)
-  })
-
-  it('does not reap before the grace elapses', () => {
-    const keys = new Set<string>()
-    const since = new Map<string, number>()
-    const q = createDeliveryQueue()
-    markBusyKeyLockstep(keys, since, '555:_', 0)
-    expect(reap(keys, since, q, TTL - 1)).toEqual([])
-    expect(keys.has('555:_')).toBe(true)
-  })
-
-  it('disconnect → reconnect → re-mark: fresh timestamp, key NOT reaped as stale (the lockstep fix)', () => {
-    const keys = new Set<string>()
-    const since = new Map<string, number>()
-    const q = createDeliveryQueue()
-
-    // t=0 first mark.
-    markBusyKeyLockstep(keys, since, '-100:4', 0)
-
-    // Bridge dies at t=1000 — the REAL disconnect flush clears BOTH containers
-    // in lockstep (belt-and-suspenders to the set-membership guard).
-    flushOnAgentDisconnect(flushDeps(keys, since))
-    expect(keys.size).toBe(0)
-    expect(since.size).toBe(0)
-
-    // Reconnect and re-mark the SAME key at t=300_000 (well after the old stamp).
-    markBusyKeyLockstep(keys, since, '-100:4', 300_000)
-
-    // Pre-fix (stale t=0 stamp surviving the disconnect + a `!since.has` guard
-    // declining to re-stamp) the age would read 300_000ms ≫ grace and the key
-    // would be reaped THE INSTANT it was re-marked — re-opening the idle-drain
-    // while claude is about to process this very inbound. With the fix the stamp
-    // is fresh (t=300_000), so at t just past the re-mark it is NOT reaped.
-    expect(reap(keys, since, q, 305_000)).toEqual([]) // age 5s < 30s grace
-    expect(keys.has('-100:4')).toBe(true)
-
-    // ...and it DOES reap once the fresh grace genuinely elapses.
-    expect(reap(keys, since, q, 300_000 + TTL)).toEqual(['-100:4'])
-  })
-
-  it('disconnect while a delivery is pending: reconnect re-mark stays protected by the proof gate', () => {
-    const keys = new Set<string>()
-    const since = new Map<string, number>()
-    const q = createDeliveryQueue<{ text: string }>()
-
-    markBusyKeyLockstep(keys, since, '-100:4', 0)
-    trackDelivery(q, '-100:4', { text: 'inflight' }, 0, '42')
-
-    // Bridge flap: disconnect clears busy state; the offline buffer / re-deliver
-    // loop still owns the inbound. Reconnect re-marks + re-tracks it.
-    flushOnAgentDisconnect(flushDeps(keys, since))
-    markBusyKeyLockstep(keys, since, '-100:4', 5_000)
-    trackDelivery(q, '-100:4', { text: 'inflight' }, 5_000, '42')
-
-    // Even minutes later, still pending its ack → never reaped.
-    expect(reap(keys, since, q, 5_000 + 400_000)).toEqual([])
-    expect(keys.has('-100:4')).toBe(true)
-  })
-
-  it('prunes shadow-map entries whose key already left the set (no unbounded growth)', () => {
-    const keys = new Set<string>()
-    const since = new Map<string, number>()
-    const q = createDeliveryQueue()
-    // Simulate a direct clear that (hypothetically) left the map behind.
-    since.set('ghost:_', 0)
-    reap(keys, since, q, 999_999)
-    expect(since.has('ghost:_')).toBe(false)
-  })
-
-  it('re-mark of an already-busy key does NOT reset its timestamp (measures the true dangle)', () => {
-    const keys = new Set<string>()
-    const since = new Map<string, number>()
-    const q = createDeliveryQueue()
-    markBusyKeyLockstep(keys, since, 'k:_', 0)
-    markBusyKeyLockstep(keys, since, 'k:_', 20_000) // still busy → no re-stamp
-    expect(since.get('k:_')).toBe(0)
-    // Orphaned (no pending delivery) → reaps on the ORIGINAL stamp's grace.
-    expect(reap(keys, since, q, TTL)).toEqual(['k:_'])
-  })
-
-  it('clearBusyKeyLockstep removes from both containers', () => {
-    const keys = new Set<string>()
-    const since = new Map<string, number>()
-    markBusyKeyLockstep(keys, since, 'k:_', 0)
-    clearBusyKeyLockstep(keys, since, 'k:_')
-    expect(keys.has('k:_')).toBe(false)
-    expect(since.has('k:_')).toBe(false)
-  })
-})