switchroom 0.18.25 → 0.18.27

package/telegram-plugin/send-gate.test.ts

@@ -137,6 +137,8 @@ describe('send-gate: SEND_GATE_DEFAULTS (compile-time default PIN)', () => {
       perGroupPerMin: 18,
       perGroupBurst: 2,
       editFloorMs: 1500,
+      perMessageEditWindowMs: 300_000,
+      perMessageEditMaxPerWindow: 150,
     })
   })
 })
@@ -157,6 +159,8 @@ describe('send-gate: sendGateConfigFromEnv (yaml → env → createSendGate)', (
         SWITCHROOM_TG_SEND_GATE_PER_GROUP_PER_MIN: '30',
         SWITCHROOM_TG_SEND_GATE_PER_GROUP_BURST: '4',
         SWITCHROOM_TG_SEND_GATE_EDIT_FLOOR_MS: '2000',
+        SWITCHROOM_TG_SEND_GATE_PER_MSG_EDIT_WINDOW_MS: '30000',
+        SWITCHROOM_TG_SEND_GATE_PER_MSG_EDIT_MAX: '8',
       }),
     )
     expect(cfg).toEqual({
@@ -168,9 +172,23 @@ describe('send-gate: sendGateConfigFromEnv (yaml → env → createSendGate)', (
       perGroupPerMin: 30,
       perGroupBurst: 4,
       editFloorMs: 2000,
+      perMessageEditWindowMs: 30000,
+      perMessageEditMaxPerWindow: 8,
     })
   })
 
+  it('per-message edit budget: MAX accepts 0 (disables the backstop); WINDOW must be positive', () => {
+    expect(
+      sendGateConfigFromEnv(E({ SWITCHROOM_TG_SEND_GATE_PER_MSG_EDIT_MAX: '0' }))
+        .perMessageEditMaxPerWindow,
+    ).toBe(0)
+    // A zero/negative window is malformed → dropped so createSendGate's default applies.
+    expect(
+      sendGateConfigFromEnv(E({ SWITCHROOM_TG_SEND_GATE_PER_MSG_EDIT_WINDOW_MS: '0' }))
+        .perMessageEditWindowMs,
+    ).toBeUndefined()
+  })
+
   it('accepts a fractional per-sec rate (rates are not integers)', () => {
     const cfg = sendGateConfigFromEnv(E({ SWITCHROOM_TG_SEND_GATE_PER_CHAT_PER_SEC: '0.5' }))
     expect(cfg.perChatPerSec).toBe(0.5)
@@ -857,3 +875,123 @@ describe('send-gate: flood windows + boot ramp (L3 / §7 hook)', () => {
     expect(c2.filter((c) => c.at === 11_000).length).toBe(10) // full burst, no ramp
   })
 })
