switchroom 0.18.24 → 0.18.26

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

@@ -200,6 +200,91 @@ describe("handleModelCommand — show / help never inject (picker-wedge guard)",
   });
 });
 
+describe("handleModelCommand — set — #3241 poll-until-signal wiring", () => {
+  it("forwards successPattern + errorPattern + settleBeforeSendMs to the inject primitive", async () => {
+    const seen: Array<{ command: string; opts: unknown }> = [];
+    const { deps } = makeDeps({
+      inject: async (_agent, command, opts) => {
+        seen.push({ command, opts });
+        return okResult("⏺ Set model to Sonnet 5 for this session");
+      },
+    });
+    await handleModelCommand({ kind: "set", model: "sonnet" }, deps);
+    expect(seen).toHaveLength(1);
+    const opts = seen[0].opts as {
+      successPattern?: RegExp;
+      errorPattern?: RegExp;
+      settleBeforeSendMs?: number;
+    };
+    // A success pattern that matches claude's confirmation line, an error pattern
+    // that matches the "not found" line, and a clean-prompt pre-send wait.
+    expect(opts.successPattern?.test("⏺ Set model to Sonnet 5")).toBe(true);
+    expect(opts.errorPattern?.test("⎿  Model 'x' not found")).toBe(true);
+    expect(typeof opts.settleBeforeSendMs).toBe("number");
+    expect(opts.settleBeforeSendMs).toBeGreaterThan(0);
+  });
+
+  it("confirmation that lands after a banner → records the live model for /status", async () => {
+    // The inject primitive (poll-until-signal) is responsible for returning the
+    // confirmation and not the banner; here the handler receives that confirmation
+    // and must record it as the session override.
+    const { deps } = makeDeps({
+      inject: async () =>
+        okResult("⠋ extending Claude Fable 5 access…\n⎿  Set model to Fable 5 for this session"),
+    });
+    const reply = await handleModelCommand({ kind: "set", model: "fable" }, deps);
+    expect(reply.selectedModel).toBe("Fable 5");
+    expect(reply.optimistic).toBeUndefined();
+    expect(reply.text).toContain("Set model to Fable 5");
+    // The banner is scrollback and must not leak as prose above the confirmation.
+    expect(reply.text).not.toContain("extending Claude Fable 5 access");
+  });
+
+  it("scraped error line → failure verdict AND no override recorded (retract)", async () => {
+    const { deps } = makeDeps({
+      inject: async () => okResult("⎿  Model 'claude-bogus-99' not found"),
+    });
+    const reply = await handleModelCommand({ kind: "set", model: "claude-bogus-99" }, deps);
+    expect(reply.text).toContain("did not take");
+    expect(reply.selectedModel).toBeUndefined();
+    expect(reply.optimistic).toBeUndefined();
+  });
+
+  // #3242 review MEDIUM 1 — an access/entitlement denial must NOT be recorded
+  // optimistically. Each of these lines matches neither the confirmation prefix
+  // nor the OLD bad-id error regex, so before the widen they slipped into the
+  // optimistic branch and falsely recorded the switch.
+  for (const denial of [
+    "⎿  Fable is not available on your plan",
+    "⎿  access denied",
+    "⎿  Fable requires a Pro subscription",
+    "⎿  This model is not enabled for your account",
+    "⎿  No access to Fable on this tier",
+    "⎿  Fable 5 is currently unavailable",
+  ]) {
+    it(`access-denial line → failure verdict AND no override (retract): ${JSON.stringify(denial)}`, async () => {
+      const { deps } = makeDeps({ inject: async () => okResult(denial) });
+      const reply = await handleModelCommand({ kind: "set", model: "fable" }, deps);
+      expect(reply.text).toContain("did not take");
+      expect(reply.selectedModel).toBeUndefined();
+      expect(reply.optimistic).toBeUndefined();
+    });
+  }
+
+  it("a genuine confirmation is NEVER flipped to a failure by the widened denial regex", async () => {
+    // Confirmation-first ordering: even if scrollback in the same region says
+    // something "unavailable", a real "Set model to …" line wins.
+    const mixed = [
+      "the metrics endpoint was unavailable earlier",
+      "⎿  Set model to Fable 5 for this session",
+    ].join("\n");
+    const { deps } = makeDeps({ inject: async () => okResult(mixed) });
+    const reply = await handleModelCommand({ kind: "set", model: "fable" }, deps);
+    expect(reply.text).not.toContain("did not take");
+    expect(reply.selectedModel).toBe("Fable 5");
+  });
+});
+
 describe("handleModelCommand — set", () => {
   it("injects exactly `/model <name>` once and relays a genuine confirmation + persistence note", async () => {
     const { deps, calls } = makeDeps();
@@ -228,13 +313,17 @@ describe("handleModelCommand — set", () => {
     expect(reply.text).not.toContain("summary you asked for");
     expect(reply.text).not.toContain("rollback plan");
     expect(reply.text).not.toContain("<pre>");
-    // No confirmation line was captured, so the switch is UNVERIFIED — report it
-    // honestly (never a false "switched") and record NO session override.
+    // #3241 part B — poll-until-signal already waited the full window, so a
+    // missing confirmation line with NO scraped error is a SILENT switch, not a
+    // failure. Record the requested model optimistically so /status is right,
+    // and say so honestly (no false "switched (session)", no scrollback leak).
     expect(reply.text).toContain("/model fable");
-    expect(reply.text).toContain("couldn't confirm the switch");
+    expect(reply.text).toContain("couldn't read a confirmation");
     expect(reply.text).toContain("/status");
+    expect(reply.text).not.toContain("Recorded");
     expect(reply.text).not.toContain("switched (session)");
-    expect(reply.selectedModel).toBeUndefined();
+    expect(reply.selectedModel).toBe("Fable");
+    expect(reply.optimistic).toBe(true);
     expect(reply.html).toBe(true);
   });
 
@@ -260,15 +349,17 @@ describe("handleModelCommand — set", () => {
     const { deps } = makeDeps({ inject: async () => okResult(prose) });
     const reply = await handleModelCommand({ kind: "set", model: "fable" }, deps);
     // The anchored regex rejects all three lines, so nothing leaks and there is
-    // no <pre> block. With no confirmation captured, the switch is UNVERIFIED —
-    // report it honestly, never a false "switched".
+    // no <pre> block. No confirmation AND no scraped error → #3241 optimistic
+    // record: the switch is reported as sent + recorded, never a false
+    // "switched", and no scrollback prose leaks.
     expect(reply.text).not.toContain("<pre>");
     expect(reply.text).not.toContain("switched the deploy");
     expect(reply.text).not.toContain("set model behaviour");
     expect(reply.text).not.toContain("kept model changes");
-    expect(reply.text).toContain("couldn't confirm the switch");
+    expect(reply.text).toContain("couldn't read a confirmation");
     expect(reply.text).not.toContain("switched (session)");
-    expect(reply.selectedModel).toBeUndefined();
+    expect(reply.selectedModel).toBe("Fable");
+    expect(reply.optimistic).toBe(true);
     expect(reply.html).toBe(true);
   });
 
@@ -290,7 +381,13 @@ describe("handleModelCommand — set", () => {
       }),
     });
     const reply = await handleModelCommand({ kind: "set", model: "sonnet" }, deps);
-    expect(reply.text).toContain("no response captured");
+    // #3241 part B — an empty capture can't carry an error line, so the send is
+    // treated as a silent switch and the requested model is recorded
+    // optimistically (was: "no response captured", recorded nothing).
+    expect(reply.text).toContain("couldn't read a confirmation");
+    expect(reply.text).toContain("/status");
+    expect(reply.selectedModel).toBe("Sonnet");
+    expect(reply.optimistic).toBe(true);
   });
 
   it("session_missing failure surfaces the tmux-supervisor hint", async () => {
@@ -475,9 +572,12 @@ describe("handleModelCommand — busy gate + honest unverified reporting", () =>
     const reply = await handleModelCommand({ kind: "set", model: "opus" }, deps);
     expect(reply.text).not.toContain("did not take");
     expect(reply.text).not.toContain("model not found");
-    // No confirmation either → honest unverified message, nothing recorded.
-    expect(reply.text).toContain("couldn't confirm the switch");
-    expect(reply.selectedModel).toBeUndefined();
+    // No LINE-ANCHORED error and no confirmation → #3241 optimistic record: the
+    // mid-sentence "model not found" prose does NOT flip the switch to a failure,
+    // and the requested model is recorded (was: "couldn't confirm", nothing).
+    expect(reply.text).toContain("couldn't read a confirmation");
+    expect(reply.selectedModel).toBe("Opus");
+    expect(reply.optimistic).toBe(true);
   });
 
   it("recognises claude v2.1.205's real arg-form confirmation (⎿ glyph + 'and saved as your default')", async () => {
@@ -713,6 +813,7 @@ import {
   EXTRA_CLAUDE_ALIASES,
   externalModelNames,
   isSrToClaudeTransition,
+  optimisticModelRecordLabel,
   type ModelMenuDeps,
 } from "../gateway/model-command.js";
 import { labelTag } from "../../src/agents/model-picker.js";
@@ -909,6 +1010,62 @@ describe("handleModelMenuCallback", () => {
   });
 });
 
+// #3242 review MEDIUM 2 — the alias BUTTON (mdl:alias:<alias>, e.g. the Fable
+// button) must be symmetric with the typed set path: record-on-send / retract-
+// on-scraped-error, handling BOTH ok and ok_no_output. Before the fix a silent
+// successful button-switch (ok_no_output, or ok with no confirmation line) fell
+// through to "Switch failed" and dropped the override.
+describe("handleModelMenuCallback — alias button symmetry (#3242 MEDIUM 2)", () => {
+  it("ok_no_output (silent switch via the button) → optimistic record, not a failure", async () => {
+    const { deps } = makeMenuDeps({
+      inject: async () => ({
+        outcome: "ok_no_output" as const,
+        output: "",
+        truncated: false,
+        command: "/model",
+        meta: { description: "Open model picker", expectsOutput: true },
+      }),
+    });
+    const out = await handleModelMenuCallback(`${MODEL_CALLBACK_ALIAS}fable`, deps);
+    expect(out.selectedModel).toBe("Fable"); // normalized display form
+    expect(out.selectedModelToken).toBe("fable");
+    // Provisional copy (#3242 FIX 2): doesn't assert the switch succeeded, points
+    // at /status, and never reads as a failure.
+    expect(out.reply.text).not.toContain("failed");
+    expect(out.reply.text).toContain("/status");
+    expect(out.reply.text).toContain("/model fable");
+  });
+
+  it("ok with no confirmation line (banner-only) → optimistic record", async () => {
+    const { deps } = makeMenuDeps({
+      inject: async () => okResult("⠋ extending Claude Fable 5 access…"),
+    });
+    const out = await handleModelMenuCallback(`${MODEL_CALLBACK_ALIAS}fable`, deps);
+    expect(out.selectedModel).toBe("Fable");
+    expect(out.selectedModelToken).toBe("fable");
+    // The banner must not leak as the confirmation.
+    expect(out.reply.text).not.toContain("extending Claude Fable 5 access");
+  });
+
+  it("scraped access-denial line via the button → failure, no override (retract)", async () => {
+    const { deps } = makeMenuDeps({
+      inject: async () => okResult("⎿  Fable is not available on your plan"),
+    });
+    const out = await handleModelMenuCallback(`${MODEL_CALLBACK_ALIAS}fable`, deps);
+    expect(out.selectedModel).toBeUndefined();
+    expect(out.reply.text).toContain("did not take");
+  });
+
+  it("genuine confirmation via the button still records the display name", async () => {
+    const { deps } = makeMenuDeps({
+      inject: async () => okResult("⎿  Set model to Fable 5 for this session"),
+    });
+    const out = await handleModelMenuCallback(`${MODEL_CALLBACK_ALIAS}fable`, deps);
+    expect(out.selectedModel).toBe("Fable 5");
+    expect(out.selectedModelToken).toBe("fable");
+  });
+});
+
 describe("sessionModelFromConfirmation", () => {
   it("pulls the model name from claude's session-switch confirmation", () => {
     expect(sessionModelFromConfirmation("Set model to Fable 5 for this session only")).toBe("Fable 5");
@@ -1170,6 +1327,26 @@ describe("isSrToClaudeTransition", () => {
     expect(isSrToClaudeTransition("sr-gemini-2.5-pro", "sr-deepseek-r1")).toBe(false);
   });
 
+  // #3242 review FIX 1 — optimisticModelRecordLabel must NOT de-prefix an sr-*
+  // token: the stored selectedModel doubles as the sr-*→Claude sentinel that
+  // isSrToClaudeTransition (prevModel.startsWith('sr-')) reads. De-prefixing to
+  // a friendly label ("kimi k2") would silently kill the graceful restart that
+  // tears down LiteLLM routing on a subsequent Claude switch.
+  it("optimisticModelRecordLabel keeps sr-* tokens verbatim so the sentinel survives", () => {
+    const recorded = optimisticModelRecordLabel("sr-kimi-k2");
+    expect(recorded).toBe("sr-kimi-k2"); // NOT "kimi k2"
+    // The recorded value still trips the sr→Claude transition on a later switch.
+    expect(isSrToClaudeTransition(recorded, "opus")).toBe(true);
+    // Regression guard: the de-prefixed form would NOT — that was the bug.
+    expect(isSrToClaudeTransition("kimi k2", "opus")).toBe(false);
+  });
+
+  it("optimisticModelRecordLabel Title-cases a bare Claude alias, leaves full ids as-is", () => {
+    expect(optimisticModelRecordLabel("fable")).toBe("Fable");
+    expect(optimisticModelRecordLabel("opus")).toBe("Opus");
+    expect(optimisticModelRecordLabel("claude-opus-4-8")).toBe("claude-opus-4-8");
+  });
+
   it("false when switching to sr-* from Claude (Claude → sr-*)", () => {
     expect(isSrToClaudeTransition("Sonnet", "sr-gemini-2.5-pro")).toBe(false);
   });

package/telegram-plugin/tests/redelivery-decision.test.ts

@@ -0,0 +1,84 @@
+import { describe, it, expect } from 'vitest'
+import {
+  decideRedeliver,
+  frameRedelivery,
+  REDELIVERY_PREFIX,
+  type RedeliverDecisionInput,
+} from '../gateway/redelivery-decision.js'
+
+/**
+ * Pins the crash-survival redelivery decision predicate. The load-bearing
+ * property is the DURABLE TEXT-IDENTITY oracle: an interim `progress_update`
+ * earlier in the same turn must NOT suppress a genuinely-undelivered final
+ * answer (the exact MISS = permanent-silence bug this fix closes), while an
+ * already-delivered final answer MUST be suppressed.
+ */
+
+const base: RedeliverDecisionInput = {
+  capturedText: 'The deploy finished — all three services are green.',
+  trailingIsText: true,
+  hasDeliveredText: false,
+  alreadyRedelivered: false,
+  ageMs: 60_000,
+  maxAgeMs: 10_800_000, // 3h
+}
+
+describe('decideRedeliver — text-identity oracle', () => {
+  it('REDELIVERS an undelivered final answer even when an interim message was sent (the MISS bug)', () => {
+    // The MISS scenario: a progress_update landed a role=assistant row earlier
+    // in the turn, so a chat+time-window oracle would say "delivered" and skip.
+    // The text-identity oracle keys on the ANSWER text — which was never sent —
+    // so hasDeliveredText is false and redelivery fires.
+    const d = decideRedeliver({ ...base, hasDeliveredText: false })
+    expect(d.redeliver).toBe(true)
+    expect(d.framedText).toContain(base.capturedText)
+    expect(d.framedText?.startsWith(REDELIVERY_PREFIX)).toBe(true)
+  })
+
+  it('SUPPRESSES when the final answer text was already delivered', () => {
+    const d = decideRedeliver({ ...base, hasDeliveredText: true })
+    expect(d.redeliver).toBe(false)
+    expect(d.skipReason).toBe('already-delivered')
+  })
+})
+
+describe('decideRedeliver — other skip reasons', () => {
+  it('skips empty / whitespace text', () => {
+    expect(decideRedeliver({ ...base, capturedText: '   ' }).skipReason).toBe('empty-text')
+  })
+
+  it('skips when trailing content is a dangling tool_use (mid-stream, not an answer)', () => {
+    expect(decideRedeliver({ ...base, trailingIsText: false }).skipReason).toBe('trailing-not-text')
+  })
+
+  it('skips an already-redelivered turn (at-most-once ledger)', () => {
+    expect(decideRedeliver({ ...base, alreadyRedelivered: true }).skipReason).toBe('already-redelivered')
+  })
+
+  it('skips a stale turn beyond maxAgeMs', () => {
+    expect(decideRedeliver({ ...base, ageMs: 4 * 3_600_000 }).skipReason).toBe('stale')
+  })
+
+  it('precedence: empty-text wins over delivered/redelivered/stale', () => {
+    const d = decideRedeliver({
+      ...base,
+      capturedText: '',
+      hasDeliveredText: true,
+      alreadyRedelivered: true,
+      ageMs: 999_999_999,
+    })
+    expect(d.skipReason).toBe('empty-text')
+  })
+
+  it('precedence: already-redelivered is checked before the age failsafe', () => {
+    const d = decideRedeliver({ ...base, alreadyRedelivered: true, ageMs: 999_999_999 })
+    expect(d.skipReason).toBe('already-redelivered')
+  })
+})
+
+describe('frameRedelivery', () => {
+  it('frames as a recovered draft, never a clean final answer', () => {
+    const framed = frameRedelivery('  hello world  ')
+    expect(framed).toBe(`${REDELIVERY_PREFIX}\n\nhello world`)
+  })
+})

package/telegram-plugin/tests/registry-turns.test.ts

@@ -20,6 +20,8 @@ import {
   markOrphanedWithTimeoutClassification,
   findLatestTurnIfInterrupted,
   markTurnResumed,
+  markAnswerRedelivered,
+  stampTurnSessionId,
   getTurnByKey,
 } from '../registry/turns-schema.js'
 
@@ -574,3 +576,52 @@ describe('markTurnResumed', () => {
     db.close()
   })
 })
+
+// ---------------------------------------------------------------------------
+// stampTurnSessionId + markAnswerRedelivered — crash-survival redelivery
+// ---------------------------------------------------------------------------
+
+describe('stampTurnSessionId', () => {
+  it('pins the session id on the turn (first-write-wins) and defaults null', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'sx:1', chatId: 'sx' })
+    expect(getTurnByKey(db, 'sx:1')!.session_id).toBeNull()
+    stampTurnSessionId(db, 'sx:1', 'sess-abc')
+    expect(getTurnByKey(db, 'sx:1')!.session_id).toBe('sess-abc')
+    // first-write-wins: a later different session id does not overwrite
+    stampTurnSessionId(db, 'sx:1', 'sess-def')
+    expect(getTurnByKey(db, 'sx:1')!.session_id).toBe('sess-abc')
+    db.close()
+  })
+
+  it('ignores an empty session id and no-ops on unknown key', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'sx:2', chatId: 'sx' })
+    stampTurnSessionId(db, 'sx:2', '')
+    expect(getTurnByKey(db, 'sx:2')!.session_id).toBeNull()
+    expect(() => stampTurnSessionId(db, 'nope', 'x')).not.toThrow()
+    db.close()
+  })
+})
+
+describe('markAnswerRedelivered', () => {
+  it('stamps answer_redelivered_at (first-write-wins) on a SEPARATE marker from resumed_at', () => {
+    const db = openTurnsDbInMemory()
+    recordTurnStart(db, { turnKey: 'rd:1', chatId: 'rd' })
+    recordTurnEnd(db, { turnKey: 'rd:1', endedVia: 'restart' })
+    expect(getTurnByKey(db, 'rd:1')!.answer_redelivered_at).toBeNull()
+    markAnswerRedelivered(db, 'rd:1', 1_700_000_000_000)
+    expect(getTurnByKey(db, 'rd:1')!.answer_redelivered_at).toBe(1_700_000_000_000)
+    // does not touch resumed_at — the two ledgers are independent
+    expect(getTurnByKey(db, 'rd:1')!.resumed_at).toBeNull()
+    markAnswerRedelivered(db, 'rd:1', 1_800_000_000_000)
+    expect(getTurnByKey(db, 'rd:1')!.answer_redelivered_at).toBe(1_700_000_000_000)
+    db.close()
+  })
+
+  it('no-ops for an unknown turn_key', () => {
+    const db = openTurnsDbInMemory()
+    expect(() => markAnswerRedelivered(db, 'nope:1')).not.toThrow()
+    db.close()
+  })
+})

