switchroom 0.18.24 → 0.18.26

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

@@ -0,0 +1,205 @@
+import { describe, it, expect } from "vitest";
+import { guardAccidentalEmphasis } from "../../render/emphasis-guard.js";
+
+// Any U+1D400–U+1D7FF codepoint would be a mathematical-alphanumeric glyph; the
+// source never emits them — kept as a canary that the guard adds none.
+const MATH_GLYPH = /[\u{1D400}-\u{1D7FF}]/u;
+
+/** Strip defusing backslashes so we can assert the reader-visible/copy text is
+ *  byte-identical to the original prose. */
+function copyText(s: string): string {
+  return s.replace(/\\([_*])/g, "$1");
+}
+
+describe("guardAccidentalEmphasis (#3252) — accidental emphasis IS neutralised", () => {
+  it("escapes intra-word underscores in a snake_case identifier", () => {
+    const out = guardAccidentalEmphasis("the var is file_name_here in scope");
+    // No unescaped intra-word `_` remains to pair into an italic span.
+    expect(out).toContain("file\\_name\\_here");
+    expect(copyText(out)).toBe("the var is file_name_here in scope");
+  });
+
+  it("escapes intra-word asterisks in inline multiplication `a*b*c`", () => {
+    const out = guardAccidentalEmphasis("compute a*b*c for the product");
+    expect(out).toContain("a\\*b\\*c");
+    expect(copyText(out)).toBe("compute a*b*c for the product");
+  });
+
+  it("escapes digit-flanked `2*3*4` multiplication (2+ asterisks can pair)", () => {
+    const out = guardAccidentalEmphasis("the area is 2*3*4 units");
+    expect(out).toContain("2\\*3\\*4");
+  });
+
+  it("escapes a mixed digit/letter intra-word underscore run `v2_final_rc`", () => {
+    const out = guardAccidentalEmphasis("ship v2_final_rc today");
+    expect(out).toContain("v2\\_final\\_rc");
+  });
+
+  it("adds no math-italic glyphs", () => {
+    expect(guardAccidentalEmphasis("file_name_here and a*b")).not.toMatch(MATH_GLYPH);
+  });
+});
+
+describe("guardAccidentalEmphasis (#3252) — intended emphasis is LEFT UNTOUCHED (the critical no-false-positive cases)", () => {
+  it("leaves `**bold**` verbatim", () => {
+    const s = "this is **bold** text";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("leaves `*italic*` verbatim", () => {
+    const s = "this is *italic* text";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("leaves `_italic_` verbatim", () => {
+    const s = "this is _italic_ text";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("leaves a multi-word `*italic phrase*` verbatim (boundary-flanked delimiters)", () => {
+    const s = "please read *the whole thing* carefully";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("leaves `**bold**` and `_italic_` mixed in one line verbatim", () => {
+    const s = "**Header** then _emphasis_ and more **bold**";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("leaves an intended italic that WRAPS a glob (`*.ts is a glob*`) verbatim", () => {
+    // The opening `*` is boundary-flanked (space before, `.` after) → not
+    // intra-word → deliberately left alone so the intended italic survives.
+    const s = "note: *.ts is a glob* pattern";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("leaves a leading-underscore identifier `_private` verbatim (indistinguishable from italic)", () => {
+    const s = "the _private field and _internal state";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("leaves space-flanked operators (`3 * 4`) verbatim — GFM cannot emphasise them", () => {
+    const s = "the product 3 * 4 equals 12";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("leaves a bare trailing glob (`rm *`) verbatim", () => {
+    const s = "run rm * to clear the dir";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("leaves a lone glob (`*.ts`) verbatim", () => {
+    const s = "match *.ts files only";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+});
+
+describe("guardAccidentalEmphasis (#3252) — pair threshold (finding 4)", () => {
+  // A single delimiter in the whole message can NEVER form an emphasis pair, so
+  // a lone intra-word `_`/`*` is provably inert and is left byte-identical.
+  it("leaves a LONE intra-word underscore `file_name` verbatim (can't pair)", () => {
+    const s = "the var is file_name in scope";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("leaves a LONE intra-word asterisk `2*3` verbatim (can't pair)", () => {
+    const s = "the area is 2*3 units";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("STILL escapes a lone intra-word `_` when a later `_italic_` gives it a pair", () => {
+    // Three underscores total (one intra-word + an intended `_italic_`); Telegram
+    // could mis-pair them, so the intra-word `_` MUST be escaped even though it is
+    // the only intra-word one. Threshold 2 (total count) catches this correctly.
+    const out = guardAccidentalEmphasis("the file_name and _italic_ here");
+    expect(out).toContain("file\\_name");
+    // The intended italic delimiters (boundary-flanked) are left untouched.
+    expect(out).toContain("_italic_");
+  });
+});
+
+describe("guardAccidentalEmphasis (#3252) — link / autolink awareness (finding 1)", () => {
+  it("does NOT escape intra-word `_` inside a markdown link destination", () => {
+    const s = "see [docs](https://x.io/a_b_c_d) for more";
+    // URL underscores are structural → passed through UNMODIFIED.
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("does NOT escape `_` inside a bare autolinked URL", () => {
+    const s = "read https://x.io/foo_bar_baz now";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("STILL guards the link LABEL prose while protecting the URL", () => {
+    const out = guardAccidentalEmphasis("[file_name_here](https://x.io/a_b_c)");
+    // Label (rendered prose) is escaped; the `(url)` destination is verbatim.
+    expect(out).toContain("[file\\_name\\_here]");
+    expect(out).toContain("(https://x.io/a_b_c)");
+  });
+
+  it("protects a link destination WITH a title", () => {
+    const s = 'see [docs](https://x.io/a_b_c "the_title") now';
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+});
+
+describe("guardAccidentalEmphasis (#3252) — trailing-alnum emphasis closer (finding 5)", () => {
+  // `*cat*s` / `_cat_s`: the closing delimiter is intra-word (t*s / t_s). Under
+  // strict CommonMark it cannot close emphasis, but Telegram may be more liberal
+  // (UAT-gated). Documented current behaviour: the intra-word closer is escaped
+  // (2 asterisks/underscores total → armed). Copy-round-trips to the original.
+  it("escapes the intra-word closer of `*cat*s`", () => {
+    const out = guardAccidentalEmphasis("a *cat*s tail");
+    expect(out).toContain("*cat\\*s");
+    expect(copyText(out)).toBe("a *cat*s tail");
+  });
+
+  it("escapes the intra-word closer of `_cat_s`", () => {
+    const out = guardAccidentalEmphasis("a _cat_s tail");
+    expect(out).toContain("_cat\\_s");
+    expect(copyText(out)).toBe("a _cat_s tail");
+  });
+});
+
+describe("guardAccidentalEmphasis (#3252) — code-span awareness", () => {
+  it("never touches intra-word `_`/`*` inside a code span", () => {
+    const s = "the identifier `file_name_here` and math `a*b*c` are code";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("escapes prose but leaves an adjacent code span verbatim", () => {
+    // Two intra-word underscores in prose (`file_name_here`) → armed; the code
+    // span's `file_name` is verbatim and does NOT count toward the threshold.
+    const out = guardAccidentalEmphasis("prose file_name_here but code `file_name`");
+    expect(out).toContain("file\\_name\\_here but code `file_name`");
+  });
+
+  it("never touches intra-word delimiters inside a fenced code block", () => {
+    const s = "```\nfoo_bar = a*b*c\n```\ntail";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+});
+
+describe("guardAccidentalEmphasis (#3252) — no-op & idempotency", () => {
+  it("is a strict no-op when there is no `_` or `*` at all", () => {
+    const s = "a plain sentence with no delimiters at all";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("is a strict no-op when the only `_`/`*` are intended emphasis", () => {
+    const s = "**bold** and _italic_ only";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+
+  it("is idempotent: guarding already-guarded text is a strict no-op", () => {
+    const once = guardAccidentalEmphasis("file_name_here and a*b");
+    expect(guardAccidentalEmphasis(once)).toBe(once);
+    expect(once).not.toContain("\\\\_"); // never a doubled backslash
+    expect(once).not.toContain("\\\\*");
+  });
+
+  it("does not double-escape a pre-escaped `\\_` intra-word delimiter", () => {
+    const s = "file\\_name here";
+    expect(guardAccidentalEmphasis(s)).toBe(s);
+  });
+});

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

@@ -0,0 +1,138 @@
+import { describe, it, expect } from "vitest";
+import { guardAccidentalFormatting, richMessage } from "../../rich-send.js";
+
+// Any U+1D400–U+1D7FF codepoint = a mathematical-alphanumeric glyph (what a
+// `$…$` math span typesets to on the reader's screen).
+const MATH_GLYPH = /[\u{1D400}-\u{1D7FF}]/u;
+
+/** Strip the defusing backslashes so we can assert the reader-visible / copied
+ *  text is byte-identical to the original ASCII. */
+function copyText(s: string): string {
+  return s.replace(/\\([$_*>.~=|])/g, "$1");
+}
+
+// The composed seam guard (#3252): guardAccidentalEmphasis →
+// guardAccidentalBlockConstructs → guardAccidentalInlinePairs → guardDollarMath.
+// These tests prove the guards COMPOSE without one guard's inserted backslash
+// creating or destroying a signal for another — the interference question.
+describe("guardAccidentalFormatting composition (#3252)", () => {
+  it("neutralises a message that trips emphasis + dollar + tilde at once", () => {
+    // `file_name_here` (2 intra-word `_` → can pair), `~$5M … ~$10M`
+    // (digit-adjacent tildes AND a two-dollar currency span) — three guards fire.
+    const src = "the file_name_here budget trims ~$5M, down from ~$10M last year";
+    const out = guardAccidentalFormatting(src);
+    // Emphasis: the intra-word underscores are escaped (no `_…_` pair).
+    expect(out).toContain("file\\_name\\_here");
+    // Dollar: no unescaped `$` remains to open a math span.
+    expect(out).not.toMatch(/(?<!\\)\$/);
+    // Tilde: BOTH approximation tildes escaped so no `~…~` strikethrough forms.
+    // This is the interference case — dollar runs last so its `\$` never hides
+    // the digit-adjacent tildes from the inline-pairs guard.
+    expect(out).not.toMatch(/(?<!\\)~/);
+    expect(out).toContain("\\~\\$5M");
+    expect(out).toContain("\\~\\$10M");
+    // No math glyphs, and stripping the defusers yields the original prose.
+    expect(out).not.toMatch(MATH_GLYPH);
+    expect(copyText(out)).toBe(src);
+  });
+
+  it("handles a line-start blockquote + operator-mark + dollar body", () => {
+    const src = ">2x growth means x==y and a==b while spend hit $40 and $80";
+    const out = guardAccidentalFormatting(src);
+    // Line-start `>2x` blockquote-promotion escaped.
+    expect(out).toContain("\\>2x");
+    // Both `==` operators neutralised (word-flanked → not intended ==mark==).
+    expect(out).toContain("x\\=\\=y");
+    expect(out).toContain("a\\=\\=b");
+    // Dollars escaped.
+    expect(out).not.toMatch(/(?<!\\)\$/);
+    expect(copyText(out)).toBe(src);
+  });
+
+  it("leaves a 4-digit-year accidental ordered-list alone except the dot", () => {
+    const src = "2026. was the year the file_name_here convention changed";
+    const out = guardAccidentalFormatting(src);
+    expect(out).toContain("2026\\. was");
+    expect(out).toContain("file\\_name\\_here");
+  });
+
+  it("never touches DELIBERATE formatting: bold, italic, strike, code, blockquote", () => {
+    const src =
+      "**bold** and *italic* and _under_ and ~~strike~~ and `a_b*c` and\n> real quote";
+    // No accidental signal anywhere → strict no-op.
+    expect(guardAccidentalFormatting(src)).toBe(src);
+  });
+
+  it("never touches content inside code spans / fenced blocks", () => {
+    const src =
+      "prose $10 and $20 but the snippet `x==y && file_name ~5` stays verbatim";
+    const out = guardAccidentalFormatting(src);
+    expect(out).toContain("`x==y && file_name ~5`");
+    // Prose dollars still escaped outside the code span.
+    expect(out).not.toMatch(/(?<!\\)\$(?=\d)/);
+  });
+
+  it("is idempotent: composing already-composed text is a strict no-op", () => {
+    const src = "file_name_here ~$5M and ~$10M with x==y and a==b, >2x, 2026. done";
+    const once = guardAccidentalFormatting(src);
+    expect(guardAccidentalFormatting(once)).toBe(once);
+    // No doubled backslashes anywhere.
+    expect(once).not.toMatch(/\\\\/);
+  });
+
+  it("passes a markdown link with a `_`/`~`/`==`-laden URL through UNMODIFIED (finding 1)", () => {
+    const src = "see [docs](https://x.io/a_b_c?p==1&q~2) and [more](https://y.io/foo_bar)";
+    // Every trigger char in the URL is structural → the whole body is verbatim.
+    expect(guardAccidentalFormatting(src)).toBe(src);
+  });
+
+  it("passes a bare autolinked URL through UNMODIFIED (finding 1)", () => {
+    const src = "read https://en.wikipedia.org/wiki/Foo_Bar_Baz today";
+    expect(guardAccidentalFormatting(src)).toBe(src);
+  });
+
+  it("guards the link LABEL but protects the destination (finding 1)", () => {
+    const out = guardAccidentalFormatting("[a_b_c](https://x.io/p_q_r) spent $5 and $9");
+    // Label prose escaped; URL verbatim; prose dollars still escaped.
+    expect(out).toContain("[a\\_b\\_c]");
+    expect(out).toContain("(https://x.io/p_q_r)");
+    expect(out).not.toMatch(/(?<!\\)\$/);
+  });
+
+  it("passes a GFM table with empty cells through UNMODIFIED (finding 3)", () => {
+    // A real table (has a delimiter row) — its structural pipes/empty cells and
+    // any `_`/`$` inside cells must survive. `|a||b|` = a real empty cell.
+    const src = ["| A | B | C |", "| --- | --- | --- |", "|a||b||c|", "| x_y | $5 | ~3 |"].join("\n");
+    expect(guardAccidentalFormatting(src)).toBe(src);
+  });
+
+  it("STILL guards a genuine accidental `a||b` in prose (not a table)", () => {
+    // Two word-flanked `||` in PROSE (no delimiter row) → armed spoiler guard.
+    const out = guardAccidentalFormatting("logic is a||b and c||d here");
+    expect(out).toContain("a\\|\\|b");
+    expect(out).toContain("c\\|\\|d");
+  });
+
+  // FINDING 2 (documented non-issue): switchroom's IR renderer emits code
+  // blocks ONLY as backtick FENCES (render.ts renderCodeBlock), never as
+  // 4-space-indented CommonMark code. So renderer output reaching richMessage()
+  // never contains an indented code block. The emphasis/inline-pairs/dollar
+  // guards therefore do NOT special-case a 4-space indent (only line-start does,
+  // for its own blockquote/list heuristics). This test PINS that current
+  // behaviour: a 4-space-indented prose line is treated as ordinary prose and
+  // its currency `$` is guarded like any other. (If a future change ever routes
+  // raw indented code blocks to the wire, revisit — see guards-integration-note.)
+  it("treats a 4-space-indented line as prose (finding 2 — renderer emits fences, not indented code)", () => {
+    const out = guardAccidentalFormatting("    spend was $5 and $10 total");
+    expect(out).toContain("\\$5");
+    expect(out).toContain("\\$10");
+  });
+
+  it("richMessage() applies the composed guard on the wire body exactly once", () => {
+    const src = "file_name spend ~$5M vs ~$10M, x==y";
+    const wire = richMessage(src);
+    expect(wire.markdown).toBe(guardAccidentalFormatting(src));
+    // And re-wrapping (streaming re-render) is byte-stable.
+    expect(richMessage(wire.markdown).markdown).toBe(wire.markdown);
+  });
+});

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);
+  });
+});