+
+describe('send-gate: long-horizon per-message edit budget (backstop)', () => {
+  it('paces + coalesces a sustained same-message cosmetic edit stream under the rolling cap', async () => {
+    const clock = new FakeClock()
+    const { calls, fn } = recorder(clock)
+    // Tight, fast budget for a deterministic test: 2 cosmetic edits / 5s window,
+    // 1s edit floor. A distinct edit every 1s would sail through the floor
+    // forever (this is exactly the sub-1/s flood the backstop exists to stop).
+    const gate = createSendGate({
+      enabled: true,
+      clock,
+      editFloorMs: 1000,
+      perMessageEditWindowMs: 5000,
+      perMessageEditMaxPerWindow: 2,
+    })
+    const msg = 77
+    const attempts = 20
+    const promises: Promise<unknown>[] = []
+    for (let i = 0; i < attempts; i++) {
+      promises.push(
+        gate.gate(fn(`v${i}`), { messageId: msg, editPayload: `v${i}`, priorityClass: 'cosmetic' }),
+      )
+      await flush()
+      await clock.advance(1000)
+    }
+    // Drain any final budget-deferred send (a full window is enough).
+    await clock.advance(5000)
+    await flush()
+    await Promise.allSettled(promises)
+
+    const stats = gate.stats().global
+    // The sustained ~1/s stream is paced FAR below the attempt count — bounded
+    // by ~2 sends per 5s over the ~25s simulated span, not 20 one-per-second.
+    expect(stats.sent).toBeLessThan(attempts)
+    expect(stats.sent).toBeLessThanOrEqual(10)
+    // The backstop actively deferred at least one edit (not just the 1s floor).
+    expect(stats.budgetDeferred).toBeGreaterThan(0)
+    // Coalescing collapsed the deferred edits (last-write-wins), so the FINAL
+    // send carries the newest payload — no stale body is shown.
+    expect(calls[calls.length - 1].label).toBe(`v${attempts - 1}`)
+  })
+
+  it('does NOT throttle distinct message_ids — each message gets its own budget', async () => {
+    const clock = new FakeClock()
+    const { calls, fn } = recorder(clock)
+    const gate = createSendGate({
+      enabled: true,
+      clock,
+      editFloorMs: 1000,
+      perMessageEditWindowMs: 5000,
+      perMessageEditMaxPerWindow: 1,
+    })
+    // One cosmetic edit to each of two distinct messages at t=0. A per-message
+    // budget of 1 must NOT make message B's first edit wait on message A's.
+    const pA = gate.gate(fn('A'), { messageId: 1, editPayload: 'A', priorityClass: 'cosmetic' })
+    const pB = gate.gate(fn('B'), { messageId: 2, editPayload: 'B', priorityClass: 'cosmetic' })
+    await flush()
+    await Promise.all([pA, pB])
+    expect(calls.map((c) => c.label).sort()).toEqual(['A', 'B'])
+    expect(calls.every((c) => c.at === 0)).toBe(true)
+    expect(gate.stats().global.budgetDeferred).toBe(0)
+  })
+
+  it('does NOT throttle non-cosmetic (useful/untagged) edits of the same message', async () => {
+    const clock = new FakeClock()
+    const { calls, fn } = recorder(clock)
+    // Budget so tight it would allow only ONE cosmetic edit ever in the span —
+    // yet untagged edits default to `useful` and must bypass the budget entirely
+    // (only the 1s floor applies). Legitimate stream/draft edits are untouched.
+    const gate = createSendGate({
+      enabled: true,
+      clock,
+      editFloorMs: 1000,
+      perMessageEditWindowMs: 100_000,
+      perMessageEditMaxPerWindow: 1,
+    })
+    const msg = 9
+    const promises: Promise<unknown>[] = []
+    for (let i = 0; i < 5; i++) {
+      promises.push(gate.gate(fn(`u${i}`), { messageId: msg, editPayload: `u${i}` }))
+      await flush()
+      await clock.advance(1000)
+    }
+    await clock.advance(1000)
+    await flush()
+    await Promise.allSettled(promises)
+    // All five distinct useful edits landed (floor-spaced), none budget-deferred.
+    expect(gate.stats().global.sent).toBe(5)
+    expect(gate.stats().global.budgetDeferred).toBe(0)
+    expect(calls.map((c) => c.label)).toEqual(['u0', 'u1', 'u2', 'u3', 'u4'])
+  })
+
+  it('disables the backstop when perMessageEditMaxPerWindow is 0', async () => {
+    const clock = new FakeClock()
+    const { calls, fn } = recorder(clock)
+    const gate = createSendGate({
+      enabled: true,
+      clock,
+      editFloorMs: 1000,
+      perMessageEditMaxPerWindow: 0,
+    })
+    const msg = 55
+    const promises: Promise<unknown>[] = []
+    for (let i = 0; i < 6; i++) {
+      promises.push(
+        gate.gate(fn(`c${i}`), { messageId: msg, editPayload: `c${i}`, priorityClass: 'cosmetic' }),
+      )
+      await flush()
+      await clock.advance(1000)
+    }
+    await clock.advance(1000)
+    await flush()
+    await Promise.allSettled(promises)
+    // With the budget off, only the 1s floor gates: every floor-spaced distinct
+    // edit lands and nothing is budget-deferred.
+    expect(gate.stats().global.sent).toBe(6)
+    expect(gate.stats().global.budgetDeferred).toBe(0)
+    expect(calls.map((c) => c.label)).toEqual(['c0', 'c1', 'c2', 'c3', 'c4', 'c5'])
+  })
+})

