switchroom 0.15.2 → 0.15.4

package/telegram-plugin/gateway/model-command.ts

@@ -2,13 +2,14 @@
  * Telegram `/model` command — show or switch the Claude model for this
  * agent's live session.
  *
- * `/model` (bare) shows the configured model and the switch options.
- * It deliberately NEVER injects the bare `/model` verb into the claude
- * pane: with no argument the CLI renders an interactive picker modal
- * that nothing on the Telegram side can drive (no arrow keys, no Esc),
- * which would wedge the pane — the same TUI-modal class of wedge as
- * the /rate-limit-options incident. Only the argument form is ever
- * injected.
+ * `/model` (bare) renders the model dashboard: the live model, a brief
+ * quota line, and an inline-keyboard menu of the options claude's own
+ * `/model` picker offers (discovered live via `src/agents/model-picker.ts`
+ * — opened, parsed, Esc'd; never hardcoded, so new models appear the
+ * moment the installed CLI offers them). A button tap re-opens the
+ * picker fresh, matches the row by label, and applies session-only.
+ * When discovery fails (agent mid-turn, CLI UI changed, kill-switched
+ * via SWITCHROOM_MODEL_MENU=0) it falls back to the static v1 text.
  *
  * `/model <alias|full-id>` types claude's own `/model <name>` into the
  * agent's tmux pane via the existing allowlisted inject primitive
@@ -24,6 +25,12 @@
  */
 
 import type { InjectResult } from '../../src/agents/inject.js'
