switchroom 0.16.38 → 0.16.46

package/telegram-plugin/tests/formatting-torture-set.ts

@@ -0,0 +1,218 @@
+/**
+ * formatting-torture-set — curated fixtures for parse-level formatting
+ * regression testing.
+ *
+ * Each fixture is an INTENT (`input`) plus the STRUCTURE we expect the
+ * formatter's output to parse into (checked by `rich-markdown-oracle.ts`).
+ * The `input` is the raw text as a model/card surface would author it — the
+ * regression test runs it through the SAME outbound transform pipeline the
+ * gateway uses (repairEscapedWhitespace -> normalizeParagraphBreaks ->
+ * addParagraphSpacers -> splitMarkdownChunks) and then asserts:
+ *
+ *   (a) every emitted chunk is parse-accept valid (no rich-path 400), and
+ *   (b) the concatenated output parses into `expect` (entity structure).
+ *
+ * The `expect` block describes WHAT should survive, not a byte-for-byte echo
+ * of formatter output — the oracle is independent of the formatter, so this is
+ * a genuine cross-check, not a circular self-comparison.
+ *
+ * F1/F2/F4/F7 fixtures reproduce the specific formatting fixes from PR #2737
+ * (see `telegram-plugin/format.ts` and `text-voice-scrub.ts`).
+ */
+
+import type { EntityType } from './rich-markdown-oracle.js'
+
+export interface ExpectEntity {
+  readonly type: EntityType
+  /** Exact inner text the entity should carry. */
+  readonly text: string
+  /** For links, the destination. */
+  readonly url?: string
+  /** For fenced blocks, the language info string. */
+  readonly lang?: string
+}
+
+export interface TortureFixture {
+  readonly name: string
+  /** One-line description of the intent this fixture pins. */
+  readonly intent: string
+  /** Raw authored input, before the outbound transform pipeline. */
+  readonly input: string
+  /**
+   * Entities we expect to find in the transformed output. The test asserts
+   * every listed entity is PRESENT (membership), not that these are the only
+   * entities — spacer/structure passes may add nothing observable to the
+   * entity set. Empty ⇒ only signal (a) is asserted for this fixture.
+   */
+  readonly expect: ReadonlyArray<ExpectEntity>
+  /**
+   * When set, the raw input is EXPECTED to be scrubbed by the card-surface
+   * voice pass (F1) before it reaches the rich path — the test applies
+   * `normalizeDashes` first and asserts the em/en-dash glyph is gone.
+   */
+  readonly cardSurfaceScrub?: boolean
+}
+
+export const TORTURE_SET: ReadonlyArray<TortureFixture> = [
+  // ── Multi-item bullet list — one fact per bullet ──────────────────────────
+  {
+    name: 'multi-item-bullet-list',
+    intent: 'A plain multi-item bullet list stays parse-valid and keeps its items intact',
+    input: [
+      'Findings:',
+      '- Master Bath 1 is clean',
+      '- Master Bath 2 shows 33% loss',
+      '- Cabinet is clean',
+    ].join('\n'),
+    expect: [],
+  },
+
+  // ── Middot (·) separator INSIDE a bullet — the collapsed-inline case ──────
+  {
+    name: 'middot-separator-inside-bullet',
+    intent: 'A collapsed one-line bullet list using `·` separators splits without corrupting entities',
+    input: '- Master Bath 1, clean · **Master Bath 2**, 33% loss · Cabinet, clean',
+    expect: [{ type: 'bold', text: 'Master Bath 2' }],
+  },
+
+  // ── Em-dash in prose (voice scrub is a DIFFERENT surface — see F1) ────────
+  {
+    name: 'em-dash-in-prose',
+    intent: 'Prose containing an em-dash is parse-valid on the rich path (raw, un-scrubbed)',
+    input: 'The audit is done — every surface checked, nothing left open.',
+    expect: [],
+  },
+
+  // ── Wide / long code block ────────────────────────────────────────────────
+  {
+    name: 'wide-long-code-block',
+    intent: 'A fenced code block with a long line and reserved chars stays balanced and verbatim',
+    input: [
+      'Run this:',
+      '```bash',
+      'grep -rnE "foo\\|bar\\|baz" src/ | awk -F: \'{print $1}\' | sort -u  # a very very very long command line that keeps going and going',
+      'echo "done"',
+      '```',
+    ].join('\n'),
+    expect: [
+      {
+        type: 'pre',
+        lang: 'bash',
+        text: [
+          'grep -rnE "foo\\|bar\\|baz" src/ | awk -F: \'{print $1}\' | sort -u  # a very very very long command line that keeps going and going',
+          'echo "done"',
+        ].join('\n'),
+      },
+    ],
+  },
+
+  // ── A GFM table ───────────────────────────────────────────────────────────
+  {
+    name: 'gfm-table',
+    intent: 'A GFM table stays row-complete (no bisected/half rows) and parse-valid',
+    input: [
+      'Results:',
+      '',
+      '| Surface | Status | Loss |',
+      '| --- | --- | --- |',
+      '| Bath 1 | clean | 0% |',
+      '| Bath 2 | flagged | 33% |',
+    ].join('\n'),
+    expect: [],
+  },
+
+  // ── A nested list ─────────────────────────────────────────────────────────
+  {
+    name: 'nested-list',
+    intent: 'A nested bullet list stays parse-valid with inline emphasis preserved',
+    input: [
+      '- Top level one',
+      '  - Nested **bold** item',
+      '  - Nested plain item',
+      '- Top level two',
+    ].join('\n'),
+    expect: [{ type: 'bold', text: 'bold' }],
+  },
+
+  // ── A long line that wraps ────────────────────────────────────────────────
+  {
+    name: 'long-wrapping-line',
+    intent: 'A single long prose line is parse-valid and preserves inline entities',
+    input:
+      'This is a single very long line of prose that would wrap on a phone screen and keeps going with more and more words to exceed a comfortable width, and it ends with an inline `code token` plus a **bold phrase** to make sure entities survive the length.',
+    expect: [
+      { type: 'code', text: 'code token' },
+      { type: 'bold', text: 'bold phrase' },
+    ],
+  },
+
+  // ── Links ─────────────────────────────────────────────────────────────────
+  {
+    name: 'links',
+    intent: 'Inline links parse into link entities with the right label + destination',
+    input:
+      'See the [switchroom repo](https://github.com/switchroom/switchroom) and the [docs](https://example.com/docs) for details.',
+    expect: [
+      { type: 'link', text: 'switchroom repo', url: 'https://github.com/switchroom/switchroom' },
+      { type: 'link', text: 'docs', url: 'https://example.com/docs' },
+    ],
+  },
+
+  // ── Inline code containing reserved chars ─────────────────────────────────
+  {
+    name: 'inline-code-reserved-chars',
+    intent: 'Inline code holding *, _, [, ], | renders verbatim without breaking entities',
+    input: 'The pattern `a_b*c[d]|e` is matched literally, and `f*g` too.',
+    expect: [
+      { type: 'code', text: 'a_b*c[d]|e' },
+      { type: 'code', text: 'f*g' },
+    ],
+  },
+
+  // ── F1 — dash-scrub on the card surface ───────────────────────────────────
+  // The card/worker-narration surface runs `normalizeDashes` (voice scrub)
+  // before the rich path; an em-dash must not survive to the wire. Assert the
+  // scrub removes the glyph AND the scrubbed text is parse-valid.
+  {
+    name: 'F1-card-surface-dash-scrub',
+    intent: 'F1: em/en-dash is scrubbed off the card surface and the result stays parse-valid',
+    input: 'Cabinet clean — 33% loss noted, second pass pending – rechecking now.',
+    expect: [],
+    cardSurfaceScrub: true,
+  },
+
+  // ── F2 — a stray pipe must NOT eat paragraph spacing ──────────────────────
+  // A prose line containing a loose ` | ` used to be misread as a table row,
+  // suppressing the paragraph break that follows. The two paragraphs must stay
+  // separated and the whole thing must be parse-valid (no half-table-row).
+  {
+    name: 'F2-stray-pipe-keeps-paragraph-spacing',
+    intent: 'F2: a loose interior pipe in prose does not collapse the following paragraph break',
+    input:
+      'You can choose plan A | plan B depending on scale.\n\nEither way the migration completes in one pass.',
+    expect: [],
+  },
+
+  // ── F4 — blank line after a closed code fence ─────────────────────────────
+  // Prose glued directly onto a fence close (single `\n`) can be swallowed.
+  // The block-boundary pass inserts a blank line; the fence must stay balanced
+  // and the trailing prose must survive as parse-valid text.
+  {
+    name: 'F4-blank-line-after-closed-fence',
+    intent: 'F4: a closed fence followed immediately by prose stays balanced and the prose survives',
+    input: ['Here is the fix:', '```', 'const x = 1', '```', 'And it ships today.'].join('\n'),
+    expect: [{ type: 'pre', text: 'const x = 1' }],
+  },
+
+  // ── F7 — over-cap chunk falls back to hard-slice, not dropped ─────────────
+  // An indivisible fenced block larger than the cap must be hard-sliced into
+  // <= cap pieces rather than emitted whole (which Telegram rejects) or dropped.
+  // The test drives this with a small cap so the giant block cannot fit; it
+  // asserts no content is lost and every emitted chunk fits the cap.
+  {
+    name: 'F7-over-cap-hard-slice',
+    intent: 'F7: an oversized indivisible fenced block is hard-sliced to <= cap, losing no content',
+    input: '```\n' + 'x'.repeat(600) + '\n```',
+    expect: [],
+  },
+]

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