package/telegram-plugin/send-gate.ts

@@ -197,6 +197,14 @@ export interface BucketCounters {
    * because the open window exceeded the fail-fast ceiling (part3-design §3).
    */
   failedFast: number
+  /**
+   * Cosmetic edits DEFERRED at least once by the long-horizon per-message edit
+   * budget (rolling-window cap). Counts driver loop iterations that slept on the
+   * budget, not distinct messages — a paced runaway stream increments this each
+   * time it waits out the window. A non-zero, climbing value means the backstop
+   * is actively pacing a sustained same-message edit stream.
+   */
+  budgetDeferred: number
 }
 
 export interface SendGateStats {
@@ -256,6 +264,35 @@ export interface SendGateConfig {
   perGroupBurst?: number
   /** Minimum ms between edits of the same message_id. Default 1500. */
   editFloorMs?: number
+  /**
+   * Long-horizon per-message edit budget (rolling window). DEFENSE-IN-DEPTH
+   * backstop for a runaway same-message edit stream (finn incident: sustained
+   * worker-card clock-only edits → ~88min 429 ban). It caps a SINGLE message to
+   * at most `perMessageEditMaxPerWindow` cosmetic edits per
+   * `perMessageEditWindowMs`; beyond that the driver DEFERS the next edit until
+   * the window slides, and newer edits coalesce (last-write-wins) onto the
+   * pending slot in the meantime — so a runaway is paced + collapsed rather than
+   * sustained.
+   *
+   * IMPORTANT — this is a coarse rate ceiling, NOT the primary fix. The gate
+   * cannot tell a SUBSTANTIVE cosmetic edit (a new worker step) from an
+   * elapsed-clock cosmetic edit; both carry a changed payload. So the primary
+   * cure for the clock-churn flood is at the source (`worker-activity-feed.ts`
+   * suppresses elapsed-only edits via a substance signature), and THIS backstop
+   * must sit ABOVE legitimate substantive cadence so it never throttles real
+   * updates. The worker feed's own min-edit interval is 2500ms (≤24 edits/min);
+   * the default here — 150 edits / 300_000ms ⟹ a 30 edits/min sustained ceiling
+   * — sits above that, so a normal (even continuously-updating) card never
+   * binds, while a stream that sustains faster than the feed's throttle for
+   * minutes (e.g. a future regression re-introducing per-tick churn, or a
+   * lowered floor) is paced back to 30/min. Scoped strictly to `cosmetic`-class
+   * edits of the SAME `${chat_id}:${messageId}` (worker-feed, typing,
+   * reactions); `useful` / `critical` edits and all non-edit sends are
+   * untouched, and distinct messages each get their own budget. Set
+   * `perMessageEditMaxPerWindow: 0` to disable the backstop.
+   */
+  perMessageEditWindowMs?: number
+  perMessageEditMaxPerWindow?: number
   /**
    * Flood windows to re-open at construction (part3-design §7). PR 2 loads
    * these from `flood-wait.json` BEFORE the first outbound call so a restart
@@ -433,6 +470,14 @@ interface MessageEditState {
   running: boolean
   /** Per-message flood suppression window (part3-design §7). */
   suppressedUntilMs: number
+  /**
+   * Send-START timestamps of recent COSMETIC edits to this message, kept within
+   * the long-horizon rolling window (`perMessageEditWindowMs`). Pruned to the
+   * window on each driver loop and appended at each send start; its length is
+   * the message's edit count over the trailing window and gates the per-message
+   * edit budget. Bounded by the budget cap; empty when the backstop is disabled.
+   */
+  editWindowTs: number[]
 }
 
 function hashPayload(payload: unknown): string {
@@ -517,6 +562,15 @@ export const SEND_GATE_DEFAULTS = {
   perGroupBurst: 2,
   /** Minimum ms between edits of the same message_id. */
   editFloorMs: 1500,
+  /** Long-horizon per-message edit budget: rolling window length (ms). */
+  perMessageEditWindowMs: 300_000,
+  /**
+   * Long-horizon per-message edit budget: max cosmetic edits per window.
+   * 150 / 300s ⟹ a 30 edits/min sustained ceiling — above the worker feed's
+   * own 24/min cadence so legitimate substantive updates never bind (see the
+   * SendGateConfig field doc).
+   */
+  perMessageEditMaxPerWindow: 150,
 } as const
 
 export function createSendGate(config: SendGateConfig): SendGate {
@@ -529,6 +583,14 @@ export function createSendGate(config: SendGateConfig): SendGate {
   const perGroupPerMin = config.perGroupPerMin ?? SEND_GATE_DEFAULTS.perGroupPerMin
   const perGroupBurst = config.perGroupBurst ?? SEND_GATE_DEFAULTS.perGroupBurst
   const editFloorMs = config.editFloorMs ?? SEND_GATE_DEFAULTS.editFloorMs
+  const perMessageEditWindowMs = Math.max(
+    1,
+    Math.floor(config.perMessageEditWindowMs ?? SEND_GATE_DEFAULTS.perMessageEditWindowMs),
+  )
+  const perMessageEditMaxPerWindow = Math.max(
+    0,
+    Math.floor(config.perMessageEditMaxPerWindow ?? SEND_GATE_DEFAULTS.perMessageEditMaxPerWindow),
+  )
   const messageStateTtlMs = config.messageStateTtlMs ?? 60_000
   const maxMessageStates = config.maxMessageStates ?? 5_000
   const usefulTtlMs = config.usefulTtlMs ?? 120_000
@@ -546,6 +608,7 @@ export function createSendGate(config: SendGateConfig): SendGate {
     shed: 0,
     expired: 0,
     failedFast: 0,
+    budgetDeferred: 0,
   }
 
   const bootStart = clock.now()
@@ -605,6 +668,7 @@ export function createSendGate(config: SendGateConfig): SendGate {
         pending: null,
         running: false,
         suppressedUntilMs: 0,
+        editWindowTs: [],
       }
       perMessage.set(key, state)
     }
@@ -902,7 +966,28 @@ export function createSendGate(config: SendGateConfig): SendGate {
     try {
       while (state.pending) {
         const now = clock.now()
-        const readyAt = Math.max(state.lastSentMs + editFloorMs, state.suppressedUntilMs)
+        let readyAt = Math.max(state.lastSentMs + editFloorMs, state.suppressedUntilMs)
+        // Long-horizon per-message edit budget (backstop). Scoped to cosmetic
+        // edits of THIS message: prune the rolling window, and if it is already
+        // full, defer until the oldest in-window send ages out. Reading the
+        // pending edit's (possibly upgraded) class here means a critical edit
+        // that coalesced onto a cosmetic driver is NOT budget-capped — it must
+        // never block unbounded (part3-design §3). Newer edits keep coalescing
+        // into `state.pending` while we sleep, so pacing preserves last-write-
+        // wins rather than sending stale bodies.
+        if (perMessageEditMaxPerWindow > 0 && state.pending.priorityClass === 'cosmetic') {
+          const windowStart = now - perMessageEditWindowMs
+          while (state.editWindowTs.length > 0 && state.editWindowTs[0] <= windowStart) {
+            state.editWindowTs.shift()
+          }
+          if (state.editWindowTs.length >= perMessageEditMaxPerWindow) {
+            const budgetReadyAt = state.editWindowTs[0] + perMessageEditWindowMs
+            if (budgetReadyAt > readyAt) {
+              readyAt = budgetReadyAt
+              counters.budgetDeferred++
+            }
+          }
+        }
         const waitMs = readyAt - now
         if (waitMs > 0) {
           // Still inside the floor / an open window — sleep, then re-read
@@ -958,6 +1043,16 @@ export function createSendGate(config: SendGateConfig): SendGate {
         // Reserve the send-start time BEFORE awaiting the network so the floor
         // is measured from send start (matches the per-message serialization).
         state.lastSentMs = clock.now()
+        // Record this send against the long-horizon budget when it is a cosmetic
+        // edit (the only class the budget gates). Recorded at send START so the
+        // rolling window measures dispatch cadence, consistent with the floor.
+        if (perMessageEditMaxPerWindow > 0 && p.priorityClass === 'cosmetic') {
+          state.editWindowTs.push(state.lastSentMs)
+          // Bound the array against pathological inputs (it is naturally ≈ the
+          // budget cap since we prune to the window each loop).
+          const overflow = state.editWindowTs.length - (perMessageEditMaxPerWindow + 1)
+          if (overflow > 0) state.editWindowTs.splice(0, overflow)
+        }
         try {
           // N3 (liveness): this awaits `p.fn()` with no watchdog. A `fn` that
           // NEVER settles would keep `state.running` true forever, making the
@@ -1222,6 +1317,8 @@ export type SendGateEnvConfig = Pick<SendGateConfig, 'enabled'> &
       | 'perGroupPerMin'
       | 'perGroupBurst'
       | 'editFloorMs'
+      | 'perMessageEditWindowMs'
+      | 'perMessageEditMaxPerWindow'
       | 'conservativeGlobalFloodScope'
     >
   >
@@ -1270,6 +1367,12 @@ export function sendGateConfigFromEnv(
   if (perGroupBurst !== undefined) out.perGroupBurst = perGroupBurst
   const editFloorMs = parseNonNegativeInt(env.SWITCHROOM_TG_SEND_GATE_EDIT_FLOOR_MS)
   if (editFloorMs !== undefined) out.editFloorMs = editFloorMs
+  // Long-horizon per-message edit budget (flood-ban backstop). Window ≥1ms is
+  // enforced in createSendGate; MAX_PER_WINDOW=0 disables the backstop.
+  const perMsgWindowMs = parsePositiveInt(env.SWITCHROOM_TG_SEND_GATE_PER_MSG_EDIT_WINDOW_MS)
+  if (perMsgWindowMs !== undefined) out.perMessageEditWindowMs = perMsgWindowMs
+  const perMsgMax = parseNonNegativeInt(env.SWITCHROOM_TG_SEND_GATE_PER_MSG_EDIT_MAX)
+  if (perMsgMax !== undefined) out.perMessageEditMaxPerWindow = perMsgMax
   // #3111 break-glass: restore the pre-#3111 always-open-global flood posture.
   // Unset ⇒ scope-precise default (global opened only on genuinely global 429s).
   const conservativeGlobal = parseBoolFlag(env.SWITCHROOM_TG_SEND_GATE_CONSERVATIVE_GLOBAL)

package/telegram-plugin/tests/activity-ever-opened-sticky.test.ts

@@ -10,8 +10,14 @@
  * resume-400 signature) from "feed opened + finalized".
  *
  * Load-bearing constraints:
- *   1. `activityEverOpened = true` is set exactly ONCE in gateway.ts (at the
- *      send-message success site in drainActivitySummary).
+ *   1. `activityEverOpened = true` is set only at legitimate feed-OPEN signal
+ *      sites in gateway.ts — the send-message success site in
+ *      drainActivitySummary, AND the sub-agent-handback pre-turn ADOPTION site
+ *      (#3268): an adopted turn inherits an already-open pre-turn card via a
+ *      seeded `activityMessageId`, so it only ever EDITs the feed (never hits
+ *      the open branch), and must stamp the flag itself so the turn-end
+ *      DEGRADED check doesn't false-flag it as "feed never opened". Both are
+ *      set-TRUE (never a reset), preserving the sticky-true invariant.
  *   2. `turn.activityEverOpened = false` NEVER appears in gateway.ts (it is only
  *      initialised to `false` in the turn-initialiser object literal, never reset
  *      via a standalone assignment).
@@ -28,9 +34,13 @@ const gatewaySrc = readFileSync(
 )
 
 describe('M-2: activityEverOpened sticky-true invariant', () => {
-  it('activityEverOpened = true appears exactly once (set at send-message success)', () => {
+  it('activityEverOpened = true appears only at the two feed-OPEN signal sites', () => {
+    // Site 1: drainActivitySummary send-message success. Site 2: the #3268
+    // handback pre-turn ADOPTION seed (an adopted turn only edits, so it stamps
+    // the flag itself). Both are set-TRUE; the sticky invariant (no reset to
+    // false) is enforced by the next test.
     const setTrueMatches = [...gatewaySrc.matchAll(/activityEverOpened\s*=\s*true/g)]
-    expect(setTrueMatches).toHaveLength(1)
+    expect(setTrueMatches).toHaveLength(2)
   })
 
   it('turn.activityEverOpened = false never appears (no standalone reset)', () => {

package/telegram-plugin/tests/effort-command.test.ts

@@ -21,6 +21,7 @@ import {
   EFFORT_CALLBACK_PREFIX,
   type EffortCommandDeps,
 } from "../gateway/effort-command.js";
+import { resolveStaleAwareBusy } from "../gateway/model-command.js";
 import type { EffortApplyResult } from "../../src/agents/effort-picker.js";
 
 function applyOk(level: string, confirmed = false): EffortApplyResult {
@@ -254,4 +255,50 @@ describe("effort-command: /effort default (#3039)", () => {
     expect(r.text).toContain("/effort default");
     expect(r.text).toContain("lasts until the agent’s next restart");
   });
+
+  // #3262 parity with /model: the gateway gates the effort apply-vs-queue on
+  // `resolveModelEffortBusy().currentTurnActive` (the turn-atom leg — /effort
+  // does not consult the delivery-machine/approval gate). These pin the SAME
+  // stale-aware decision the gateway feeds that gate: a dangling atom older than
+  // the hard TTL reads idle → APPLY; a fresh atom reads busy → QUEUE.
+  describe("phantom 'active turn' apply-vs-queue (#3262)", () => {
+    const HARD_TTL = 10 * 60_000;
+    // The gateway's effort queue predicate, reduced to the signal it reads.
+    const effortWouldQueue = (currentTurnActive: boolean): boolean => currentTurnActive;
+
+    it("APPLIES a set when the turn atom is DANGLING (older than the hard TTL)", () => {
+      const r = resolveStaleAwareBusy({
+        currentTurnActive: true,
+        turnAgeMs: HARD_TTL + 1,
+        machineInTurn: false,
+        oldestPendingApprovalAgeMs: null,
+        hardTtlMs: HARD_TTL,
+      });
+      expect(r.clearStaleTurn).toBe(true);
+      expect(effortWouldQueue(r.currentTurnActive)).toBe(false); // → applies now
+    });
+
+    it("QUEUES a set when the turn is FRESH (marker within the TTL) — no regression", () => {
+      const r = resolveStaleAwareBusy({
+        currentTurnActive: true,
+        turnAgeMs: 5_000,
+        machineInTurn: false,
+        oldestPendingApprovalAgeMs: null,
+        hardTtlMs: HARD_TTL,
+      });
+      expect(r.clearStaleTurn).toBe(false);
+      expect(effortWouldQueue(r.currentTurnActive)).toBe(true); // → queues
+    });
+
+    it("APPLIES when there is no turn atom at all", () => {
+      const r = resolveStaleAwareBusy({
+        currentTurnActive: false,
+        turnAgeMs: null,
+        machineInTurn: false,
+        oldestPendingApprovalAgeMs: null,
+        hardTtlMs: HARD_TTL,
+      });
+      expect(effortWouldQueue(r.currentTurnActive)).toBe(false);
+    });
+  });
 });

package/telegram-plugin/tests/flushed-turn-supersede.test.ts

@@ -20,6 +20,7 @@
 import { describe, it, expect } from 'vitest'
 import {
   decideSupersede,
+  decideSupersedeCorrection,
   FlushedTurnSupersedeRegistry,
   DEFAULT_SUPERSEDE_TTL_MS,
   type FlushedTurnRecord,
@@ -33,6 +34,65 @@ const rec = (over: Partial<FlushedTurnRecord> = {}): FlushedTurnRecord => ({
   ...over,
 })
 
+describe('decideSupersedeCorrection — edit-in-place vs delete+resend', () => {
+  const base = {
+    flushMessageIds: [500],
+    chunkCount: 1,
+    hasFiles: false,
+    suppressText: false,
+    hasOpenPreview: false,
+  }
+
+  it('edits in place when the flush posted ONE message and the reply fits one plain-text message', () => {
+    const c = decideSupersedeCorrection(base)
+    expect(c.mode).toBe('edit-in-place')
+    // edit target is the single flushed message; nothing is deleted (A becomes B).
+    expect(c).toMatchObject({ mode: 'edit-in-place', editMessageId: 500, deleteMessageIds: [] })
+  })
+
+  it('literal (format:text) single-message replies still edit in place (text is text)', () => {
+    // literalText is not an input to the decision — a literal reply is still a
+    // text message the edit lane renders identically.
+    const c = decideSupersedeCorrection({ ...base })
+    expect(c.mode).toBe('edit-in-place')
+  })
+
+  it('falls back to delete+resend for a MULTI-PART reply (edit can only carry one message)', () => {
+    const c = decideSupersedeCorrection({ ...base, chunkCount: 3 })
+    expect(c).toEqual({ mode: 'delete-resend', deleteMessageIds: [500] })
+  })
+
+  it('falls back to delete+resend when the flush posted MORE THAN ONE message', () => {
+    const c = decideSupersedeCorrection({ ...base, flushMessageIds: [500, 501] })
+    expect(c).toEqual({ mode: 'delete-resend', deleteMessageIds: [500, 501] })
+  })
+
+  it('falls back to delete+resend for a file/album reply (not a plain-text edit)', () => {
+    const c = decideSupersedeCorrection({ ...base, hasFiles: true })
+    expect(c.mode).toBe('delete-resend')
+  })
+
+  it('falls back to delete+resend for a voice-only reply (no text body to edit into)', () => {
+    const c = decideSupersedeCorrection({ ...base, suppressText: true })
+    expect(c.mode).toBe('delete-resend')
+  })
+
+  it('falls back to delete+resend when a draft-stream preview already owns the edit lane', () => {
+    const c = decideSupersedeCorrection({ ...base, hasOpenPreview: true })
+    expect(c.mode).toBe('delete-resend')
+  })
+
+  it('anti-duplicate invariant: every correction resolves to exactly one surviving message', () => {
+    // edit-in-place → A becomes B (1 message, 0 deletes); delete-resend → all
+    // flushed ids deleted then B sent fresh (1 message). Neither leaves A+B both
+    // visible, and neither loses the reply.
+    const editing = decideSupersedeCorrection(base)
+    expect(editing.mode === 'edit-in-place' && editing.deleteMessageIds.length).toBe(0)
+    const resending = decideSupersedeCorrection({ ...base, chunkCount: 2 })
+    expect(resending.deleteMessageIds).toEqual([500])
+  })
+})
+
 describe('decideSupersede — the duplicate-reply decision core', () => {
   it('supersedes when the reply is attributed to the SAME turn as the flush', () => {
     // The common late-replay dup: the gateway resolves the reply's turnId (from