+import {
+  labelTag,
+  type DiscoverResult,
+  type SelectResult,
+  type ModelPickerOption,
+} from '../../src/agents/model-picker.js'
 
 /**
  * Aliases the claude CLI resolves natively. Listed in help text only —
@@ -180,3 +187,250 @@ export async function handleModelCommand(
     html: true,
   }
 }
+
+// ---------------------------------------------------------------------------
+// Picker-driven model menu (v2) — discovery, render, callback selection.
+// ---------------------------------------------------------------------------
+
+export interface ModelMenuDeps {
+  /** Live picker discovery — src/agents/model-picker.ts discoverModels. */
+  discover: (agent: string) => Promise<DiscoverResult>
+  /** Live picker selection by label — selectModel (session-only `s`). */
+  select: (agent: string, label: string) => Promise<SelectResult>
+  /**
+   * True while the agent is mid-turn. Driving the picker types into
+   * claude's input box; doing that mid-turn would queue "/model" as
+   * user text instead of opening the modal — refuse instead.
+   */
+  isBusy: () => boolean
+  getAgentName: () => string
+  /** One-line quota summary (e.g. "29% / 5h · 33% / 7d") or null. */
+  getQuotaBrief: () => Promise<string | null>
+  escapeHtml: (s: string) => string
+}
+
+/** Raw Telegram inline-keyboard shape (grammY accepts it verbatim). */
+export interface ModelMenuKeyboardButton {
+  text: string
+  callback_data: string
+}
+
+export interface ModelMenuReply {
+  text: string
+  html: true
+  /** Rows of buttons; absent on the no-menu fallback. */
+  keyboard?: ModelMenuKeyboardButton[][]
+}
+
+export const MODEL_CALLBACK_PREFIX = 'mdl:'
+const MODEL_CALLBACK_SELECT = 'mdl:s:'
+export const MODEL_CALLBACK_REFRESH = 'mdl:r'
+
+export function modelSelectCallbackData(label: string): string {
+  // Identity is the label's hash, not its index — a tap re-discovers
+  // the picker and matches by tag, so a list that shifted between
+  // render and tap can never select the wrong row. 8 hex chars keeps
+  // callback_data tiny (well under Telegram's 64-byte cap).
+  return `${MODEL_CALLBACK_SELECT}${labelTag(label)}`
+}
+
+function busyReply(deps: Pick<ModelMenuDeps, 'escapeHtml'>): ModelMenuReply {
+  return {
+    text: '⏳ The agent is mid-turn — the model picker needs an idle prompt. Try again in a moment.',
+    html: true,
+  }
+}
+
+function menuKeyboard(options: ModelPickerOption[]): ModelMenuKeyboardButton[][] {
+  // One option per row (labels + ✔ render cleanly at full width on
+  // mobile), refresh on a trailing row.
+  const rows: ModelMenuKeyboardButton[][] = options.map((o) => [
+    {
+      text: o.current ? `✅ ${o.label}` : o.label,
+      callback_data: modelSelectCallbackData(o.label),
+    },
+  ])
+  rows.push([{ text: '🔄 Refresh', callback_data: MODEL_CALLBACK_REFRESH }])
+  return rows
+}
+
+/**
+ * Build the `/model` dashboard: live model + quota brief + tap menu.
+ * Returns a keyboard-less fallback (v1-shaped static text) when the
+ * picker can't be driven right now — the command never hard-fails.
+ */
+export async function buildModelMenu(
+  deps: ModelMenuDeps & ModelCommandDeps,
+): Promise<ModelMenuReply> {
+  if (deps.isBusy()) return busyReply(deps)
+
+  const [discovered, quota] = await Promise.all([
+    deps.discover(deps.getAgentName()),
+    deps.getQuotaBrief().catch(() => null),
+  ])
+
+  if (!discovered.ok) {
+    // Graceful static fallback — same content as the v1 show path,
+    // with the discovery failure surfaced.
+    const v1 = await handleModelCommand({ kind: 'show' }, deps)
+    return {
+      text: [`<i>(picker unavailable: ${deps.escapeHtml(discovered.reason)})</i>`, v1.text].join('\n'),
+      html: true,
+    }
+  }
+
+  // claude's ✔ marks the DEFAULT FOR NEW SESSIONS, which is a different axis
+  // from the model the agent is running right now (set via --model at launch
+  // or a prior session switch). Labelling the ✔ row "Now:" was misleading —
+  // it could read "Opus 4.8" while the live session is on Fable. Call it what
+  // it is, and tell the operator a switch applies to the live session.
+  const current = discovered.options.find((o) => o.current)
+  const lines: string[] = [`<b>Model — ${deps.escapeHtml(deps.getAgentName())}</b>`]
+  if (discovered.dismissFailed) {
+    lines.push('⚠️ <i>The picker may still be open on the agent pane — check it before switching.</i>')
+  }
+  if (current) {
+    const detail = current.detail ? ` · ${deps.escapeHtml(current.detail)}` : ''
+    lines.push(`Default (new sessions): <b>${deps.escapeHtml(current.label)}</b>${detail}`)
+  } else {
+    lines.push('Default (new sessions): <i>unknown (no ✔ row in picker)</i>')
+  }
+  if (quota) lines.push(`Quota: ${deps.escapeHtml(quota)}`)
+  lines.push('', 'Tap a model to switch the <b>live session</b>:')
+  lines.push(PERSIST_NOTE)
+
+  return { text: lines.join('\n'), html: true, keyboard: menuKeyboard(discovered.options) }
+}
+
+export interface ModelCallbackOutcome {
+  /**
+   * When true, the caller should ONLY show the toast (`answer`) and leave
+   * the existing menu message untouched — used for the mid-turn refusal so
+   * the menu keeps its buttons and the operator can simply tap again when
+   * the agent goes idle, instead of the menu collapsing to a button-less
+   * "try again" line (which read as "nothing happened").
+   */
+  toastOnly?: boolean
+  /**
+   * On a successful session switch, the live model name now running (parsed
+   * from claude's confirmation, e.g. "Fable 5"). The gateway records this as
+   * the session-model override so `/status` reflects what's actually running.
+   * Absent on every non-switch outcome.
+   */
+  selectedModel?: string
+  /** Short toast for answerCallbackQuery. */
+  answer: string
+  /** Replacement dashboard (message edit). */
+  reply: ModelMenuReply
+}
+
+/**
+ * Handle a `mdl:*` callback tap. `mdl:r` re-renders the dashboard;
+ * `mdl:s:<tag>` re-discovers the picker, resolves the tag back to a
+ * live label, and applies it session-only. A tag that no longer
+ * matches (claude updated its options since render) re-renders the
+ * menu instead of guessing.
+ */
+export async function handleModelMenuCallback(
+  data: string,
+  deps: ModelMenuDeps & ModelCommandDeps,
+): Promise<ModelCallbackOutcome> {
+  if (data === MODEL_CALLBACK_REFRESH) {
+    return { answer: 'Refreshed', reply: await buildModelMenu(deps) }
+  }
+  if (!data.startsWith(MODEL_CALLBACK_SELECT)) {
+    return { answer: 'Unknown action', reply: await buildModelMenu(deps) }
+  }
+  // Mid-turn: refuse WITHOUT touching the message. Driving the picker types
+  // into claude's input box, which mid-turn would queue "/model" as user
+  // text. toastOnly keeps the menu (and its buttons) exactly as-is so the
+  // operator just taps again when the agent is idle — no button-less
+  // "try again" line that read as a dead menu.
+  if (deps.isBusy()) {
+    return {
+      answer: '⏳ Agent is mid-turn — tap again when it’s idle',
+      reply: busyReply(deps),
+      toastOnly: true,
+    }
+  }
+
+  const tag = data.slice(MODEL_CALLBACK_SELECT.length)
+  const discovered = await deps.discover(deps.getAgentName())
+  if (!discovered.ok) {
+    // Keep the menu interactive: re-render (falls back to v1 text if even
+    // the show path can't discover) with the failure as a banner.
+    return {
+      answer: 'Picker unavailable',
+      reply: await menuWithBanner(
+        deps,
+        `❌ Could not open the model picker: ${deps.escapeHtml(discovered.reason)}`,
+      ),
+    }
+  }
+  const target = discovered.options.find((o) => labelTag(o.label) === tag)
+  if (!target) {
+    // Options changed since the menu rendered — never guess; re-render.
+    const fresh = await buildModelMenu(deps)
+    return { answer: 'Model list changed — menu refreshed', reply: fresh }
+  }
+  // NOTE: do NOT short-circuit when target.current is set. The picker's ✔
+  // marks claude's DEFAULT FOR NEW SESSIONS, which is a DIFFERENT axis from
+  // the model the live session is running (set by --model at launch). Tapping
+  // the ✔ row to apply that model to the live session is a legitimate switch
+  // — e.g. an agent launched on Fable tapping "Default (Opus)". Skipping it
+  // here was the "tapped Default, nothing happened" bug. Always drive the
+  // selection; claude harmlessly answers "Kept model as X" if it's already
+  // the session model.
+  const result = await deps.select(deps.getAgentName(), target.label)
+  if (!result.ok) {
+    // Switch failed but the agent is reachable — keep the menu so the
+    // operator can retry, with the reason as a banner.
+    return {
+      answer: 'Switch failed — see the menu',
+      reply: await menuWithBanner(
+        deps,
+        `❌ Switch to <b>${deps.escapeHtml(target.label)}</b> failed: ${deps.escapeHtml(result.reason)}`,
+      ),
+    }
+  }
+
+  return {
+    answer: deps.escapeHtml(result.confirmation),
+    reply: await menuWithBanner(deps, `✅ ${deps.escapeHtml(result.confirmation)}`),
+    selectedModel: sessionModelFromConfirmation(result.confirmation) ?? target.label,
+  }
+}
+
+/**
+ * Pull the model NAME out of claude's session-switch confirmation so it can
+ * be shown in `/status` as the live session model. claude phrases it as
+ * "Set model to <name> for this session only" (or "Switched to <name>").
+ * Returns null when the confirmation doesn't carry a recognizable name (the
+ * caller falls back to the tapped picker label).
+ */
+export function sessionModelFromConfirmation(confirmation: string): string | null {
+  const m = /(?:Set model to|Switched to)\s+(.+?)(?:\s+for (?:this|the) session|\s*\(|\s*$)/i.exec(
+    confirmation.trim(),
+  )
+  const name = m?.[1]?.trim()
+  return name && name.length > 0 ? name : null
+}
+
+/**
+ * Re-render the live menu with a one-line banner on top. Used by every
+ * post-tap outcome (success, already-default, failure) so the menu ALWAYS
+ * keeps its buttons and the operator can act again — the consistent
+ * "status line + interactive menu" shape the other dashboards use. Falls
+ * back to the banner alone if the menu can't be rebuilt right now.
+ */
+async function menuWithBanner(
+  deps: ModelMenuDeps & ModelCommandDeps,
+  banner: string,
+): Promise<ModelMenuReply> {
+  const fresh = await buildModelMenu(deps)
+  return {
+    text: [banner, '', fresh.text].join('\n'),
+    html: true,
+    ...(fresh.keyboard ? { keyboard: fresh.keyboard } : {}),
+  }
+}

package/telegram-plugin/tests/inbound-spool.test.ts

@@ -285,6 +285,107 @@ describe('inbound-spool — bounded escalation (promise always resolved)', () =>
   })
 })
 