@@ -44,7 +44,7 @@ function makeDeps(overrides: Partial<ModelCommandDeps> = {}) {
       return okResult("⏺ Set model to sonnet");
     },
     getAgentName: () => "klanker",
-    getConfiguredModel: () => "claude-sonnet-4-6",
+    getConfiguredModel: () => "claude-sonnet-5",
     escapeHtml: (s) =>
       s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"),
     preBlock: (s) => `<pre>${s}</pre>`,
@@ -75,9 +75,9 @@ describe("parseModelCommand", () => {
       model: "claude-opus-4-8",
     });
     // 1m-context variant ids carry brackets
-    expect(parseModelCommand("/model claude-sonnet-4-6[1m]")).toEqual({
+    expect(parseModelCommand("/model claude-sonnet-5[1m]")).toEqual({
       kind: "set",
-      model: "claude-sonnet-4-6[1m]",
+      model: "claude-sonnet-5[1m]",
     });
   });
 
@@ -107,7 +107,7 @@ describe("parseModelCommand", () => {
 
 describe("isValidModelArg", () => {
   it("accepts aliases and full ids", () => {
-    for (const good of [...MODEL_ALIASES, "claude-opus-4-8", "claude-haiku-4-5-20251001", "claude-sonnet-4-6[1m]"]) {
+    for (const good of [...MODEL_ALIASES, "claude-opus-4-8", "claude-haiku-4-5-20251001", "claude-sonnet-5[1m]"]) {
       expect(isValidModelArg(good), good).toBe(true);
     }
   });
@@ -163,7 +163,7 @@ describe("handleModelCommand — show / help never inject (picker-wedge guard)",
     const { deps, calls } = makeDeps();
     const reply = await handleModelCommand({ kind: "show" }, deps);
     expect(calls.length).toBe(0);
-    expect(reply.text).toContain("claude-sonnet-4-6");
+    expect(reply.text).toContain("claude-sonnet-5");
     expect(reply.text).toContain("/model opus");
     expect(reply.text).toContain("switchroom.yaml");
   });
@@ -246,7 +246,7 @@ describe("isSrModel / isClaudeModel helpers", () => {
   it("isSrModel is true only for sr-* names", () => {
     expect(isSrModel("sr-gemini-2.5-pro")).toBe(true);
     expect(isSrModel("sr-deepseek-r1")).toBe(true);
-    expect(isSrModel("claude-sonnet-4-6")).toBe(false);
+    expect(isSrModel("claude-sonnet-5")).toBe(false);
     expect(isSrModel("sonnet")).toBe(false);
     expect(isSrModel("")).toBe(false);
   });
@@ -256,7 +256,7 @@ describe("isSrModel / isClaudeModel helpers", () => {
       expect(isClaudeModel(alias), alias).toBe(true);
     }
     expect(isClaudeModel("claude-opus-4-8")).toBe(true);
-    expect(isClaudeModel("claude-sonnet-4-6[1m]")).toBe(true);
+    expect(isClaudeModel("claude-sonnet-5[1m]")).toBe(true);
     expect(isClaudeModel("sr-gemini-2.5-pro")).toBe(false);
     expect(isClaudeModel("gpt-4")).toBe(false);
   });
@@ -407,7 +407,13 @@ import {
   MODEL_CALLBACK_REFRESH,
   MODEL_CALLBACK_HEADER,
   MODEL_CALLBACK_SR,
+  MODEL_CALLBACK_ALIAS,
+  MODEL_CALLBACK_PAGE_EXTERNAL,
+  MODEL_CALLBACK_PAGE_MAIN,
   SR_MODEL_LABELS,
+  SR_MODEL_ALIASES,
+  EXTRA_CLAUDE_ALIASES,
+  externalModelNames,
   isSrToClaudeTransition,
   type ModelMenuDeps,
 } from "../gateway/model-command.js";
@@ -415,7 +421,7 @@ import { labelTag } from "../../src/agents/model-picker.js";
 
 const OPTIONS = [
   { index: 1, label: "Default (recommended)", detail: "Opus 4.8 with 1M context", current: false },
-  { index: 2, label: "Sonnet", detail: "Sonnet 4.6 · Efficient", current: true },
+  { index: 2, label: "Sonnet", detail: "Sonnet 5 · Efficient", current: true },
   { index: 3, label: "Haiku", detail: "Haiku 4.5 · Fastest", current: false },
 ];
 
@@ -448,11 +454,16 @@ describe("buildModelMenu", () => {
     expect(menu.text).toContain("**Sonnet**");
     expect(menu.text).toContain("29% / 5h · 33% / 7d");
     expect(menu.keyboard).toBeDefined();
-    // 3 option rows + refresh row
-    expect(menu.keyboard!.length).toBe(4);
+    // 3 scraped option rows + static Fable row + refresh row
+    // (no external row here — discoverSrModels returns [] and the default
+    // makeMenuDeps has no SR seed override, but externalModelNames seeds from
+    // SR_MODEL_ALIASES, so the External row IS present — see dedicated tests).
     expect(menu.keyboard![1][0].text).toBe("✅ Sonnet");
     expect(menu.keyboard![0][0].text).toBe("Default (recommended)");
-    expect(menu.keyboard![3][0].callback_data).toBe(MODEL_CALLBACK_REFRESH);
+    // Refresh is always the last row.
+    expect(menu.keyboard![menu.keyboard!.length - 1][0].callback_data).toBe(
+      MODEL_CALLBACK_REFRESH,
+    );
   });
 
   it("every callback_data fits Telegram's 64-byte cap", async () => {
@@ -585,7 +596,7 @@ describe("sessionModelFromConfirmation", () => {
 
 const OPTIONS_WITH_SR = [
   { index: 1, label: "Default (recommended)", detail: "Opus 4.8 with 1M context", current: false },
-  { index: 2, label: "Sonnet", detail: "Sonnet 4.6", current: true },
+  { index: 2, label: "Sonnet", detail: "Sonnet 5", current: true },
   { index: 3, label: "sr-gemini-2.5-pro", detail: "", current: false },
   { index: 4, label: "sr-deepseek-r1", detail: "", current: false },
   // internal path — should be filtered out
@@ -635,42 +646,48 @@ describe("buildModelMenu — with sr-* models", () => {
     });
   }
 
-  it("shows 🌐 buttons for sr-* models, normal buttons for claude models", async () => {
-    const { deps } = makeMenuDepsWithSr();
-    const menu = await buildModelMenu(deps);
-    expect(menu.keyboard).toBeDefined();
-    const allButtons = menu.keyboard!.flat();
-    // 🌐 buttons for sr-*
-    expect(allButtons.find((b) => b.text === "🌐 Gemini 2.5 Pro")).toBeDefined();
-    expect(allButtons.find((b) => b.text === "🌐 DeepSeek R1")).toBeDefined();
-    // Regular buttons for Claude models
-    expect(allButtons.find((b) => b.text === "Default (recommended)")).toBeDefined();
-    // openrouter/* not shown at all
-    expect(allButtons.find((b) => b.text.includes("openrouter"))).toBeUndefined();
-  });
+  // Nested-page design (this PR): sr-* models no longer render inline on the
+  // main page — they live behind the "🌐 External models ▸" button on a second
+  // keyboard page. Live discoverSrModels() results are UNION-ed with the static
+  // SR_MODEL_ALIASES seed, so the external page always has at least the six
+  // curated aliases even when discovery returns [].
 
-  it("sr-* buttons use mdl:sr: callback prefix", async () => {
+  it("live-discovered sr-* models appear on the EXTERNAL page (not inline on main)", async () => {
     const { deps } = makeMenuDepsWithSr();
-    const menu = await buildModelMenu(deps);
+    const main = await buildModelMenu(deps, "main");
+    const mainButtons = main.keyboard!.flat();
+    // Not inline on the main page…
+    expect(mainButtons.find((b) => b.text === "🌐 Gemini 2.5 Pro")).toBeUndefined();
+    // …but the External-open button is present.
+    expect(mainButtons.find((b) => b.callback_data === MODEL_CALLBACK_PAGE_EXTERNAL)).toBeDefined();
+
+    const ext = await buildModelMenu(deps, "external");
+    const extButtons = ext.keyboard!.flat();
+    expect(extButtons.find((b) => b.text === "🌐 Gemini 2.5 Pro")).toBeDefined();
+    expect(extButtons.find((b) => b.text === "🌐 DeepSeek R1")).toBeDefined();
+    // openrouter/* / non-sr-* never shown at all.
+    expect(extButtons.find((b) => b.text.includes("openrouter"))).toBeUndefined();
+  });
+
+  it("external-page sr-* buttons use the mdl:sr: callback prefix", async () => {
+    const { deps } = makeMenuDepsWithSr();
+    const menu = await buildModelMenu(deps, "external");
     const srButton = menu.keyboard!.flat().find((b) => b.text === "🌐 Gemini 2.5 Pro");
     expect(srButton?.callback_data).toBe(`${MODEL_CALLBACK_SR}sr-gemini-2.5-pro`);
   });
 
-  it("shows section header rows when both claude and sr-* models present", async () => {
+  it("external page has exactly one header row (billed-separately)", async () => {
     const { deps } = makeMenuDepsWithSr();
-    const menu = await buildModelMenu(deps);
-    const allButtons = menu.keyboard!.flat();
-    const headers = allButtons.filter((b) => b.callback_data === MODEL_CALLBACK_HEADER);
-    expect(headers.length).toBe(2);
-    expect(headers[0].text).toContain("Claude");
-    expect(headers[1].text).toContain("OpenRouter");
+    const menu = await buildModelMenu(deps, "external");
+    const headers = menu.keyboard!.flat().filter((b) => b.callback_data === MODEL_CALLBACK_HEADER);
+    expect(headers.length).toBe(1);
+    expect(headers[0].text).toContain("External");
   });
 
-  it("no section headers when only claude models (no sr-*)", async () => {
+  it("main page carries NO header rows (headers live on the external page)", async () => {
     const { deps } = makeMenuDeps();
-    const menu = await buildModelMenu(deps);
-    const allButtons = (menu.keyboard ?? []).flat();
-    const headers = allButtons.filter((b) => b.callback_data === MODEL_CALLBACK_HEADER);
+    const menu = await buildModelMenu(deps, "main");
+    const headers = (menu.keyboard ?? []).flat().filter((b) => b.callback_data === MODEL_CALLBACK_HEADER);
     expect(headers.length).toBe(0);
   });
 
@@ -682,17 +699,11 @@ describe("buildModelMenu — with sr-* models", () => {
     expect(injectCalls).toHaveLength(0);
   });
 
-  it("shows subscription/OpenRouter legend when sr-* models are present", async () => {
+  it("main page points at the External page for OpenRouter-billed models", async () => {
     const { deps } = makeMenuDepsWithSr();
-    const menu = await buildModelMenu(deps);
+    const menu = await buildModelMenu(deps, "main");
     expect(menu.text).toContain("Max/Pro subscription");
-    expect(menu.text).toContain("OpenRouter");
-  });
-
-  it("no legend when no sr-* models in picker", async () => {
-    const { deps } = makeMenuDeps();
-    const menu = await buildModelMenu(deps);
-    expect(menu.text).not.toContain("OpenRouter");
+    expect(menu.text).toContain("External models");
   });
 });
 
@@ -761,3 +772,158 @@ describe("isSrToClaudeTransition", () => {
     expect(isSrToClaudeTransition("Sonnet", "sr-gemini-2.5-pro")).toBe(false);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Paginated picker — Fable in the Claude group + nested External page.
+// ---------------------------------------------------------------------------
+
+describe("externalModelNames", () => {
+  it("seeds from SR_MODEL_ALIASES values even when discovery is empty", () => {
+    const names = externalModelNames([]);
+    for (const target of Object.values(SR_MODEL_ALIASES)) {
+      expect(names).toContain(target);
+    }
+    // All six curated aliases, deduped.
+    expect(names.length).toBe(new Set(Object.values(SR_MODEL_ALIASES)).size);
+    expect(names).toEqual([...names].sort());
+  });
+
+  it("unions live discovery, dedupes, and drops non-sr-* names", () => {
+    const names = externalModelNames(["sr-brand-new", "sr-glm-5", "gpt-4o", "voyage-law-2"]);
+    expect(names).toContain("sr-brand-new");
+    expect(names).toContain("sr-glm-5");
+    // sr-glm-5 already came from aliases — deduped, not doubled.
+    expect(names.filter((n) => n === "sr-glm-5").length).toBe(1);
+    // Non-sr-* names never surface (subscription-honest).
+    expect(names).not.toContain("gpt-4o");
+    expect(names).not.toContain("voyage-law-2");
+  });
+});
+
+describe("paginated model menu — main page", () => {
+  it("main page includes a Fable button and an External-models-open button", async () => {
+    const { deps } = makeMenuDeps();
+    const menu = await buildModelMenu(deps);
+    const flat = menu.keyboard!.flat();
+    const fable = flat.find((b) => b.text === "Fable");
+    expect(fable).toBeDefined();
+    expect(fable!.callback_data).toBe(`${MODEL_CALLBACK_ALIAS}fable`);
+    const ext = flat.find((b) => b.callback_data === MODEL_CALLBACK_PAGE_EXTERNAL);
+    expect(ext).toBeDefined();
+    expect(ext!.text).toContain("External");
+    // Refresh is last.
+    expect(menu.keyboard![menu.keyboard!.length - 1][0].callback_data).toBe(
+      MODEL_CALLBACK_REFRESH,
+    );
+  });
+
+  it("no External-open button when there are no external models", async () => {
+    // Force externalModelNames to be empty by stubbing SR aliases away is not
+    // possible (static), but a build with an empty alias set is covered by the
+    // externalModelNames unit test. Here we assert the button is gated on the
+    // list being non-empty via the real (non-empty) path: it IS present.
+    const { deps } = makeMenuDeps();
+    const menu = await buildModelMenu(deps);
+    const flat = menu.keyboard!.flat();
+    expect(flat.some((b) => b.callback_data === MODEL_CALLBACK_PAGE_EXTERNAL)).toBe(true);
+  });
+
+  it("dedupes the static Fable row if the scraped options already include Fable", async () => {
+    const { deps } = makeMenuDeps({
+      discover: async () => ({
+        ok: true as const,
+        options: [
+          { index: 1, label: "Sonnet", detail: "", current: true },
+          { index: 2, label: "Fable", detail: "Fable 5", current: false },
+        ],
+        currentLabel: "Sonnet",
+      }),
+    });
+    const menu = await buildModelMenu(deps);
+    const flat = menu.keyboard!.flat();
+    // Exactly one Fable button, and it's the scraped (select) one, not the alias.
+    const fables = flat.filter((b) => b.text === "Fable" || b.text === "✅ Fable");
+    expect(fables.length).toBe(1);
+    expect(fables[0].callback_data.startsWith(MODEL_CALLBACK_ALIAS)).toBe(false);
+  });
+
+  it("every callback_data still fits Telegram's 64-byte cap", async () => {
+    const { deps } = makeMenuDeps();
+    for (const page of ["main", "external"] as const) {
+      const menu = await buildModelMenu(deps, page);
+      for (const btn of menu.keyboard!.flat()) {
+        expect(Buffer.byteLength(btn.callback_data, "utf-8")).toBeLessThanOrEqual(64);
+      }
+    }
+  });
+});
+
+describe("paginated model menu — external page", () => {
+  it("lists all six SR_MODEL_ALIASES models plus a Back button", async () => {
+    const { deps } = makeMenuDeps();
+    const menu = await buildModelMenu(deps, "external");
+    const flat = menu.keyboard!.flat();
+    for (const target of Object.values(SR_MODEL_ALIASES)) {
+      const btn = flat.find((b) => b.callback_data === `${MODEL_CALLBACK_SR}${target}`);
+      expect(btn, `missing external button for ${target}`).toBeDefined();
+      expect(btn!.text.startsWith("🌐")).toBe(true);
+    }
+    expect(flat.some((b) => b.callback_data === MODEL_CALLBACK_PAGE_MAIN)).toBe(true);
+    expect(flat.some((b) => b.callback_data === MODEL_CALLBACK_REFRESH)).toBe(true);
+  });
+
+  it("external page body text makes the billed-separately split explicit", async () => {
+    const { deps } = makeMenuDeps();
+    const menu = await buildModelMenu(deps, "external");
+    expect(menu.text).toContain("billed separately");
+    expect(menu.text).toContain("OpenRouter");
+    expect(menu.text).toContain("subscription");
+  });
+});
+
+describe("page callbacks swap the keyboard without switching model", () => {
+  it("PAGE_EXTERNAL renders the external page and does NOT select/inject", async () => {
+    const { deps, calls, injectCalls } = makeMenuDeps();
+    const out = await handleModelMenuCallback(MODEL_CALLBACK_PAGE_EXTERNAL, deps);
+    expect(calls.select).toEqual([]);
+    expect(injectCalls).toEqual([]);
+    expect(out.selectedModel).toBeUndefined();
+    const flat = out.reply.keyboard!.flat();
+    expect(flat.some((b) => b.callback_data === MODEL_CALLBACK_PAGE_MAIN)).toBe(true);
+    expect(out.reply.text).toContain("billed separately");
+  });
+
+  it("PAGE_MAIN renders the main page and does NOT select/inject", async () => {
+    const { deps, calls, injectCalls } = makeMenuDeps();
+    const out = await handleModelMenuCallback(MODEL_CALLBACK_PAGE_MAIN, deps);
+    expect(calls.select).toEqual([]);
+    expect(injectCalls).toEqual([]);
+    expect(out.selectedModel).toBeUndefined();
+    const flat = out.reply.keyboard!.flat();
+    expect(flat.some((b) => b.callback_data === MODEL_CALLBACK_PAGE_EXTERNAL)).toBe(true);
+    expect(flat.some((b) => b.text === "Fable")).toBe(true);
+  });
+});
+
+describe("Fable alias callback injects /model fable", () => {
+  it("injects exactly '/model fable' and reports the session model", async () => {
+    const { deps, calls, injectCalls } = makeMenuDeps();
+    const out = await handleModelMenuCallback(`${MODEL_CALLBACK_ALIAS}fable`, deps);
+    // Alias path uses inject, never the cursor-nav select path.
+    expect(calls.select).toEqual([]);
+    expect(injectCalls).toHaveLength(1);
+    expect(injectCalls[0].command).toBe("/model fable");
+    expect(out.reply.text).toContain("✅");
+  });
+
+  it("EXTRA_CLAUDE_ALIASES contains fable", () => {
+    expect(EXTRA_CLAUDE_ALIASES.some((a) => a.alias === "fable" && a.label === "Fable")).toBe(true);
+  });
+
+  it("rejects an invalid alias without injecting", async () => {
+    const { deps, injectCalls } = makeMenuDeps();
+    const out = await handleModelMenuCallback(`${MODEL_CALLBACK_ALIAS}bad name`, deps);
+    expect(injectCalls).toEqual([]);
+    expect(out.answer).toContain("Invalid");
+  });
+});