switchroom 0.19.3 → 0.19.5

package/telegram-plugin/tests/gateway-heartbeat.test.ts

@@ -0,0 +1,70 @@
+/**
+ * Gateway liveness heartbeat writer (duplicate-message fix).
+ *
+ * The Stop hook's single-writer election only ALLOWS a stop (handing delivery
+ * to the gateway) when the gateway heartbeat file is fresh. This pins the
+ * writer: it creates the file, bumps its mtime on subsequent touches, and the
+ * hook's freshness reader agrees on the filename + bound.
+ */
+
+import { describe, it, expect } from 'vitest'
+import { mkdtempSync, existsSync, rmSync, utimesSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import {
+  touchGatewayHeartbeat,
+  startGatewayHeartbeat,
+  GATEWAY_HEARTBEAT_FILE,
+} from '../gateway/gateway-heartbeat.js'
+import {
+  isGatewayHeartbeatFresh,
+  GATEWAY_HEARTBEAT_FILE as HOOK_HEARTBEAT_FILE,
+} from '../hooks/silent-end-scan.mjs'
+
+describe('gateway-heartbeat writer', () => {
+  it('creates the heartbeat file on first touch under a fresh state dir', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'gw-hb-w-'))
+    try {
+      const path = join(dir, GATEWAY_HEARTBEAT_FILE)
+      expect(existsSync(path)).toBe(false)
+      touchGatewayHeartbeat(dir)
+      expect(existsSync(path)).toBe(true)
+      // The hook's freshness reader agrees it's fresh.
+      expect(isGatewayHeartbeatFresh(dir)).toBe(true)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it('refreshes an aged heartbeat back to fresh on a subsequent touch', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'gw-hb-w-'))
+    try {
+      const path = join(dir, GATEWAY_HEARTBEAT_FILE)
+      touchGatewayHeartbeat(dir)
+      // Backdate the mtime to stale, then touch again → back to fresh.
+      const old = new Date(Date.now() - 10 * 60_000)
+      utimesSync(path, old, old)
+      expect(isGatewayHeartbeatFresh(dir)).toBe(false)
+      touchGatewayHeartbeat(dir)
+      expect(isGatewayHeartbeatFresh(dir)).toBe(true)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it('startGatewayHeartbeat writes immediately and returns an unref-able timer', () => {
+    const dir = mkdtempSync(join(tmpdir(), 'gw-hb-w-'))
+    try {
+      const timer = startGatewayHeartbeat(dir, 60_000)
+      expect(existsSync(join(dir, GATEWAY_HEARTBEAT_FILE))).toBe(true)
+      clearInterval(timer)
+    } finally {
+      rmSync(dir, { recursive: true, force: true })
+    }
+  })
+
+  it('the writer filename and the hook reader filename are identical (no drift)', () => {
+    expect(GATEWAY_HEARTBEAT_FILE).toBe(HOOK_HEARTBEAT_FILE)
+    expect(GATEWAY_HEARTBEAT_FILE).toBe('gateway-heartbeat')
+  })
+})

package/telegram-plugin/tests/hang-restart-decision.test.ts

@@ -0,0 +1,146 @@
+/**
+ * Unit tests for the progress-based hang-restart discriminator (Stage B).
+ *
+ * The crux: a mid-tool framework fallback with a STALE turn-active marker
+ * escalates to a real restart, but a fallback whose marker mtime keeps
+ * advancing (a healthy long turn), OR whose in-flight tool is a known-long
+ * class (Bash/WebFetch/Task/research — Finding A), must NOT be restarted.
+ *
+ * FAILS on current head: `../gateway/hang-restart-decision.js` does not exist
+ * there — the discriminator is the contribution under test.
+ */
+
+import { describe, it, expect } from 'vitest'
+import {
+  decideHangRestart,
+  isHangRestartProtectedTool,
+  classifyToolClass,
+  hangStalenessMs,
+  DEFAULT_HANG_STALENESS_MS,
+} from '../gateway/hang-restart-decision.js'
+
+const STALE = 300_000
+
+describe('decideHangRestart — the crux discriminator', () => {
+  it('(1) tool mid-call + zero marker progress past the ceiling ⇒ restart requested', () => {
+    const d = decideHangRestart({
+      inFlightToolNames: ['some_mcp_tool'], // a standard, non-long tool
+      markerAgeMs: 600_000, // 10 min since last observable progress
+      stalenessThresholdMs: STALE,
+    })
+    expect(d.restart).toBe(true)
+    expect(d.reason).toBe('mid-tool-marker-stale')
+  })
+
+  it('(2) a turn whose marker mtime keeps advancing is NOT restarted', () => {
+    const d = decideHangRestart({
+      inFlightToolNames: ['some_mcp_tool'],
+      markerAgeMs: 4_000, // marker touched 4s ago — the turn is working
+      stalenessThresholdMs: STALE,
+    })
+    expect(d.restart).toBe(false)
+    expect(d.reason).toBe('marker-advancing')
+  })
+
+  it('a marker exactly at the staleness ceiling is stale ⇒ restart', () => {
+    const d = decideHangRestart({
+      inFlightToolNames: ['some_mcp_tool'],
+      markerAgeMs: STALE,
+      stalenessThresholdMs: STALE,
+    })
+    expect(d.restart).toBe(true)
+  })
+
+  it('an absent marker (no progress signal at all) is treated as stale ⇒ restart', () => {
+    const d = decideHangRestart({
+      inFlightToolNames: ['some_mcp_tool'],
+      markerAgeMs: null,
+      stalenessThresholdMs: STALE,
+    })
+    expect(d.restart).toBe(true)
+  })
+
+  it('a fallback that is NOT mid-tool never restarts (ordinary teardown owns it)', () => {
+    const d = decideHangRestart({
+      inFlightToolNames: [],
+      markerAgeMs: null,
+      stalenessThresholdMs: STALE,
+    })
+    expect(d.restart).toBe(false)
+    expect(d.reason).toBe('not-mid-tool')
+  })
+})
+
+describe('decideHangRestart — Finding A: protect known-long foreground tools', () => {
+  it('a healthy long foreground Bash + stale marker is NOT restarted', () => {
+    // The exact false-positive the review flagged: a 15-min foreground `Bash`
+    // build/test never touches the marker, so at the ceiling it looks stale —
+    // but it is genuinely working. It must be protected.
+    const d = decideHangRestart({
+      inFlightToolNames: ['Bash'],
+      markerAgeMs: 900_000, // 15 min stale
+      stalenessThresholdMs: STALE,
+    })
+    expect(d.restart).toBe(false)
+    expect(d.reason).toBe('protected-long-tool:Bash')
+  })
+
+  it('WebFetch / Task / a research MCP tool + stale marker are NOT restarted', () => {
+    for (const name of ['WebFetch', 'Task', 'Agent', 'perplexity_research', 'mcp__webkite__crawl']) {
+      const d = decideHangRestart({
+        inFlightToolNames: [name],
+        markerAgeMs: 900_000,
+        stalenessThresholdMs: STALE,
+      })
+      expect(d.restart, `${name} should be protected`).toBe(false)
+      expect(d.reason).toContain('protected-long-tool')
+    }
+  })
+
+  it('a protected long tool ALONGSIDE a standard tool still protects (conservative)', () => {
+    const d = decideHangRestart({
+      inFlightToolNames: ['quick_tool', 'Bash'],
+      markerAgeMs: 900_000,
+      stalenessThresholdMs: STALE,
+    })
+    expect(d.restart).toBe(false)
+  })
+
+  it('a genuinely-standard hung tool (no long class in flight) + stale ⇒ restart', () => {
+    const d = decideHangRestart({
+      inFlightToolNames: ['Read', 'some_mcp_query'],
+      markerAgeMs: 900_000,
+      stalenessThresholdMs: STALE,
+    })
+    expect(d.restart).toBe(true)
+  })
+})
+
+describe('isHangRestartProtectedTool + classifyToolClass', () => {
+  it('protects background / long-fetch / research / human classes', () => {
+    for (const n of ['Task', 'Agent', 'Bash', 'WebFetch', 'WebSearch', 'ask_user',
+      'perplexity_research', 'deep_research', 'mcp__webkite__crawl']) {
+      expect(isHangRestartProtectedTool(n), n).toBe(true)
+    }
+  })
+  it('does NOT protect ordinary quick tools', () => {
+    for (const n of ['Read', 'Grep', 'Edit', 'Write', 'some_mcp_query']) {
+      expect(isHangRestartProtectedTool(n), n).toBe(false)
+    }
+  })
+  it('classifyToolClass taxonomy (ported from Stage A)', () => {
+    expect(classifyToolClass('ask_user')).toBe('human')
+    expect(classifyToolClass('Task')).toBe('background')
+    expect(classifyToolClass('Bash', { backgroundBash: true })).toBe('background')
+    expect(classifyToolClass('Read')).toBe('standard')
+  })
+})
+
+describe('config helpers', () => {
+  it('hangStalenessMs keys off TURN_HANG_SECS (seconds → ms), default 300s', () => {
+    expect(hangStalenessMs({})).toBe(DEFAULT_HANG_STALENESS_MS)
+    expect(hangStalenessMs({ TURN_HANG_SECS: '120' })).toBe(120_000)
+    expect(hangStalenessMs({ TURN_HANG_SECS: 'nope' })).toBe(DEFAULT_HANG_STALENESS_MS)
+    expect(hangStalenessMs({ TURN_HANG_SECS: '0' })).toBe(DEFAULT_HANG_STALENESS_MS)
+  })
+})

package/telegram-plugin/tests/hang-restart-marker-integration.test.ts

@@ -0,0 +1,98 @@
+/**
+ * Integration test for the Stage B crux false-positive protection (review
+ * Finding C).
+ *
+ * The pure `decideHangRestart` tests pass `markerAgeMs` as a literal. This
+ * test proves the REAL chain end-to-end on a real marker file:
+ *
+ *   sub-agent JSONL growth → touchTurnActiveMarker (the exact call the
+ *   subagent-watcher makes at subagent-watcher.ts:1324) → readTurnActiveMarkerAgeMs
+ *   yields a SMALL age → decideHangRestart does NOT restart.
+ *
+ * i.e. a genuinely-working long turn (its only liveness being sub-agent output)
+ * is protected against the hang-restart, not just in the abstract.
+ */
+
+import { describe, it, expect, afterEach } from 'vitest'
+import { mkdtempSync, rmSync, statSync, utimesSync } from 'node:fs'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import {
+  writeTurnActiveMarker,
+  touchTurnActiveMarker,
+  readTurnActiveMarkerAgeMs,
+  removeTurnActiveMarker,
+  TURN_ACTIVE_MARKER_FILE,
+} from '../gateway/turn-active-marker.js'
+import { decideHangRestart, DEFAULT_HANG_STALENESS_MS } from '../gateway/hang-restart-decision.js'
+
+const dirs: string[] = []
+function tempDir(): string {
+  const d = mkdtempSync(join(tmpdir(), 'hang-marker-'))
+  dirs.push(d)
+  return d
+}
+afterEach(() => {
+  for (const d of dirs.splice(0)) rmSync(d, { recursive: true, force: true })
+})
+
+describe('Stage B marker integration — healthy long turn is protected end-to-end', () => {
+  it('sub-agent JSONL growth touches the marker → small age → NOT restarted', () => {
+    const dir = tempDir()
+    writeTurnActiveMarker(dir, { turnKey: 't1', chatId: '123', startedAt: Date.now() })
+    const path = join(dir, TURN_ACTIVE_MARKER_FILE)
+
+    // Simulate a turn that has been running long with NO interim tool_use —
+    // force the marker mtime stale (15 min old). Without a progress touch this
+    // would read as a hang.
+    const now = Date.now()
+    const staleTime = new Date(now - 900_000)
+    utimesSync(path, staleTime, staleTime)
+    const staleAge = readTurnActiveMarkerAgeMs(dir, now)
+    expect(staleAge).not.toBeNull()
+    expect(staleAge!).toBeGreaterThanOrEqual(DEFAULT_HANG_STALENESS_MS)
+
+    // Now the sub-agent produces output: the watcher touches the marker (this
+    // is the exact call at subagent-watcher.ts:1324). The mtime advances.
+    touchTurnActiveMarker(dir)
+    const freshAge = readTurnActiveMarkerAgeMs(dir)
+    expect(freshAge).not.toBeNull()
+    expect(freshAge!).toBeLessThan(5_000) // touched just now → small age
+
+    // Fed through the real decision with a NON-protected in-flight tool (so the
+    // only thing keeping it alive is the fresh marker), it must NOT restart.
+    const d = decideHangRestart({
+      inFlightToolNames: ['some_mcp_query'],
+      markerAgeMs: freshAge,
+      stalenessThresholdMs: DEFAULT_HANG_STALENESS_MS,
+    })
+    expect(d.restart).toBe(false)
+    expect(d.reason).toBe('marker-advancing')
+  })
+
+  it('with no touch, the stale marker + non-protected tool DOES restart (control)', () => {
+    const dir = tempDir()
+    writeTurnActiveMarker(dir, { turnKey: 't2', chatId: '123', startedAt: Date.now() })
+    const path = join(dir, TURN_ACTIVE_MARKER_FILE)
+    const now = Date.now()
+    const staleTime = new Date(now - 900_000)
+    utimesSync(path, staleTime, staleTime)
+
+    const age = readTurnActiveMarkerAgeMs(dir, now)
+    const d = decideHangRestart({
+      inFlightToolNames: ['some_mcp_query'],
+      markerAgeMs: age,
+      stalenessThresholdMs: DEFAULT_HANG_STALENESS_MS,
+    })
+    expect(d.restart).toBe(true)
+    expect(d.reason).toBe('mid-tool-marker-stale')
+  })
+
+  it('readTurnActiveMarkerAgeMs is null once the marker is removed', () => {
+    const dir = tempDir()
+    writeTurnActiveMarker(dir, { turnKey: 't3', chatId: '1', startedAt: Date.now() })
+    expect(statSync(join(dir, TURN_ACTIVE_MARKER_FILE)).isFile()).toBe(true)
+    removeTurnActiveMarker(dir)
+    expect(readTurnActiveMarkerAgeMs(dir)).toBeNull()
+  })
+})

package/telegram-plugin/tests/render/heading-guard-blockquote-glued-hash.test.ts

@@ -0,0 +1,86 @@
+import { describe, it, expect } from "vitest";
+import { guardAccidentalHeading } from "../../render/line-start-guard.js";
+import { guardAccidentalFormatting } from "../../rich-send.js";
+
+// Characterization test for #3464 — glued `#` AFTER a blockquote/list marker.
+//
+// ── The observation (#3464, follow-up from #3463 review) ─────────────────────
+// `guardAccidentalHeading` is `^`-anchored (`ACCIDENTAL_HEADING = /^([ \t]{0,3})
+// (#{1,6})(?=[^\s#])/`), so a `#` glued after a blockquote or list marker on the
+// same line — `> #3460`, `- #3460`, `1. #3460` — is NOT matched, and the seam
+// leaves it untouched. On the RENDERER path this position is incidentally
+// escaped, because render.ts:escapeLineLeadingHash runs on the paragraph's
+// rendered text BEFORE renderBlockquote/renderList prepend the `> `/`- ` marker.
+// On the renderer-BYPASS seam (cards / banners / status / approval sends), no
+// such belt runs, so the glued `#` reaches Telegram unescaped.
+//
+// ── Why this test PINS the current behavior instead of changing it ───────────
+// Whether this is a bug depends on a fact we CANNOT determine from the byte
+// stream: does Telegram's non-spec Bot API rich parser actually promote a
+// space-less `#` to a heading when it sits AFTER a `>`/list marker, the way it
+// demonstrably does at a bare line start (`#3460` → giant heading, #3306/#3463)?
+//   - CommonMark treats `> #3460` as a blockquote whose content is the paragraph
+//     `#3460` (no ATX heading — no space after `#`); `> # Heading` (WITH space)
+//     is a real nested heading. Telegram's promotion of the SPACE-LESS form is
+//     the documented non-spec deviation — but only ever OBSERVED at a bare line
+//     start, never confirmed inside a blockquote/list.
+//   - There is no repo evidence (UAT fixture, doc note, or #3306/#3463 UAT
+//     result) establishing that the promotion fires in this nested position.
+//     The render.ts belt escaping it is a GENERIC side effect of a `^…#`
+//     paragraph regex, not a confirmed-behavior signal.
+// Issue #3464 itself says: "Verify against Telegram live-UAT whether the
+// non-spec heading promotion actually fires inside blockquotes/lists before
+// adding escaping (avoid stray backslashes if it does not)." That live UAT
+// cannot run in vitest. Ken's hard constraint on this guard family is that a
+// wrong "fix" adding stray backslashes would itself corrupt legitimate
+// formatting — the exact thing to avoid. So this test DOCUMENTS the current,
+// deliberately-conservative behavior; if live UAT later confirms Telegram DOES
+// promote here, extend the guard and flip these expectations in the same PR.
+
+describe("guardAccidentalHeading — glued `#` after a blockquote/list marker is NOT escaped (#3464, awaits live-UAT)", () => {
+  it("leaves `> #3460` untouched (glued hash after a blockquote marker)", () => {
+    expect(guardAccidentalHeading("> #3460 done")).toBe("> #3460 done");
+  });
+
+  it("leaves `- #3460` untouched (glued hash after an unordered-list marker)", () => {
+    expect(guardAccidentalHeading("- #3460 done")).toBe("- #3460 done");
+  });
+
+  it("leaves `* #3460` untouched (glued hash after a `*` bullet)", () => {
+    expect(guardAccidentalHeading("* #3460 x")).toBe("* #3460 x");
+  });
+
+  it("leaves `1. #3460` untouched (glued hash after an ordered-list marker)", () => {
+    expect(guardAccidentalHeading("1. #3460 x")).toBe("1. #3460 x");
+  });
+
+  it("still escapes the SAME `#3460` at a bare line start (the confirmed case)", () => {
+    // Proves the untouched results above are the `^`-anchor scope, not the guard
+    // being disabled: at a real line start the accidental heading IS escaped.
+    expect(guardAccidentalHeading("#3460 done")).toBe("\\#3460 done");
+  });
+});
+
+describe("guardAccidentalHeading — a real nested heading (space form) must stay untouched (#3464)", () => {
+  it("leaves `> # Heading` untouched (intended heading inside a blockquote)", () => {
+    expect(guardAccidentalHeading("> # Heading")).toBe("> # Heading");
+  });
+
+  it("leaves `- # Heading` untouched (intended heading inside a list item)", () => {
+    expect(guardAccidentalHeading("- # Heading")).toBe("- # Heading");
+  });
+});
+
+describe("guardAccidentalFormatting (universal seam) — same conservative behavior end-to-end (#3464)", () => {
+  it("leaves `> #3460` untouched through the full composition", () => {
+    expect(guardAccidentalFormatting("> #3460 done")).toBe("> #3460 done");
+  });
+
+  it("leaves `- #3460` untouched through the full composition", () => {
+    expect(guardAccidentalFormatting("- #3460 done")).toBe("- #3460 done");
+  });
+
+  it("still escapes a bare line-leading `#3460` at the seam (control)", () => {
+    expect(guardAccidentalFormatting("#3460 done")).toBe("\\#3460 done");
+  });
+});

package/telegram-plugin/tests/render/heading-guard.test.ts

@@ -0,0 +1,114 @@
+import { describe, it, expect } from "vitest";
+import { guardAccidentalHeading } from "../../render/line-start-guard.js";
+import { guardAccidentalFormatting } from "../../rich-send.js";
+
+// Accidental-heading guard (#3306 follow-up): Telegram's Bot API rich-markdown
+// parser is NON-spec and promotes a line-leading `#{1,6}` run to a heading even
+// WITHOUT the CommonMark-required trailing space, so `#3460 done` renders as a
+// giant heading. The guard escapes ONLY the space-less, non-`#`-adjacent form
+// and leaves genuine `# Title` / `## Sub` headings byte-for-byte untouched.
+//
+// The load-bearing assertions run against the REAL universal wire seam
+// `guardAccidentalFormatting` (rich-send.ts) — the composed guard every
+// `{ markdown }` send funnels through — not the renderer, so cards / banners /
+// status / approval sends (which bypass the rich renderer) are proven covered.
+
+/** Strip the defusing backslash 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, "#");
+}
+
+describe("guardAccidentalHeading — accidental Telegram heading is escaped", () => {
+  it("escapes ONLY the line-leading `#3460`, not the mid-line `#3462` after `PR `", () => {
+    expect(guardAccidentalHeading("#3460 done and up as PR #3462")).toBe(
+      "\\#3460 done and up as PR #3462",
+    );
+  });
+
+  it("escapes `#foo` (no space, glued to a letter)", () => {
+    expect(guardAccidentalHeading("#foo bar")).toBe("\\#foo bar");
+  });
+
+  it("escapes `###x` (multi-hash run, no space)", () => {
+    expect(guardAccidentalHeading("###x")).toBe("\\###x");
+  });
+
+  it("reader-visible text is byte-identical after stripping the backslash", () => {
+    const s = "#3460 done";
+    expect(copyText(guardAccidentalHeading(s))).toBe(s);
+  });
+});
+
+describe("guardAccidentalHeading — intended headings are NEVER touched", () => {
+  it("leaves `# Real Heading` (space form) untouched", () => {
+    const s = "# Real Heading";
+    expect(guardAccidentalHeading(s)).toBe(s);
+  });
+
+  it("leaves `## Sub` untouched", () => {
+    const s = "## Sub";
+    expect(guardAccidentalHeading(s)).toBe(s);
+  });
+
+  it("leaves a bare `#` / `##` (end-of-line) untouched", () => {
+    expect(guardAccidentalHeading("#")).toBe("#");
+    expect(guardAccidentalHeading("##\nbody")).toBe("##\nbody");
+  });
+
+  it("leaves a multi-line mix intact: heading kept, glued ref escaped", () => {
+    const s = "# Title\n#3460 is the issue";
+    expect(guardAccidentalHeading(s)).toBe("# Title\n\\#3460 is the issue");
+  });
+
+  it("leaves a 4-space indented `#3460` (indented code) untouched", () => {
+    const s = "    #3460 indented code";
+    expect(guardAccidentalHeading(s)).toBe(s);
+  });
+});
+
+describe("guardAccidentalHeading — code spans / fences are verbatim", () => {
+  it("does not escape `#` inside an inline code span", () => {
+    expect(guardAccidentalHeading("`#3460`")).toBe("`#3460`");
+  });
+
+  it("does not escape a line-leading `#3460` inside a fenced block", () => {
+    const s = "```\n#3460 in code\n```";
+    expect(guardAccidentalHeading(s)).toBe(s);
+  });
+});
+
+describe("guardAccidentalHeading — idempotent + no-op", () => {
+  it("running twice equals running once", () => {
+    const once = guardAccidentalHeading("#3460 done");
+    expect(guardAccidentalHeading(once)).toBe(once);
+  });
+
+  it("is a strict no-op on hash-free text", () => {
+    const s = "no hashes here at all";
+    expect(guardAccidentalHeading(s)).toBe(s);
+  });
+});
+
+describe("guardAccidentalFormatting (universal seam) escapes accidental headings", () => {
+  it("escapes the line-leading `#3460`, leaves the mid-line `#3462`", () => {
+    expect(
+      guardAccidentalFormatting("#3460 done and up as PR #3462"),
+    ).toBe("\\#3460 done and up as PR #3462");
+  });
+
+  it("leaves `# Real Heading` untouched through the full composition", () => {
+    expect(guardAccidentalFormatting("# Real Heading")).toBe("# Real Heading");
+  });
+
+  it("does not double-escape an already-escaped `\\#3460` (renderer belt + seam)", () => {
+    // render.ts:escapeLineLeadingHash may already have escaped the `#`; the seam
+    // must not turn `\#3460` into `\\#3460`.
+    expect(guardAccidentalFormatting("\\#3460 done")).toBe("\\#3460 done");
+  });
+
+  it("is idempotent at the seam", () => {
+    const once = guardAccidentalFormatting("#3460 done");
+    expect(guardAccidentalFormatting(once)).toBe(once);
+  });
+});

package/telegram-plugin/tests/render/rich-corpus-seam-regression.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect } from "vitest";
+import { guardAccidentalFormatting } from "../../rich-send.js";
+
+// Composed-seam rich-corpus regression (#3465).
+//
+// The individual guards (heading / block-construct / emphasis / inline-pair /
+// dollar) each have focused tests, and guard-composition.test.ts proves pairs
+// of guards don't interfere. What was MISSING is a single assertion that a
+// FULL, representative rich-formatting corpus — every construct Ken's
+// rich-formatting directive relies on, together in one message — survives the
+// REAL universal wire seam `guardAccidentalFormatting` (rich-send.ts)
+// BYTE-IDENTICAL. That is the property the whole conservative-guard family
+// exists to protect: intended formatting must NEVER be restricted or corrupted.
+// This test pins it against regression from any future guard that over-reaches.
+//
+// The corpus deliberately contains NO line-leading glued-`#` (e.g. `#3460`), so
+// under the current guards it must be left completely untouched. The second
+// suite proves that untouched-ness is the guards being CORRECT, not the guards
+// being disabled: a line-leading `#3460` in the same corpus position IS escaped.
+
+/** One representative message carrying, together: `**bold**`, `_italic_`,
+ *  `~~strike~~`, inline `code`, a fenced block, a `[link](url#frag)`, a `>`
+ *  blockquote, an unordered list, an ordered list, and real `# `/`## ` headings.
+ *  Every construct is in its INTENDED, well-formed shape — none matches a guard's
+ *  accidental-signal — so the whole thing is expected to pass through verbatim. */
+const RICH_CORPUS = [
+  "# Release notes",
+  "## Highlights",
+  "Shipped **bold wins** and some _italic nuance_ this cycle.",
+  "The old flag is ~~deprecated~~ now.",
+  "Call `guardAccidentalFormatting` at the seam.",
+  "",
+  "```ts",
+  "const x = renderRich(markdown)",
+  "return x",
+  "```",
+  "",
+  "See the [rendering guide](https://ex.com/a#frag) for details.",
+  "",
+  "> This is a genuine blockquote from the design note.",
+  "",
+  "Unordered:",
+  "- first point",
+  "- second point",
+  "",
+  "Ordered:",
+  "1. plan",
+  "2. build",
+  "3. ship",
+].join("\n");
+
+describe("guardAccidentalFormatting — full rich corpus passes the seam byte-identical (#3465)", () => {
+  it("leaves a complete intended-formatting corpus completely untouched", () => {
+    expect(guardAccidentalFormatting(RICH_CORPUS)).toBe(RICH_CORPUS);
+  });
+
+  it("is idempotent on the rich corpus (seam re-application is a strict no-op)", () => {
+    const once = guardAccidentalFormatting(RICH_CORPUS);
+    expect(guardAccidentalFormatting(once)).toBe(once);
+  });
+});
+
+describe("guardAccidentalFormatting — the untouched result is the guard working, not disabled (#3465)", () => {
+  it("STILL escapes a line-leading `#3460` present in the same corpus", () => {
+    // Inject an accidental Telegram-only heading (`#3460`, glued to a digit, no
+    // space) into the corpus. The seam MUST escape it — proving the byte-identical
+    // pass above is the guard correctly finding no accidental signal, not the
+    // guard being a no-op / kill-switched.
+    const corpusWithGluedHash = RICH_CORPUS + "\n#3460 is the tracking issue";
+    const out = guardAccidentalFormatting(corpusWithGluedHash);
+    // The rest of the corpus is unchanged; only the glued hash is escaped.
+    expect(out).toBe(RICH_CORPUS + "\n\\#3460 is the tracking issue");
+    // And the reader-visible text (backslash consumed by Telegram) is intact.
+    expect(out.replace(/\\#/g, "#")).toBe(corpusWithGluedHash);
+  });
+});

package/telegram-plugin/tests/silent-end-interrupt-stop-integration.test.ts

@@ -296,4 +296,67 @@ describe('silent-end-interrupt-stop.mjs — integration', () => {
     expect(r.status).toBe(0)
     expect(r.stdout.trim()).toBe('')
   })
+
+  // ── Single-writer election (duplicate-message fix) ─────────────────
+  describe('single-writer election end-to-end', () => {
+    function writeFreshHeartbeat() {
+      writeFileSync(join(stateDir, 'gateway-heartbeat'), String(Date.now()), 'utf8')
+    }
+
+    it('zero-reply ≥200 + FRESH gateway heartbeat → ALLOW (no block re-prompt), state file still written for the flush', () => {
+      // The duplicate repro: today this BLOCKS *and* the gateway flush fires →
+      // two messages. With a fresh heartbeat the election ALLOWS the stop so
+      // the gateway flush is the single writer.
+      writeFreshHeartbeat()
+      const transcript = writeTranscript(tmp, [
+        ENQUEUE,
+        { type: 'assistant', message: { content: [{ type: 'text', text: 'A'.repeat(300) }] } },
+      ])
+      const r = runHook({ event: { session_id: 's1', transcript_path: transcript }, stateDir })
+      expect(r.status).toBe(0)
+      // ALLOW → no block JSON on stdout.
+      expect(r.stdout.trim()).toBe('')
+      expect(r.stderr).toMatch(/single-writer election ALLOWED/)
+      // State file IS written so the gateway's captured-prose bridge has its
+      // input (turnKey/turnId/pendingText); retryCount stays 0 (not a re-prompt).
+      const statePath = join(stateDir, 'silent-end-pending.json')
+      expect(existsSync(statePath)).toBe(true)
+      const state = JSON.parse(readFileSync(statePath, 'utf8'))
+      expect(state.retryCount).toBe(0)
+      expect(state.turnKey).toBe('111:_')
+      expect(state.pendingText).toBe('A'.repeat(300))
+    })
+
+    it('zero-reply ≥200 + STALE/missing heartbeat → BLOCK (never allow into a possibly-dead gateway)', () => {
+      // No heartbeat file → the liveness gate forces today's BLOCK behaviour.
+      const transcript = writeTranscript(tmp, [
+        ENQUEUE,
+        { type: 'assistant', message: { content: [{ type: 'text', text: 'A'.repeat(300) }] } },
+      ])
+      const r = runHook({ event: { session_id: 's1', transcript_path: transcript }, stateDir })
+      expect(r.status).toBe(0)
+      expect(JSON.parse(r.stdout).decision).toBe('block')
+      const state = JSON.parse(readFileSync(join(stateDir, 'silent-end-pending.json'), 'utf8'))
+      expect(state.retryCount).toBe(1)
+    })
+
+    it('retryCount>0 (prior failed delivery) + fresh heartbeat → BLOCK (preserve #3228 send-failure net)', () => {
+      writeFreshHeartbeat()
+      // Seed a prior state file with retryCount=1 (a delivery already failed).
+      writeFileSync(
+        join(stateDir, 'silent-end-pending.json'),
+        JSON.stringify({ chatId: '111', threadId: null, turnKey: '111:_', retryCount: 1, timestamp: Date.now() }),
+        'utf8',
+      )
+      const transcript = writeTranscript(tmp, [
+        ENQUEUE,
+        { type: 'assistant', message: { content: [{ type: 'text', text: 'A'.repeat(300) }] } },
+      ])
+      const r = runHook({ event: { session_id: 's1', transcript_path: transcript }, stateDir })
+      expect(r.status).toBe(0)
+      // retryCount was 1 → not the exhaustion boundary (MAX=2) → still blocks,
+      // and the election does NOT allow (retry-ladder-in-flight).
+      expect(JSON.parse(r.stdout).decision).toBe('block')
+    })
+  })
 })