switchroom 0.15.2 → 0.15.3

package/telegram-plugin/gateway/gateway.ts

@@ -247,6 +247,7 @@ import {
 import {
   fetchQuota,
   formatQuotaBlock,
+  formatQuotaLine,
   type QuotaResult,
 } from '../quota-check.js'
 import {
@@ -258,7 +259,17 @@ import { DEFAULT_SLOT } from '../../src/auth/accounts.js'
 import { currentActiveSlot, type AuthCodeOutcome } from '../../src/auth/manager.js'
 import { injectSlashCommand as injectSlashCommandImpl } from '../../src/agents/inject.js'
 import { handleInjectCommand } from './inject-handler.js'
-import { parseModelCommand, handleModelCommand } from './model-command.js'
+import {
+  parseModelCommand,
+  handleModelCommand,
+  buildModelMenu,
+  handleModelMenuCallback,
+  MODEL_CALLBACK_PREFIX,
+  type ModelMenuDeps,
+  type ModelCommandDeps,
+  type ModelMenuReply,
+} from './model-command.js'
+import { discoverModels, selectModel } from '../../src/agents/model-picker.js'
 import { type BannerState } from '../slot-banner.js'
 import { refreshBanner } from '../slot-banner-driver.js'
 import { loadConfig as loadSwitchroomConfig, findConfigFile as findSwitchroomConfigFile } from '../../src/config/loader.js'; import { resolveAgentConfig } from '../../src/config/merge.js'
@@ -13922,19 +13933,39 @@ bot.command('inject', async ctx => {
   })
 })
 
-// /model — show or switch the Claude model for this agent's live
-// session. The argument form rides the same allowlisted inject
-// primitive as /inject (claude's native `/model <name>` REPL command);
-// the bare form never injects (the no-arg picker is an undriveable TUI
-// modal from Telegram). Implementation in model-command.ts so it's
+// /model — model dashboard + switch for this agent's live session.
+// Bare form: drives claude's own /model picker (open → parse → Esc,
+// src/agents/model-picker.ts) to discover the live option list — no
+// hardcoded model names — and renders it as an inline-keyboard menu
+// with the current model + a brief quota line. A tap re-opens the
+// picker fresh and applies session-only (`s`). Kill-switch
+// SWITCHROOM_MODEL_MENU=0 reverts the bare form to the static v1
+// text. The typed argument form rides the allowlisted inject
+// primitive unchanged. Implementation in model-command.ts so it's
 // unit-testable without booting the bot.