+describe('inbound-spool — give-up notice coalescing (2026-06-09 marko spam)', () => {
+  // Helper: drive a sweep, return the list of postNotice flags per dropped entry.
+  function sweepFlags(s: ReturnType<typeof createInboundSpool>): boolean[] {
+    const flags: boolean[] = []
+    s.sweepEscalations((_e, { postNotice }) => flags.push(postNotice))
+    return flags
+  }
+
+  it('a burst of undeliverable entries in one chat posts exactly ONE notice', () => {
+    const fs = fakeFs()
+    let t = 0
+    const s = createInboundSpool({
+      path: PATH, fs, now: () => t,
+      escalateAfterMs: 100, escalateNoticeCooldownMs: 10_000,
+    })
+    // Three synthetics, same chat, distinct ids (fresh ts → distinct spoolId,
+    // the exact churn shape that produced the spam).
+    s.put('marko', msg({ messageId: 0, ts: 1, meta: { source: 'cron' } }))
+    s.put('marko', msg({ messageId: 0, ts: 2, meta: { source: 'cron' } }))
+    s.put('marko', msg({ messageId: 0, ts: 3, meta: { source: 'cron' } }))
+    t = 1000 // all older than the 100ms bound
+    const flags = sweepFlags(s)
+    expect(flags.length).toBe(3) // all three dropped (promise retracted)
+    expect(flags.filter(Boolean).length).toBe(1) // ONE notice posted
+    expect(s.liveCount()).toBe(0)
+  })
+
+  it('distinct chats each get their own notice', () => {
+    const fs = fakeFs()
+    let t = 0
+    const s = createInboundSpool({ path: PATH, fs, now: () => t, escalateAfterMs: 100 })
+    s.put('marko', msg({ chatId: 'A', messageId: 1 }))
+    s.put('marko', msg({ chatId: 'B', messageId: 2 }))
+    t = 1000
+    expect(sweepFlags(s).filter(Boolean).length).toBe(2)
+  })
+
+  it('same chat, different forum topics are coalesced independently', () => {
+    const fs = fakeFs()
+    let t = 0
+    const s = createInboundSpool({ path: PATH, fs, now: () => t, escalateAfterMs: 100 })
+    s.put('marko', msg({ chatId: 'A', messageId: 1, meta: { threadId: '3' } }))
+    s.put('marko', msg({ chatId: 'A', messageId: 2, meta: { threadId: '4' } }))
+    t = 1000
+    expect(sweepFlags(s).filter(Boolean).length).toBe(2)
+  })
+
+  it('THE BUG: the coalescing window survives a restart — a re-aged synthetic does not re-spam', () => {
+    const fs = fakeFs()
+    let t = 0
+    const opts = { escalateAfterMs: 100, escalateNoticeCooldownMs: 60_000 }
+    // Boot 1: one synthetic ages out → posts the notice.
+    const s1 = createInboundSpool({ path: PATH, fs, now: () => t, ...opts })
+    s1.put('marko', msg({ messageId: 0, ts: 1, meta: { source: 'cron' } }))
+    t = 1000
+    expect(sweepFlags(s1)).toEqual([true])
+    // Restart. A NEW synthetic (fresh ts → fresh id) lands and ages out within
+    // the cooldown. Pre-fix this re-posted every cycle across restarts.
+    t = 5000
+    const s2 = createInboundSpool({ path: PATH, fs, now: () => t, ...opts })
+    s2.put('marko', msg({ messageId: 0, ts: 2, meta: { source: 'cron' } }))
+    t = 6000
+    expect(sweepFlags(s2)).toEqual([false]) // dropped, but notice SUPPRESSED
+  })
+
+  it('compaction preserves the coalescing window (a post-compaction restart does not re-spam)', () => {
+    const fs = fakeFs()
+    let t = 0
+    // Tiny compact threshold so the next append triggers a rewrite.
+    const opts = { escalateAfterMs: 100, escalateNoticeCooldownMs: 60_000, compactAtBytes: 1 }
+    const s1 = createInboundSpool({ path: PATH, fs, now: () => t, ...opts })
+    s1.put('marko', msg({ messageId: 0, ts: 1, meta: { source: 'cron' } }))
+    t = 1000
+    expect(sweepFlags(s1)).toEqual([true]) // posts + appends esc; compaction runs
+    // After compaction the file must still carry the esc record → a restart
+    // hydrates the window → a new re-aged synthetic stays suppressed.
+    t = 5000
+    const s2 = createInboundSpool({ path: PATH, fs, now: () => t, ...opts })
+    s2.put('marko', msg({ messageId: 0, ts: 2, meta: { source: 'cron' } }))
+    t = 6000
+    expect(sweepFlags(s2)).toEqual([false])
+  })
+
+  it('re-notifies after the burst goes quiet for longer than the cooldown', () => {
+    const fs = fakeFs()
+    let t = 0
+    const s = createInboundSpool({
+      path: PATH, fs, now: () => t,
+      escalateAfterMs: 100, escalateNoticeCooldownMs: 1000,
+    })
+    s.put('marko', msg({ messageId: 0, ts: 1, meta: { source: 'cron' } }))
+    t = 200
+    expect(sweepFlags(s)).toEqual([true]) // first notice
+    // Quiet gap longer than the cooldown, then a new stuck synthetic.
+    t = 5000
+    s.put('marko', msg({ messageId: 0, ts: 2, meta: { source: 'cron' } }))
+    t = 5200
+    expect(sweepFlags(s)).toEqual([true]) // genuinely new situation → re-notify
+  })
+})
+
 describe('inbound-spool — robustness', () => {
   it('a failing appendFileSync does not throw and keeps in-memory live state', () => {
     const fs = fakeFs()

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

@@ -203,3 +203,182 @@ describe("inject allowlist contract", () => {
     expect(INJECT_COMMANDS.has("/model")).toBe(true);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Picker-driven menu (v2) — buildModelMenu + handleModelMenuCallback
+// ---------------------------------------------------------------------------
+
+import {
+  buildModelMenu,
+  handleModelMenuCallback,
+  modelSelectCallbackData,
+  sessionModelFromConfirmation,
+  MODEL_CALLBACK_REFRESH,
+  type ModelMenuDeps,
+} from "../gateway/model-command.js";
+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: 3, label: "Haiku", detail: "Haiku 4.5 · Fastest", current: false },
+];
+
+function makeMenuDeps(overrides: Partial<ModelMenuDeps> = {}) {
+  const calls = { discover: 0, select: [] as string[] };
+  const base = makeDeps(); // v1 deps (inject/getConfiguredModel/escapeHtml/preBlock)
+  const deps = {
+    ...base.deps,
+    discover: async () => {
+      calls.discover++;
+      return { ok: true as const, options: OPTIONS, currentLabel: "Sonnet" };
+    },
+    select: async (_a: string, label: string) => {
+      calls.select.push(label);
+      return { ok: true as const, confirmation: `Set model to ${label} for this session` };
+    },
+    isBusy: () => false,
+    getQuotaBrief: async () => "29% / 5h · 33% / 7d",
+    ...overrides,
+  };
+  return { deps, calls, injectCalls: base.calls };
+}
+
+describe("buildModelMenu", () => {
+  it("renders current model, quota brief, and one button per discovered option", async () => {
+    const { deps, calls } = makeMenuDeps();
+    const menu = await buildModelMenu(deps);
+    expect(calls.discover).toBe(1);
+    expect(menu.text).toContain("<b>Sonnet</b>");
+    expect(menu.text).toContain("29% / 5h · 33% / 7d");
+    expect(menu.keyboard).toBeDefined();
+    // 3 option rows + refresh row
+    expect(menu.keyboard!.length).toBe(4);
+    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);
+  });
+
+  it("every callback_data fits Telegram's 64-byte cap", async () => {
+    const { deps } = makeMenuDeps();
+    const menu = await buildModelMenu(deps);
+    for (const row of menu.keyboard!) {
+      for (const btn of row) {
+        expect(Buffer.byteLength(btn.callback_data, "utf-8")).toBeLessThanOrEqual(64);
+      }
+    }
+  });
+
+  it("busy agent → no discovery, no keyboard, explanatory text", async () => {
+    const { deps, calls } = makeMenuDeps({ isBusy: () => true });
+    const menu = await buildModelMenu(deps);
+    expect(calls.discover).toBe(0);
+    expect(menu.keyboard).toBeUndefined();
+    expect(menu.text).toContain("mid-turn");
+  });
+
+  it("discovery failure → static v1 fallback with the reason, no keyboard", async () => {
+    const { deps } = makeMenuDeps({
+      discover: async () => ({ ok: false as const, reason: "tmux session not found" }),
+    });
+    const menu = await buildModelMenu(deps);
+    expect(menu.keyboard).toBeUndefined();
+    expect(menu.text).toContain("picker unavailable");
+    expect(menu.text).toContain("Configured:");
+  });
+
+  it("quota failure never blocks the menu", async () => {
+    const { deps } = makeMenuDeps({
+      getQuotaBrief: async () => {
+        throw new Error("broker down");
+      },
+    });
+    const menu = await buildModelMenu(deps);
+    expect(menu.keyboard).toBeDefined();
+    expect(menu.text).not.toContain("Quota:");
+  });
+});
+
+describe("handleModelMenuCallback", () => {
+  it("mdl:s:<tag> selects by re-discovered label", async () => {
+    const { deps, calls } = makeMenuDeps();
+    const out = await handleModelMenuCallback(modelSelectCallbackData("Haiku"), deps);
+    expect(calls.select).toEqual(["Haiku"]);
+    expect(out.answer).toContain("Set model to Haiku");
+    expect(out.reply.text).toContain("✅");
+  });
+
+  it("stale tag (options changed) → never selects, re-renders menu", async () => {
+    const { deps, calls } = makeMenuDeps();
+    const staleTag = `mdl:s:${labelTag("Removed Model")}`;
+    const out = await handleModelMenuCallback(staleTag, deps);
+    expect(calls.select).toEqual([]);
+    expect(out.answer).toContain("refreshed");
+    expect(out.reply.keyboard).toBeDefined();
+  });
+
+  it("tapping the ✔ (default) row STILL drives a switch — ✔ is the new-session default, not the live session model", async () => {
+    // OPTIONS marks "Sonnet" current (the ✔). An agent launched on a
+    // different model must still be able to apply the ✔ row to its live
+    // session — skipping it was the "tapped Default, nothing happened" bug.
+    const { deps, calls } = makeMenuDeps();
+    const out = await handleModelMenuCallback(modelSelectCallbackData("Sonnet"), deps);
+    expect(calls.select).toEqual(["Sonnet"]);
+    expect(out.reply.text).toContain("✅");
+    expect(out.reply.keyboard).toBeDefined();
+  });
+
+  it("busy agent → toastOnly refusal that leaves the menu untouched", async () => {
+    const { deps, calls } = makeMenuDeps({ isBusy: () => true });
+    const out = await handleModelMenuCallback(modelSelectCallbackData("Haiku"), deps);
+    expect(calls.select).toEqual([]);
+    expect(out.answer).toContain("mid-turn");
+    // toastOnly tells the gateway to NOT edit the menu — buttons survive.
+    expect(out.toastOnly).toBe(true);
+  });
+
+  it("selection failure surfaces the reason AND keeps the menu so the operator can retry", async () => {
+    const { deps } = makeMenuDeps({
+      select: async () => ({ ok: false as const, reason: "cursor verification failed" }),
+    });
+    const out = await handleModelMenuCallback(modelSelectCallbackData("Haiku"), deps);
+    expect(out.answer).toContain("failed");
+    expect(out.reply.text).toContain("cursor verification failed");
+    // The menu buttons are preserved — a failure no longer collapses the
+    // menu to a button-less error (the "nothing happened" bug).
+    expect(out.reply.keyboard).toBeDefined();
+  });
+
+  it("a successful switch banners the confirmation, keeps the menu, AND reports the live model for /status", async () => {
+    const { deps } = makeMenuDeps({
+      select: async () => ({ ok: true as const, confirmation: "Set model to Haiku 4.5 for this session only" }),
+    });
+    const out = await handleModelMenuCallback(modelSelectCallbackData("Haiku"), deps);
+    expect(out.answer).toContain("Haiku 4.5");
+    expect(out.reply.text).toContain("✅");
+    expect(out.reply.text).toContain("Set model to Haiku 4.5");
+    expect(out.reply.keyboard).toBeDefined();
+    // The gateway records this so /status reflects the live session model.
+    expect(out.selectedModel).toBe("Haiku 4.5");
+  });
+});
+
+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");
+    expect(sessionModelFromConfirmation("Set model to Opus 4.8 (1M context) for this session only")).toBe("Opus 4.8");
+    expect(sessionModelFromConfirmation("Switched to Haiku 4.5")).toBe("Haiku 4.5");
+  });
+  it("returns null when no recognizable name is present", () => {
+    expect(sessionModelFromConfirmation("Kept model as Opus 4.8 (default)")).toBeNull();
+    expect(sessionModelFromConfirmation("")).toBeNull();
+  });
+
+  it("mdl:r re-renders the dashboard", async () => {
+    const { deps, calls } = makeMenuDeps();
+    const out = await handleModelMenuCallback(MODEL_CALLBACK_REFRESH, deps);
+    expect(out.answer).toBe("Refreshed");
+    expect(calls.discover).toBe(1);
+    expect(out.reply.keyboard).toBeDefined();
+  });
+});

