switchroom 0.19.4 → 0.19.6

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/narrative-lane-golden.test.ts

@@ -371,7 +371,8 @@ function makeSendReplyDeps(dedup: OutboundDedupCache) {
     assertSendable: () => {},
     statusKey: key,
     streamKey: key,
-    resolveReplyOwnerTurn: () => null,
+    resolveReplyOwnerTurn: () => ({ turn: null, tier: 'none' as const }),
+    getLastSubagentHandbackAt: () => null,
     findTurnByOriginId: () => null,
     findTurnByQuotedMessageId: () => null,
     resolveAnswerThreadWithLog: (_c: string, explicit: number | undefined) => explicit,

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/reply-owner-resolve.test.ts

@@ -32,6 +32,7 @@
 import { describe, it, expect } from 'vitest'
 import {
   resolveReplyOwnerTurnId,
+  resolveReplyOwnerTier,
   decideAnswerLatchSuppression,
   type ReplyOwnerCandidates,
   type AnswerDeliveredLatch,
@@ -611,3 +612,76 @@ describe('#3429 — flush-armed latch with content evidence', () => {
     ).toBe(false)
   })
 })
+
+/**
+ * `resolveReplyOwnerTier` (fix/backstop-duplicate-reply) exposes WHICH precedence
+ * tier won, so the gateway can apply the #3429 content gate ONLY on the ambiguous
+ * `latest-ended` fallback. It shares one precedence with `resolveReplyOwnerTurnId`
+ * (asserted equivalent below), so the winning id and the winning tier can never
+ * disagree.
+ */
+describe('resolveReplyOwnerTier — precedence + latest-ended TTL bound', () => {
+  const base: ReplyOwnerCandidates = {
+    liveTurnId: null,
+    originTurnId: null,
+    quotedTurnId: null,
+    latestEndedTurnId: null,
+  }
+
+  it('live wins over every lower tier', () => {
+    expect(
+      resolveReplyOwnerTier({ ...base, liveTurnId: 'L', originTurnId: 'O', quotedTurnId: 'Q', latestEndedTurnId: 'E' }),
+    ).toBe('live')
+  })
+
+  it('origin wins when no live turn', () => {
+    expect(resolveReplyOwnerTier({ ...base, originTurnId: 'O', quotedTurnId: 'Q', latestEndedTurnId: 'E' })).toBe('origin')
+  })
+
+  it('quoted wins when no live/origin turn (the positive DM recovery tier)', () => {
+    expect(resolveReplyOwnerTier({ ...base, quotedTurnId: 'Q', latestEndedTurnId: 'E' })).toBe('quoted')
+  })
+
+  it('latest-ended is the ambiguous FALLBACK when only it resolves', () => {
+    expect(resolveReplyOwnerTier({ ...base, latestEndedTurnId: 'E' })).toBe('latest-ended')
+  })
+
+  it('none when every lookup missed', () => {
+    expect(resolveReplyOwnerTier(base)).toBe('none')
+  })
+
+  it('a STALE latest-ended (age > TTL) is NOT accepted → none, never latest-ended', () => {
+    const stale: ReplyOwnerCandidates = {
+      ...base,
+      latestEndedTurnId: 'E',
+      latestEndedAgeMs: DEFAULT_SUPERSEDE_TTL_MS + 1,
+      latestEndedTtlMs: DEFAULT_SUPERSEDE_TTL_MS,
+    }
+    expect(resolveReplyOwnerTier(stale)).toBe('none')
+    // And the id resolver agrees (no destructive authority granted to a stale turn).
+    expect(resolveReplyOwnerTurnId(stale)).toBe(null)
+  })
+
+  it('tier and id resolver share one precedence for every candidate shape', () => {
+    const shapes: ReplyOwnerCandidates[] = [
+      base,
+      { ...base, liveTurnId: 'L', quotedTurnId: 'Q', latestEndedTurnId: 'E' },
+      { ...base, originTurnId: 'O', latestEndedTurnId: 'E' },
+      { ...base, quotedTurnId: 'Q' },
+      { ...base, latestEndedTurnId: 'E' },
+    ]
+    const idForTier = (s: ReplyOwnerCandidates): string | null => {
+      switch (resolveReplyOwnerTier(s)) {
+        case 'live': return s.liveTurnId
+        case 'origin': return s.originTurnId
+        case 'quoted': return s.quotedTurnId
+        case 'latest-ended': return s.latestEndedTurnId
+        case 'none': return null
+      }
+    }
+    for (const s of shapes) {
+      // The id the winning tier points at equals what the id resolver returns.
+      expect(resolveReplyOwnerTurnId(s)).toBe(idForTier(s))
+    }
+  })
+})