switchroom 0.18.25 → 0.18.27

package/telegram-plugin/tests/render/inline-pairs-guard.test.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect } from "vitest";
+import { guardAccidentalInlinePairs } from "../../render/inline-pairs-guard.js";
+
+// Strip defusing backslashes so we can assert the reader-visible text is
+// byte-identical to the original prose (the backslash is consumed by Telegram's
+// parser; copy-paste yields the clean glyph).
+function copyText(s: string): string {
+  return s.replace(/\\([~=|])/g, "$1");
+}
+
+describe("guardAccidentalInlinePairs — NO false positives on INTENDED formatting", () => {
+  // These are the hard constraint: the agent uses these DELIBERATELY. They must
+  // pass through byte-for-byte untouched.
+  it("leaves intended `~~strike~~` (word content) untouched", () => {
+    const s = "the ~~deprecated~~ flag is gone";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves intended single-tilde `~struck~` (word content) untouched", () => {
+    const s = "mark it ~struck~ for now";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves intended `==mark==` highlight untouched", () => {
+    const s = "please ==highlight this== part";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves two intended `==mark==` highlights untouched", () => {
+    const s = "==first== and also ==second== matter";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves intended `||spoiler||` untouched", () => {
+    const s = "the twist is ||he was dead|| all along";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves two intended `||spoiler||` spans untouched", () => {
+    const s = "reveal ||one|| then ||two|| slowly";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves intended `code` spans untouched (even with operators inside)", () => {
+    const s = "run `x==y` and `a||b` and `~10` in the shell";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves a single intended strike of a number `~~2024~~` untouched (below threshold)", () => {
+    const s = "the ~~2024~~ figure was revised";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves a lone comparison `x==y` untouched (cannot form a pair)", () => {
+    const s = "the check is x==y in the loop";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves a lone approximation `~10` untouched (cannot form a pair)", () => {
+    const s = "roughly ~10 items remain";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves space-flanked `a == b == c` untouched (cannot open a span)", () => {
+    const s = "assert a == b == c holds";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("is a strict no-op for text with none of the trigger chars", () => {
+    const s = "a perfectly ordinary sentence with no specials";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+});
+
+describe("guardAccidentalInlinePairs — neutralises ACCIDENTAL pairs", () => {
+  it("breaks an accidental strikethrough from two approximation tildes", () => {
+    const s = "trims to ~10 units, down from ~20 last week";
+    const out = guardAccidentalInlinePairs(s);
+    // No unescaped digit-adjacent tilde survives to open a `~…~` span.
+    expect(out).not.toMatch(/(?<!\\)~(?=\$?\.?\d)/);
+    expect(out).toContain("\\~10");
+    expect(out).toContain("\\~20");
+    // Reader-visible prose unchanged once the defuser is stripped.
+    expect(copyText(out)).toBe(s);
+  });
+
+  it("breaks an accidental strike from currency-approx tildes (`~$5M` / `~$9M`)", () => {
+    const s = "budget is ~$5M now, was ~$9M before";
+    const out = guardAccidentalInlinePairs(s);
+    expect(out).not.toMatch(/(?<!\\)~(?=\$?\.?\d)/);
+    expect(copyText(out)).toBe(s);
+  });
+
+  it("breaks the inner tilde of a `~~10 ... ~~20` double-open accidental pair", () => {
+    const s = "about ~~10 to ~~20 percent";
+    const out = guardAccidentalInlinePairs(s);
+    expect(out).not.toMatch(/(?<!\\)~(?=\$?\.?\d)/);
+    expect(copyText(out)).toBe(s);
+  });
+
+  it("breaks an accidental highlight from two `==` comparison operators", () => {
+    const s = "check x==y and then p==q in the guard";
+    const out = guardAccidentalInlinePairs(s);
+    expect(out).not.toMatch(/(?<=\w)==(?=\w)/);
+    expect(out).toContain("x\\=\\=y");
+    expect(out).toContain("p\\=\\=q");
+    expect(copyText(out)).toBe(s);
+  });
+
+  it("breaks an accidental spoiler from two `||` logical-or operators", () => {
+    const s = "when a||b and c||d both hold";
+    const out = guardAccidentalInlinePairs(s);
+    expect(out).not.toMatch(/(?<=\w)\|\|(?=\w)/);
+    expect(out).toContain("a\\|\\|b");
+    expect(out).toContain("c\\|\\|d");
+    expect(copyText(out)).toBe(s);
+  });
+
+  it("never escapes operators INSIDE a code span while fixing prose ones", () => {
+    const s = "prose x==y and p==q but code `m==n` stays";
+    const out = guardAccidentalInlinePairs(s);
+    // Prose operators neutralised…
+    expect(out).toContain("x\\=\\=y");
+    expect(out).toContain("p\\=\\=q");
+    // …code span verbatim.
+    expect(out).toContain("`m==n`");
+  });
+});
+
+describe("guardAccidentalInlinePairs — link / autolink awareness (finding 1)", () => {
+  it("leaves `==` inside a markdown link destination UNMODIFIED", () => {
+    const s = "see [a](https://x.io?p==1) and [b](https://y.io?q==2)";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves `~` (digit-adjacent) inside link destinations UNMODIFIED", () => {
+    const s = "see [a](https://x.io/~5x) and [b](https://y.io/~10y)";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("leaves `==` inside a bare autolinked URL UNMODIFIED", () => {
+    const s = "open https://x.io/path?a==1&b==2 in a browser";
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+});
+
+describe("guardAccidentalInlinePairs — table awareness (finding 3)", () => {
+  it("leaves a real table's empty cells (`|a||b|`) UNMODIFIED", () => {
+    const s = ["| A | B | C |", "| --- | --- | --- |", "|a||b||c|"].join("\n");
+    expect(guardAccidentalInlinePairs(s)).toBe(s);
+  });
+
+  it("STILL guards a genuine accidental `a||b` in prose (no delimiter row)", () => {
+    const out = guardAccidentalInlinePairs("eval a||b and c||d in code");
+    expect(out).toContain("a\\|\\|b");
+    expect(out).toContain("c\\|\\|d");
+  });
+});
+
+describe("guardAccidentalInlinePairs — idempotency", () => {
+  it("guarding already-guarded tilde text is a strict no-op", () => {
+    const once = guardAccidentalInlinePairs("trims to ~10 units, down from ~20 last week");
+    expect(guardAccidentalInlinePairs(once)).toBe(once);
+    expect(once).not.toContain("\\\\~"); // never a doubled backslash
+  });
+
+  it("guarding already-guarded `==`/`||` text is a strict no-op", () => {
+    const once = guardAccidentalInlinePairs("check x==y and p==q; also a||b and c||d");
+    expect(guardAccidentalInlinePairs(once)).toBe(once);
+  });
+});

package/telegram-plugin/tests/render/line-start-guard.test.ts

@@ -0,0 +1,164 @@
+import { describe, it, expect } from "vitest";
+import { guardAccidentalBlockConstructs } from "../../render/line-start-guard.js";
+
+/** Strip the defusing backslashes so we can assert the reader-visible text is
+ *  byte-identical to the original prose (Telegram consumes the `\`). */
+function copyText(s: string): string {
+  return s.replace(/\\([>.)])/g, "$1");
+}
+
+describe("guardAccidentalBlockConstructs (#3252) — INTENDED formatting is never touched", () => {
+  // ── Headings: deferred entirely, must pass through untouched ──
+  it("leaves an intended `# ` heading untouched (deferred family)", () => {
+    const s = "# Project status\nAll green.";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves `## `/`### ` sub-headings untouched", () => {
+    const s = "## Section\n### Subsection\nbody";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves `#1` (no space, not a GFM heading) untouched — Telegram renders it literally", () => {
+    const s = "#1 priority is latency";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves `# of items` untouched — deferred (indistinguishable from a heading)", () => {
+    const s = "# of items in the cart";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  // ── Intended blockquotes: `> ` with a space, never touched ──
+  it("leaves an intended `> quoted` blockquote untouched", () => {
+    const s = "> This is a real quote\n> spanning two lines";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves `> 50% of users` untouched — spaced form is a valid/intended blockquote", () => {
+    const s = "> 50% of users prefer dark mode";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  // ── Bullet lists: deferred entirely, never touched ──
+  it("leaves `- ` bullets untouched (deferred family)", () => {
+    const s = "- first item\n- second item\n- 5 apples";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves `* ` and `+ ` bullets untouched", () => {
+    const s = "* star bullet\n+ plus bullet";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves `- 5 degrees` untouched — ambiguous with a bullet, deferred", () => {
+    const s = "- 5 degrees below freezing";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  // ── Ordered lists: small numbers are real lists, never touched ──
+  it("leaves a real `1.`/`2.`/`3.` numbered list untouched", () => {
+    const s = "1. First we plan\n2. Then we build\n3. Finally we ship";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves a 2–3 digit list marker (`42.`, `100.`) untouched — deferred", () => {
+    const s = "42. answer\n100. century";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves a decimal `3.14` untouched (no space after dot => not a list)", () => {
+    const s = "3.14 is pi and 2.71 is e";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  // ── Non-triggering prose ──
+  it("is a strict no-op for ordinary prose with no line-start triggers", () => {
+    const s = "just a normal sentence about the weather today";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+});
+
+describe("guardAccidentalBlockConstructs (#3252) — accidental constructs ARE escaped", () => {
+  it("escapes a line-start `>2x` comparison (accidental blockquote)", () => {
+    const out = guardAccidentalBlockConstructs(">2x faster than before");
+    expect(out).toBe("\\>2x faster than before");
+    expect(copyText(out)).toBe(">2x faster than before");
+  });
+
+  it("escapes a line-start `>50%` comparison", () => {
+    const out = guardAccidentalBlockConstructs(">50% of the budget");
+    expect(out).toBe("\\>50% of the budget");
+  });
+
+  it("escapes a line-start `>=3` comparison", () => {
+    const out = guardAccidentalBlockConstructs(">=3 retries required");
+    expect(out).toBe("\\>=3 retries required");
+  });
+
+  it("escapes an accidental blockquote only on the offending line, mid-paragraph", () => {
+    const s = "Latency improved.\n>2x faster now\nShipping today.";
+    const out = guardAccidentalBlockConstructs(s);
+    expect(out).toBe("Latency improved.\n\\>2x faster now\nShipping today.");
+  });
+
+  it("escapes a 4+ digit year promoted to an ordered-list item (`2026. was`)", () => {
+    const out = guardAccidentalBlockConstructs("2026. was a great year for the team");
+    expect(out).toBe("2026\\. was a great year for the team");
+    expect(copyText(out)).toBe("2026. was a great year for the team");
+  });
+
+  it("escapes a `1999) ` year with the paren delimiter", () => {
+    const out = guardAccidentalBlockConstructs("1999) marked the dot-com peak");
+    expect(out).toBe("1999\\) marked the dot-com peak");
+  });
+
+  it("escapes the accidental ordered-list line only, inside a paragraph", () => {
+    const s = "Consider the timeline.\n2026. was pivotal\nThat is all.";
+    const out = guardAccidentalBlockConstructs(s);
+    expect(out).toBe("Consider the timeline.\n2026\\. was pivotal\nThat is all.");
+  });
+});
+
+describe("guardAccidentalBlockConstructs (#3252) — code / indent safety", () => {
+  it("never touches a `>` at the start of a FENCED code block line", () => {
+    const s = "```\n>2x in shell\n2026. code year\n```";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("never touches a `>` inside an inline code span", () => {
+    const s = "use `>2x` in the expression";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("does not treat a prose `>` that begins mid-line (after a code span) as a line start", () => {
+    // The `>5` is NOT at a real line start (an inline code span precedes it on
+    // the same line), so it must be left alone.
+    const s = "the value `x` >5 always";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("leaves a 4-space indented (code) line untouched", () => {
+    const s = "    >2x indented code\n    2026. also code";
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+
+  it("still escapes a construct indented 1–3 spaces (valid block context)", () => {
+    const out = guardAccidentalBlockConstructs("  >2x slightly indented");
+    expect(out).toBe("  \\>2x slightly indented");
+  });
+});
+
+describe("guardAccidentalBlockConstructs (#3252) — idempotency & no-op signal", () => {
+  it("is idempotent: guarding already-guarded text is a strict no-op", () => {
+    const once = guardAccidentalBlockConstructs(">2x and\n2026. year");
+    expect(guardAccidentalBlockConstructs(once)).toBe(once);
+    expect(once).not.toContain("\\\\"); // never a doubled backslash
+  });
+
+  it("short-circuits to a strict no-op when there is no `>` and no 4+ digit marker", () => {
+    const s = "1. a\n2. b\n- c\n# d\n> e";
+    // All intended constructs; contains `>` so it runs, but produces no change.
+    expect(guardAccidentalBlockConstructs(s)).toBe(s);
+  });
+});

package/telegram-plugin/tests/reply-owner-resolve.test.ts

@@ -277,3 +277,93 @@ describe('F2 — recency-bound the destructive latest-ended supersede tier', ()
     ).toBe('turn-T')
   })
 })
+
+/**
+ * Reply-flicker edit-in-place fix (PR #3266) — the deferred-correction
+ * resurrection window (adversarial-review L1).
+ *
+ * The fix defers the flushed-message correction (delete-resend vs edit-in-place)
+ * from the supersede site to the send site so a single-message reply can EDIT
+ * the flushed message A in place instead of delete+resend. But `take()` consumes
+ * the supersede record at the supersede site, and TWO arg-validation `throw`s
+ * (file too-large, invalid inline_keyboard) sit BETWEEN consumption and the
+ * correction. A late reply that supersedes a flush AND carries an oversized file
+ * / invalid keyboard throws before the correction runs: message A is neither
+ * deleted nor edited, the model retries `reply`, and — the record already
+ * consumed — the retry takes the no-record branch. Without a latch the retry
+ * would ship a fresh B alongside the stale narration A (both visible).
+ *
+ * The fix latches `ownerTurn.answerDelivered = true` at record consumption, so
+ * the retry (resolving the SAME ended owner turn) is caught by
+ * `decideAnswerLatchSuppression` and suppressed — exactly one message survives.
+ */
+describe('reply-flicker edit-in-place — mid-path throw + retry never resurrects the duplicate (L1)', () => {
+  const CHAT = '636363'
+
+  /** Minimal model of the ended owner turn atom the gateway mutates + reads. */
+  interface OwnerTurn { turnId: string; answerDelivered: boolean }
+
+  /**
+   * Drive the two gateway `reply` calls the incident produces, threading the
+   * SAME registry + owner-turn atom. `setLatchOnSupersede` toggles the fix on
+   * (true = PR behaviour) vs off (false = pre-fix red-on-main contrast).
+   * Returns which messages are visible after the sequence.
+   */
+  function runSupersedeThenThrowRetry(setLatchOnSupersede: boolean): {
+    visible: string[]
+    firstSuperseded: boolean
+    retrySuppressed: boolean
+  } {
+    const reg = new FlushedTurnSupersedeRegistry()
+    const now = 2_000_000
+    const owner: OwnerTurn = { turnId: 'turn-A', answerDelivered: false }
+    // The flush posted message A for turn-A and recorded it.
+    reg.record(CHAT, undefined, { turnId: owner.turnId, messageIds: [8001], text: 'narration\n\nthe answer' }, now)
+    const visible = ['A(flush-narration)']
+
+    // --- Call 1: the model's real `reply` lands and SUPERSEDES the flush. ---
+    const d1 = reg.take(CHAT, undefined, { liveTurnId: owner.turnId, now: now + 10 })
+    const firstSuperseded = d1.supersede
+    if (d1.supersede && setLatchOnSupersede) {
+      // The fix: latch at consumption, BEFORE the arg-validation throw.
+      owner.answerDelivered = true
+    }
+    // Arg-validation throw fires here (oversized file / invalid keyboard):
+    // the correction never runs → A is neither deleted nor edited, B not sent.
+    // (Modelled by simply NOT applying the correction and NOT pushing B.)
+
+    // --- Call 2: the model retries `reply` after seeing the MCP error. ---
+    // The record was consumed by Call 1's take() → no-record now.
+    const d2 = reg.take(CHAT, undefined, { liveTurnId: owner.turnId, now: now + 20 })
+    let retrySuppressed = false
+    if (!d2.supersede) {
+      // else/no-record branch: the retry is a late substantive reply.
+      retrySuppressed = decideAnswerLatchSuppression({
+        superseded: false,
+        replySubstantive: true,
+        isLateReply: true,
+        ownerAnswerDelivered: owner.answerDelivered,
+      })
+    }
+    if (!retrySuppressed) visible.push('B(retry-reply)')
+    return { visible, firstSuperseded, retrySuppressed }
+  }
+
+  it('WITH the fix: the retry is latch-suppressed → exactly ONE surviving message (never A+B)', () => {
+    const r = runSupersedeThenThrowRetry(true)
+    expect(r.firstSuperseded).toBe(true)
+    expect(r.retrySuppressed).toBe(true)
+    expect(r.visible).toHaveLength(1)
+    // The single surviving message is the flushed A (the correction throw left it
+    // in place); the retry B was suppressed — no stale-narration + reply duplicate.
+    expect(r.visible).toEqual(['A(flush-narration)'])
+  })
+
+  it('WITHOUT the fix (contrast): the retry is NOT suppressed → BOTH A and B ship (the resurrected duplicate)', () => {
+    const r = runSupersedeThenThrowRetry(false)
+    expect(r.firstSuperseded).toBe(true)
+    expect(r.retrySuppressed).toBe(false)
+    // The exact regression: stale narration A AND the retry reply B are both visible.
+    expect(r.visible).toEqual(['A(flush-narration)', 'B(retry-reply)'])
+  })
+})

package/telegram-plugin/tests/subagent-handback-inbound-builder.test.ts

@@ -37,6 +37,11 @@ describe('buildSubagentHandbackInbound', () => {
     // The wake-up contract: bridge renders <channel source="subagent_handback">.
     expect(inbound.meta.source).toBe('subagent_handback')
     expect(inbound.meta.outcome).toBe('completed')
+    // #3268 — the fabricated ts rounds-trips through meta.message_id (the only
+    // channel-rendered id) so enqueue's deriveTurnId matches the pre-turn seam's
+    // adopt id. Must equal the top-level messageId as a string.
+    expect(inbound.meta.message_id).toBe(String(FIXED_NOW))
+    expect(inbound.meta.message_id).toBe(String(inbound.messageId))
     // Text carries the task, the result, and the beat-4 steer.
     expect(inbound.text).toContain('Refactor the auth module')
     expect(inbound.text).toContain('4 tests added, all green')

package/telegram-plugin/tests/turn-active-marker.test.ts

@@ -15,6 +15,9 @@ import {
   removeTurnActiveMarker,
   sweepStaleTurnActiveMarker,
   readTurnActiveMarkerAgeMs,
+  effectiveTurnAgeMs,
+  TURN_ACTIVE_HARD_TTL_MS,
+  TURN_ACTIVE_IDLE_SWEEP_MS,
 } from '../gateway/turn-active-marker.js'
 
 describe('turn-active-marker (#412)', () => {
@@ -28,6 +31,32 @@ describe('turn-active-marker (#412)', () => {
     rmSync(tmp, { recursive: true, force: true })
   })
 
+  it('exports the sweep TTL bounds as shared constants (#3262 single source of truth)', () => {
+    // The /model & /effort phantom-turn cross-check reuses these SAME bounds —
+    // guarding against a drift where the atom ceiling and the marker ceiling
+    // diverge into two different magic numbers.
+    expect(TURN_ACTIVE_HARD_TTL_MS).toBe(10 * 60_000)
+    expect(TURN_ACTIVE_IDLE_SWEEP_MS).toBe(60_000)
+    expect(TURN_ACTIVE_HARD_TTL_MS).toBeGreaterThan(TURN_ACTIVE_IDLE_SWEEP_MS)
+  })
+
+  it('effectiveTurnAgeMs prefers the marker age when present (#3262)', () => {
+    // Marker present (touched on tool_use) → its age wins over the fixed
+    // turn.startedAt, so a legitimately LONG turn that keeps touching the
+    // marker reads fresh and is never mis-swept as a phantom.
+    const now = 1_000_000
+    expect(effectiveTurnAgeMs(5_000, now - 9_999_999, now)).toBe(5_000)
+  })
+
+  it('effectiveTurnAgeMs falls back to now - startedAt when the marker is absent (#3262)', () => {
+    // Marker already swept (null age) → fall back to the turn-start timestamp,
+    // so a dangling atom whose marker was reaped still reports a large age and
+    // is recognised as stale by the /model & /effort cross-check.
+    const now = 1_000_000
+    const startedAt = now - 42_000
+    expect(effectiveTurnAgeMs(null, startedAt, now)).toBe(42_000)
+  })
+
   it('writeTurnActiveMarker creates a JSON file with the expected payload', () => {
     writeTurnActiveMarker(tmp, {
       turnKey: 'chat:1:1700000000000',

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

@@ -659,6 +659,10 @@ describe('createWorkerActivityFeed — heartbeat', () => {
       bot,
       now: () => clock,
       minEditIntervalMs: 2500,
+      // Suffix-mechanics test: pin the elapsed-refresh cadence to the edit floor
+      // so this exercises the classic 6s heartbeat suffix, not the coarse
+      // flood-pacing cadence (covered by its own tests below).
+      elapsedRefreshMs: 2500,
       heartbeatTickMs: 6000,
       // No real timer: drive ticks manually.
       setInterval: () => 1,
@@ -862,6 +866,10 @@ describe('createWorkerActivityFeed — heartbeat', () => {
       firstPaintMinMs: 8000,
       heartbeatTickMs: 6000,
       minEditIntervalMs: 2500,
+      // Heartbeat-liveness test: pin the elapsed-refresh cadence to the edit
+      // floor so a later heartbeat repaints the climbing clock under the classic
+      // 6s cadence (coarse flood-pacing is covered by its own tests below).
+      elapsedRefreshMs: 2500,
       setInterval: () => 1,
       clearInterval: () => {},
     })
@@ -1551,3 +1559,116 @@ describe('worker-feed send-gate shed contract', () => {
     expect(feed.has('w1')).toBe(false)
   })
 })
+
+// ─── elapsed-only edit pacing (flood-ban defense, Part 1) ────────────────────
+
+describe('createWorkerActivityFeed — elapsed-only edit pacing', () => {
+  const drain = () => new Promise((r) => setTimeout(r, 0))
+
+  function mkFeed(bot: FakeBot, nowRef: { t: number }) {
+    return createWorkerActivityFeed({
+      bot,
+      now: () => nowRef.t,
+      minEditIntervalMs: 2500,
+      elapsedRefreshMs: 15_000,
+      firstPaintMinMs: 8000,
+      heartbeatTickMs: 6000,
+      setInterval: () => 1,
+      clearInterval: () => {},
+    })
+  }
+
+  it('suppresses clock-only churn: elapsed advancing within elapsedRefreshMs emits NO edit', async () => {
+    const bot = makeFakeBot()
+    const ref = { t: 10_000 }
+    const feed = mkFeed(bot, ref)
+
+    // First paint.
+    ref.t = 20_000
+    await feed.update('w1', 'chat', view({ elapsedMs: 9000, latestSummary: 'scanning', toolCount: 3 }))
+    expect(bot.sent).toHaveLength(1)
+
+    // A stream of ticks where ONLY the elapsed clock advances (same step, same
+    // toolCount). Every one is past the 2.5s edit floor but under the 15s
+    // elapsed-refresh cadence measured from the last edit (paint @20_000) — so
+    // the send-gate-evading clock-only edit that earns a flood ban never fires.
+    for (const t of [23_000, 26_000, 30_000, 34_000]) {
+      ref.t = t
+      await feed.update('w1', 'chat', view({ elapsedMs: t - 11_000, latestSummary: 'scanning', toolCount: 3 }))
+    }
+    await drain()
+    expect(bot.edits).toHaveLength(0)
+  })
+
+  it('renders a substantive step change PROMPTLY (before the elapsed-refresh cadence)', async () => {
+    const bot = makeFakeBot()
+    const ref = { t: 10_000 }
+    const feed = mkFeed(bot, ref)
+
+    ref.t = 20_000
+    await feed.update('w1', 'chat', view({ elapsedMs: 9000, latestSummary: 'scanning', toolCount: 3 }))
+    expect(bot.sent).toHaveLength(1)
+
+    // 6s later: still under the 15s elapsed-refresh cadence, but the STEP and
+    // toolCount changed — a real update. It renders immediately (only the 2.5s
+    // floor applies), not held for the coarse clock cadence.
+    ref.t = 26_000
+    await feed.update('w1', 'chat', view({ elapsedMs: 15_000, latestSummary: 'writing report', toolCount: 4 }))
+    await drain()
+    expect(bot.edits.length).toBeGreaterThanOrEqual(1)
+    expect(bot.edits[bot.edits.length - 1].text).toContain('writing report')
+  })
+
+  it('forces the terminal edit through and renders the honest final elapsed', async () => {
+    const bot = makeFakeBot()
+    const ref = { t: 10_000 }
+    const feed = mkFeed(bot, ref)
+
+    ref.t = 20_000
+    await feed.update('w1', 'chat', view({ elapsedMs: 9000, latestSummary: 'scanning', toolCount: 3 }))
+    expect(bot.sent).toHaveLength(1)
+
+    // Completion within the elapsed-refresh window still finalizes immediately
+    // (terminal edits bypass the pacing) and shows the correct final elapsed.
+    ref.t = 28_000
+    await feed.finish('w1', view({ state: 'done', toolCount: 6, elapsedMs: 31_000, latestSummary: 'all done' }))
+    await drain()
+    expect(bot.edits.length).toBeGreaterThanOrEqual(1)
+    const last = bot.edits[bot.edits.length - 1].text
+    expect(last).toContain('done · 6 tools')
+    expect(last).toContain('31s')
+  })
+
+  it('does not over-suppress a substantive change that would field-boundary-collide under naive concatenation', async () => {
+    const bot = makeFakeBot()
+    const ref = { t: 10_000 }
+    const feed = mkFeed(bot, ref)
+
+    // Paint: toolCount 1, totalTokens 23. Under a delimiter-less substance key
+    // the fields `1` and `23` concatenate to `123`.
+    ref.t = 20_000
+    await feed.update(
+      'w1',
+      'chat',
+      view({ elapsedMs: 9000, latestSummary: 'scanning', toolCount: 1, totalTokens: 23 }),
+    )
+    expect(bot.sent).toHaveLength(1)
+
+    // A REAL substantive change (toolCount 1→12, totalTokens 23→3) that collides
+    // to the SAME `123` under naive concatenation. It lands within the 15s
+    // elapsed-refresh window (past the 2.5s floor), so ONLY a substance-key
+    // difference can drive the edit. A colliding key would wrongly treat this as
+    // elapsed-only churn and suppress it; the NUL/RS-delimited key keeps them
+    // distinct, so the edit fires promptly.
+    ref.t = 22_500
+    await feed.update(
+      'w1',
+      'chat',
+      view({ elapsedMs: 11_500, latestSummary: 'scanning', toolCount: 12, totalTokens: 3 }),
+    )
+    await drain()
+    expect(bot.edits.length).toBeGreaterThanOrEqual(1)
+    // The rendered card reflects the new tool count, proving the change landed.
+    expect(bot.edits[bot.edits.length - 1].text).toContain('12 tools')
+  })
+})