package/telegram-plugin/tests/welcome-text.test.ts

@@ -82,6 +82,17 @@ describe("formatAgentLine", () => {
     const out = formatAgentLine({ ...baseMeta, topicName: "Planning", topicEmoji: "🗓" });
     expect(out).toContain("topic: 🗓 Planning");
   });
+  it("shows the live session model alongside the configured model when a /model switch is active", () => {
+    const out = formatAgentLine({ ...baseMeta, model: "claude-fable-5[1m]", sessionModel: "Opus 4.8 (1M context)" });
+    // Both surfaces present + agree: configured AND what's actually running.
+    expect(out).toContain("<code>claude-fable-5[1m]</code>");
+    expect(out).toContain("live session: <code>Opus 4.8 (1M context)</code>");
+  });
+  it("omits the session line when no override is active", () => {
+    expect(formatAgentLine({ ...baseMeta, sessionModel: null })).not.toContain("live session");
+    expect(formatAgentLine({ ...baseMeta, sessionModel: "" })).not.toContain("live session");
+    expect(formatAgentLine(baseMeta)).not.toContain("live session");
+  });
   it("omits topic when only emoji is set", () => {
     // topicName null → no topic chunk. Keeps the line clean.
     expect(formatAgentLine({ ...baseMeta, topicEmoji: "🗓" })).not.toContain("topic");