-bot.command('model', async ctx => {
-  if (!isAuthorizedSender(ctx)) return
-  const text = ctx.message?.text ?? ctx.channelPost?.text ?? ''
-  const parsed = parseModelCommand(text) ?? { kind: 'show' as const }
-  const reply = await handleModelCommand(parsed, {
-    inject: injectSlashCommandImpl,
+function buildModelDeps(): ModelMenuDeps & ModelCommandDeps {
+  return {
+    discover: (a) => discoverModels(a),
+    select: (a, label) => selectModel(a, label),
+    isBusy: () => currentTurn !== null,
     getAgentName: getMyAgentName,
+    getQuotaBrief: async () => {
+      // Broker-routed probe first (authoritative), local headers as
+      // fallback — same ladder as the boot card / legacy /usage.
+      try {
+        const probed = await probeQuotaForBootCard(getMyAgentName(), 4000)
+        if (probed?.ok) return formatQuotaLine(probed.data)
+      } catch { /* fall through */ }
+      try {
+        const agentDir = resolveAgentDirFromEnv()
+        if (agentDir) {
+          const local = await fetchQuota({ claudeConfigDir: join(agentDir, '.claude') })
+          if (local.ok) return formatQuotaLine(local.data)
+        }
+      } catch { /* quota is garnish — never block the menu on it */ }
+      return null
+    },
+    inject: injectSlashCommandImpl,
     getConfiguredModel: () => {
       type AgentListResp = { agents: Array<{ name: string; model?: string | null }> }
       const data = switchroomExecJson<AgentListResp>(['agent', 'list'])
@@ -13942,7 +13973,30 @@ bot.command('model', async ctx => {
     },
     escapeHtml: escapeHtmlForTg,
     preBlock,
-  })
+  }
+}
+
+function modelMenuReplyMarkup(reply: ModelMenuReply): InlineKeyboard | undefined {
+  if (!reply.keyboard) return undefined
+  const kb = new InlineKeyboard()
+  for (const row of reply.keyboard) {
+    for (const btn of row) kb.text(btn.text, btn.callback_data)
+    kb.row()
+  }
+  return kb
+}
+
+bot.command('model', async ctx => {
+  if (!isAuthorizedSender(ctx)) return
+  const text = ctx.message?.text ?? ctx.channelPost?.text ?? ''
+  const parsed = parseModelCommand(text) ?? { kind: 'show' as const }
+  const deps = buildModelDeps()
+  if (parsed.kind === 'show' && process.env.SWITCHROOM_MODEL_MENU !== '0') {
+    const menu = await buildModelMenu(deps)
+    await switchroomReply(ctx, menu.text, { html: true, reply_markup: modelMenuReplyMarkup(menu) })
+    return
+  }
+  const reply = await handleModelCommand(parsed, deps)
   await switchroomReply(ctx, reply.text, { html: reply.html })
 })
 
@@ -18330,6 +18384,54 @@ bot.on('callback_query:data', async ctx => {
     return
   }
 
+  // `mdl:*` — model-menu taps (/model dashboard). `mdl:s:<tag>`
+  // selects a model by label-tag via a fresh picker discovery (never
+  // a stale index); `mdl:r` re-renders. Strict allowFrom gate like
+  // every other mutating callback family — a model switch changes the
+  // fleet's quota burn profile.
+  if (data.startsWith(MODEL_CALLBACK_PREFIX)) {
+    const access = loadAccess()
+    const senderId = String(ctx.from?.id ?? '')
+    if (!access.allowFrom.includes(senderId)) {
+      await ctx.answerCallbackQuery({ text: 'Not authorized.' })
+      return
+    }
+    // Kill-switch covers the callback family too — stale menus keep
+    // their buttons after the flag flips, and the flag exists exactly
+    // for "picker-driving is misbehaving" (#2263 review blocker 2).
+    if (process.env.SWITCHROOM_MODEL_MENU === '0') {
+      await ctx.answerCallbackQuery({ text: 'Model menu is disabled (SWITCHROOM_MODEL_MENU=0).' }).catch(() => {})
+      await ctx
+        .editMessageText('Model menu is disabled on this agent. Use <code>/model &lt;name&gt;</code>.', {
+          parse_mode: 'HTML',
+          reply_markup: { inline_keyboard: [] },
+        })
+        .catch(() => {})
+      return
+    }
+    // Answer the callback IMMEDIATELY — the select path drives the
+    // picker up to three times (multi-second); leaving the tap
+    // spinning invites a double-tap, which queues a second drive
+    // behind the pane lock and confuses the user. The final state is
+    // conveyed by the message edit (a callback can only be answered
+    // once).
+    await ctx.answerCallbackQuery({ text: 'Working…' }).catch(() => {})
+    try {
+      const outcome = await handleModelMenuCallback(data, buildModelDeps())
+      await ctx
+        .editMessageText(outcome.reply.text, {
+          parse_mode: 'HTML',
+          reply_markup: modelMenuReplyMarkup(outcome.reply) ?? { inline_keyboard: [] },
+        })
+        .catch(() => {})
+    } catch (err) {
+      process.stderr.write(
+        `telegram gateway: model-menu callback failed: ${(err as Error)?.message ?? String(err)}\n`,
+      )
+    }
+    return
+  }
+
   // `cn:cancel:<key>` — cancel a pending Microsoft connect flow (the
   // Cancel button on the /connect card). RFC #1873 Phase 2.
   if (data.startsWith('cn:')) {

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,182 @@ 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,
+    }
+  }
+
+  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(`Now: <b>${deps.escapeHtml(current.label)}</b>${detail}`)
+  } else {
+    lines.push('Now: <i>unknown (no ✔ row in picker)</i>')
+  }
+  if (quota) lines.push(`Quota: ${deps.escapeHtml(quota)}`)
+  lines.push('', 'Tap to switch (applies to the live session):')
+  lines.push(PERSIST_NOTE)
+
+  return { text: lines.join('\n'), html: true, keyboard: menuKeyboard(discovered.options) }
+}
+
+export interface ModelCallbackOutcome {
+  /** 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) }
+  }
+  if (deps.isBusy()) {
+    return { answer: 'Agent is mid-turn — try again shortly', reply: busyReply(deps) }
+  }
+
+  const tag = data.slice(MODEL_CALLBACK_SELECT.length)
+  const discovered = await deps.discover(deps.getAgentName())
+  if (!discovered.ok) {
+    return {
+      answer: 'Picker unavailable',
+      reply: {
+        text: `❌ Could not open the model picker: ${deps.escapeHtml(discovered.reason)}`,
+        html: true,
+      },
+    }
+  }
+  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 }
+  }
+  if (target.current) {
+    const fresh = await buildModelMenu(deps)
+    return { answer: `Already on ${target.label}`, reply: fresh }
+  }
+
+  const result = await deps.select(deps.getAgentName(), target.label)
+  if (!result.ok) {
+    return {
+      answer: 'Switch failed',
+      reply: {
+        text: `❌ Switch to <b>${deps.escapeHtml(target.label)}</b> failed: ${deps.escapeHtml(result.reason)}`,
+        html: true,
+      },
+    }
+  }
+
+  const fresh = await buildModelMenu(deps)
+  const confirmed: ModelMenuReply = {
+    text: [`✅ ${deps.escapeHtml(result.confirmation)}`, '', fresh.text].join('\n'),
+    html: true,
+    ...(fresh.keyboard ? { keyboard: fresh.keyboard } : {}),
+  }
+  return { answer: result.confirmation, reply: confirmed }
+}

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

@@ -203,3 +203,147 @@ describe("inject allowlist contract", () => {
     expect(INJECT_COMMANDS.has("/model")).toBe(true);
   });
 });
+
+// ---------------------------------------------------------------------------
+// Picker-driven menu (v2) — buildModelMenu + handleModelMenuCallback
+// ---------------------------------------------------------------------------
+
+import {
+  buildModelMenu,
+  handleModelMenuCallback,
+  modelSelectCallbackData,
+  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 current model is a no-op refresh", async () => {
+    const { deps, calls } = makeMenuDeps();
+    const out = await handleModelMenuCallback(modelSelectCallbackData("Sonnet"), deps);
+    expect(calls.select).toEqual([]);
+    expect(out.answer).toContain("Already on Sonnet");
+  });
+
+  it("busy agent → never selects", async () => {
+    const { deps, calls } = makeMenuDeps({ isBusy: () => true });
+    const out = await handleModelMenuCallback(modelSelectCallbackData("Haiku"), deps);
+    expect(calls.select).toEqual([]);
+    expect(out.answer).toContain("mid-turn");
+  });
+
+  it("selection failure surfaces the reason", async () => {
+    const { deps } = makeMenuDeps({
+      select: async () => ({ ok: false as const, reason: "cursor verification failed" }),
+    });
+    const out = await handleModelMenuCallback(modelSelectCallbackData("Haiku"), deps);
+    expect(out.answer).toBe("Switch failed");
+    expect(out.reply.text).toContain("cursor verification failed");
+  });
+
+  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/uat/scenarios/jtbd-model-command-dm.test.ts

@@ -0,0 +1,93 @@
+/**
+ * UAT — `/model` Telegram command (PR #2259, shipped v0.15.2).
+ *
+ * Serves: `reference/vision.md` outcome 2 (you hold the leash) — the
+ * operator can see and switch the agent's Claude model from Telegram
+ * without SSH. Session-scoped switch via claude's own `/model <name>`
+ * REPL verb injected into the tmux pane.
+ *
+ * Three assertions against a real agent over real Telegram:
+ *
+ *   1. Bare `/model` → shows the configured model (never opens claude's
+ *      interactive picker — the reply must come from the gateway, fast,
+ *      containing "Configured:").
+ *   2. `/model <valid-name>` → switch is injected; reply relays claude's
+ *      response and carries the session-only persistence note.
+ *   3. `/model bogus-name` → still a reply (claude's inline error is
+ *      relayed, or the empty-capture explanation) — never silence.
+ *
+ * The switch test sets the model to the SAME value the agent already
+ * runs (sonnet) so the canary doesn't leave the harness agent on a
+ * different model afterwards.
+ */
+
+import { describe, it, expect } from "vitest";
+import { spinUp } from "../harness.js";
+
+const AGENT = "test-harness";
+const REPLY_TIMEOUT_MS = 30_000;
+
+describe("uat: /model command — show, switch, bad-name", () => {
+  it(
+    "bare /model shows the model dashboard (menu v2) or static fallback (v1)",
+    async () => {
+      const sc = await spinUp({ agent: AGENT });
+      try {
+        await sc.sendDM("/model");
+        // v2 (picker-driven menu): "Now: <model>"; v1 / fallback path:
+        // "Configured: <model>". Either proves the gateway handled the
+        // command rather than forwarding it to claude as plain text.
+        const shape = /Now:|Configured:/i;
+        const reply = await sc.expectMessage(shape, {
+          from: "bot",
+          timeout: REPLY_TIMEOUT_MS,
+        });
+        expect(reply.text).toMatch(shape);
+        // Persistence caveat present on both shapes
+        expect(reply.text).toMatch(/switchroom\.yaml/i);
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    60_000,
+  );
+
+  it(
+    "/model sonnet switches the live session (same-value, no net change)",
+    async () => {
+      const sc = await spinUp({ agent: AGENT });
+      try {
+        await sc.sendDM("/model sonnet");
+        // Accept either a relayed claude response or the explicit
+        // empty-capture explanation — both prove the command routed
+        // through the gateway handler (and neither is silence).
+        const reply = await sc.expectMessage(
+          /\/model sonnet|no response captured|Session-only/i,
+          { from: "bot", timeout: REPLY_TIMEOUT_MS },
+        );
+        expect(reply.text.length).toBeGreaterThan(0);
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    60_000,
+  );
+
+  it(
+    "/model bogus-name still gets a reply (error relayed, never silence)",
+    async () => {
+      const sc = await spinUp({ agent: AGENT });
+      try {
+        await sc.sendDM("/model bogus-model-name-xyz");
+        const reply = await sc.expectMessage(/\S/, {
+          from: "bot",
+          timeout: REPLY_TIMEOUT_MS,
+        });
+        expect(reply.text.length).toBeGreaterThan(0);
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    60_000,
+  );
+});