package/telegram-plugin/tests/render/dollar-math-guard.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect } from "vitest";
+import { guardDollarMath } from "../../render/dollar-math-guard.js";
+import { richMessage } from "../../rich-send.js";
+import { computeReplyChunks } from "../../gateway/outbound-send-path.js";
+import { RICH_MESSAGE_MAX_CHARS } from "../../format.js";
+
+// Any U+1D400–U+1D7FF codepoint = a mathematical-alphanumeric (math-italic /
+// math-bold) glyph — what a math renderer produces from a `$…$` span.
+const MATH_GLYPH = /[\u{1D400}-\u{1D7FF}]/u;
+
+/** Strip zero-width chars + defusing backslashes so we can assert the amount
+ *  the reader copies is byte-identical to the original ASCII currency token.
+ *  The wire body now flows through the composed richMessage guard, so besides
+ *  the dollar defuser (`\$`) it may also carry the inline-pairs defuser (`\~`)
+ *  for approximation tildes (`~$0.5M`) — strip both so the round-trip holds. */
+function copyText(s: string): string {
+  return s.replace(/[​⁠]/g, "").replace(/\\([$~])/g, "$1");
+}
+
+describe("guardDollarMath (#3252)", () => {
+  const OFFENDING =
+    "acquisition ceiling is ~$0.5-0.9M but nearly all in small dealers ... is ~$150-450k";
+
+  it("neutralises the two-dollar-amount currency string so no `$…$` span can form", () => {
+    const out = guardDollarMath(OFFENDING);
+    // Both currency dollars are backslash-escaped → no unescaped `$` remains to
+    // open/close a math span.
+    expect(out).not.toMatch(/(?<!\\)\$/);
+    expect(out).toContain("\\$0.5-0.9M");
+    expect(out).toContain("\\$150-450k");
+  });
+
+  it("carries no math-italic glyphs (switchroom never emits U+1D400-range)", () => {
+    expect(guardDollarMath(OFFENDING)).not.toMatch(MATH_GLYPH);
+    // …nor does the raw source; the guard is what keeps the WIRE bytes clean.
+    expect(OFFENDING).not.toMatch(MATH_GLYPH);
+  });
+
+  it("preserves the visible amounts: stripping the defuser yields the original", () => {
+    expect(copyText(guardDollarMath(OFFENDING))).toBe(OFFENDING);
+  });
+
+  it("is a strict no-op for a single `$digit` prose token", () => {
+    const s = "grab a $5 coffee on the way";
+    expect(guardDollarMath(s)).toBe(s);
+  });
+
+  it("is a strict no-op when there is no `$digit` at all", () => {
+    const s = "the cost is unknown but the $ sign appears twice: $ and $";
+    expect(guardDollarMath(s)).toBe(s);
+  });
+
+  it("never touches `$` inside a code span", () => {
+    const s = "shell math `$x = $y` is fine and `$z = $w` too";
+    // Two code spans, each with 2 `$digit`? No — non-digit. Use digits to prove
+    // code is skipped even when it WOULD otherwise trigger.
+    const withDigits = "compute `$1 + $2` and also `$3 + $4` inline";
+    expect(guardDollarMath(s)).toBe(s);
+    expect(guardDollarMath(withDigits)).toBe(withDigits);
+  });
+
+  it("escapes prose dollars but leaves an adjacent code span verbatim", () => {
+    const s = "prices $10 and $20 — the var is `$PRICE = $10`";
+    const out = guardDollarMath(s);
+    // Prose amounts escaped:
+    expect(out).toContain("\\$10 and \\$20");
+    // Code span verbatim (its `$10` NOT escaped):
+    expect(out).toContain("`$PRICE = $10`");
+  });
+
+  // ── F3: widened detection (trailing `$`, `$.50`, `$ ` with a bare gap) ────
+  it("escapes a mix of leading- and trailing-`$` amounts (`$50 or 50$`)", () => {
+    const out = guardDollarMath("It costs $50 or 50$ depending on the vendor");
+    // Both dollars gone from the unescaped set → no `$…$` pair can form.
+    expect(out).not.toMatch(/(?<!\\)\$/);
+    expect(out).toContain("\\$50 or 50\\$");
+  });
+
+  it("escapes when one dollar is bare (`$10 today (down from $ yesterday)`)", () => {
+    const out = guardDollarMath("$10 today (down from $ yesterday)");
+    expect(out).not.toMatch(/(?<!\\)\$/);
+  });
+
+  it("escapes a `$.50` amount whose `$` is not digit-adjacent by one char", () => {
+    const out = guardDollarMath("$.50 here and $5 there");
+    expect(out).not.toMatch(/(?<!\\)\$/);
+    expect(out).toContain("\\$.50 here and \\$5 there");
+  });
+
+  it("leaves two non-currency `$` (shell-var prose) untouched — no false positive", () => {
+    const s = "use $foo and $bar as the two variables";
+    expect(guardDollarMath(s)).toBe(s);
+  });
+
+  // ── F5: idempotent — running the guard twice never doubles the backslash ──
+  it("is idempotent: guarding already-guarded text is a strict no-op", () => {
+    const once = guardDollarMath(OFFENDING);
+    expect(guardDollarMath(once)).toBe(once);
+    expect(once).not.toContain("\\\\$"); // never a doubled `\\$`
+  });
+});
+
+// F1/F2 regression: exercise the ACTUAL reply pipe. The `reply` tool's final
+// answer flows executeReply → computeReplyChunks → sendReplyChunks →
+// richMessage(chunk). `richMessage` is the single wire seam the guard now lives
+// in; these assertions FAIL against the pre-fix code (bare `{ markdown }` wrap,
+// no guard) and pass after. We drive the real `computeReplyChunks` output
+// through the real `richMessage`, not `guardDollarMath` in isolation.
+describe("reply-path integration (#3252 F1/F2)", () => {
+  const OFFENDING =
+    "acquisition ceiling is ~$0.5-0.9M but nearly all in small dealers ... is ~$150-450k";
+
+  it("richMessage() escapes the `$…$` pair on the markdown wire body", () => {
+    const wire = richMessage(OFFENDING);
+    // The bytes handed to sendRichMessage/editMessageText carry no unescaped `$`.
+    expect(wire.markdown).not.toMatch(/(?<!\\)\$/);
+    expect(wire.markdown).not.toMatch(MATH_GLYPH);
+    // Reader-visible amounts intact once the defuser is stripped.
+    expect(copyText(wire.markdown)).toBe(OFFENDING);
+  });
+
+  it("the full computeReplyChunks → richMessage reply pipe emits no unescaped `$`", () => {
+    // Exactly what executeReply feeds sendReplyChunks for a non-literal reply.
+    const chunks = computeReplyChunks({
+      effectiveText: OFFENDING,
+      literalText: false,
+      limit: RICH_MESSAGE_MAX_CHARS,
+      chunkMode: "newline",
+    });
+    expect(chunks.length).toBeGreaterThan(0);
+    for (const chunk of chunks) {
+      const wire = richMessage(chunk); // sendReplyChunks wraps each chunk this way
+      expect(wire.markdown).not.toMatch(/(?<!\\)\$/);
+      expect(wire.markdown).not.toMatch(MATH_GLYPH);
+    }
+  });
+
+  it("a single-amount reply is left with its dollar untouched on the wire", () => {
+    const wire = richMessage("the retainer is $2500 per month");
+    expect(wire.markdown).toContain("$2500");
+    expect(wire.markdown).not.toContain("\\$2500");
+  });
+});
+
+describe("guardDollarMath — link / table awareness (findings 1 & 3)", () => {
+  it("does NOT escape a `$` inside a markdown link destination", () => {
+    // Two dollars + a digit-adjacent one would normally arm the guard, but both
+    // live in URL query strings → structural → left verbatim.
+    const s = "buy [x](https://x.io?price=$5) or [y](https://y.io?price=$9)";
+    expect(guardDollarMath(s)).toBe(s);
+  });
+
+  it("does NOT escape `$` inside a real table's cells", () => {
+    const s = ["| Item | Cost |", "| --- | --- |", "| a | $5 |", "| b | $9 |"].join("\n");
+    expect(guardDollarMath(s)).toBe(s);
+  });
+
+  it("STILL escapes two currency dollars in ordinary prose", () => {
+    const out = guardDollarMath("spend was $5 today and $9 tomorrow");
+    expect(out).not.toMatch(/(?<!\\)\$/);
+  });
+});