switchroom 0.16.5 → 0.16.7

package/dist/cli/switchroom.js

@@ -51674,8 +51674,8 @@ import { existsSync, readFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.16.5";
-var COMMIT_SHA = "6821d14b";
+var VERSION = "0.16.7";
+var COMMIT_SHA = "696eea91";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {
@@ -69841,7 +69841,7 @@ x-litellm-tags: service:hindsight`);
     `--pids-limit=${HINDSIGHT_DEFAULT_PIDS_LIMIT}`,
     `--shm-size=${HINDSIGHT_DEFAULT_SHM_SIZE}`,
     "--health-cmd",
-    HINDSIGHT_HEALTHCHECK_CMD,
+    litellm ? `python3 -c 'import urllib.request,sys; sys.exit(0 if urllib.request.urlopen("http://localhost:${apiPort}/health",timeout=4).getcode()==200 else 1)'` : HINDSIGHT_HEALTHCHECK_CMD,
     "--health-interval",
     "30s",
     "--health-timeout",

package/dist/host-control/main.js

@@ -22587,7 +22587,7 @@ import { existsSync as existsSync6, readFileSync as readFileSync4 } from "node:f
 import { dirname as dirname4, join as join2 } from "node:path";
 
 // src/build-info.ts
-var VERSION = "0.16.5";
+var VERSION = "0.16.7";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "switchroom",
-  "version": "0.16.5",
+  "version": "0.16.7",
   "description": "Run Claude Code 24/7 on your Claude Pro/Max subscription over Telegram. Open-source alternative to OpenClaw and NanoClaw — no API keys.",
   "type": "module",
   "bin": {

package/profiles/_base/cron-session.sh.hbs

@@ -86,6 +86,39 @@ CRON_APPEND_PROMPT="You are the cheap background cron worker for {{name}}. You r
 # (no --continue) — low context by construction. cd into the workspace so
 # claude's project key matches the pre-seeded trust state (.claude-cron).
 cd "{{agentDir}}" || exit 1
+
+# LiteLLM routing for the cron session — mirrors start.sh's boot block.
+# IMPORTANT: the vault key is provisioned under the BASE agent name ({{name}}),
+# NOT the cron identity ({{name}}-cron). Use the Handlebars template var so the
+# lookup is a compile-time literal — no fragile runtime suffix-stripping.
+# Attribution headers carry $SWITCHROOM_AGENT_NAME (= {{name}}-cron) so LiteLLM
+# can distinguish cron spend from main-session spend per agent.
+# FAIL-OPEN: missing key OR unreachable proxy → strip routing env, fall back to
+# direct OAuth. An outage must never take the cron session dark.
+if [ -n "$SWITCHROOM_LITELLM" ] && command -v switchroom >/dev/null 2>&1; then
+  sr_ll_key="$(switchroom vault get "litellm/{{name}}/api-key" 2>/dev/null || true)"
+  sr_ll_ok=""
+  if [ -z "$sr_ll_key" ]; then
+    echo "litellm: no virtual key for cron '{{name}}' — falling back to direct OAuth (no tracking/guardrail)" >&2
+  elif command -v curl >/dev/null 2>&1 && [ -n "$ANTHROPIC_BASE_URL" ] \
+       && ! curl -fsS -m 5 -o /dev/null "${ANTHROPIC_BASE_URL%/}/health/liveliness" 2>/dev/null; then
+    echo "litellm: proxy unreachable at $ANTHROPIC_BASE_URL — falling back to direct OAuth (no tracking/guardrail this session)" >&2
+  else
+    sr_ll_ok="1"
+  fi
+  if [ -n "$sr_ll_ok" ]; then
+    export ANTHROPIC_CUSTOM_HEADERS="x-litellm-api-key: Bearer $sr_ll_key
+x-litellm-customer-id: $SWITCHROOM_AGENT_NAME
+x-litellm-tags: agent:$SWITCHROOM_AGENT_NAME,profile:${SWITCHROOM_AGENT_PROFILE:-default}"
+    export CLAUDE_CODE_ENABLE_GATEWAY_MODEL_DISCOVERY=1
+  else
+    # Fail-open: drop every routing var so the claude CLI talks to Anthropic
+    # directly on its OAuth credential (subscription path), unproxied.
+    unset ANTHROPIC_BASE_URL ANTHROPIC_SMALL_FAST_MODEL SWITCHROOM_LITELLM
+  fi
+  unset sr_ll_key sr_ll_ok
+fi
+
 # Create the cron tmux session DETACHED (-d), not in attach mode. This is a
 # SUPERVISED BACKGROUND sidecar (start.sh forks it with `&`) with no controlling
 # TTY — the MAIN session owns the container's foreground TTY. The attach flag

package/telegram-plugin/dist/gateway/gateway.js

@@ -46101,6 +46101,7 @@ var MODEL_CALLBACK_PREFIX = "mdl:";
 var MODEL_CALLBACK_SELECT = "mdl:s:";
 var MODEL_CALLBACK_REFRESH = "mdl:r";
 var MODEL_CALLBACK_SR = "mdl:sr:";
+var MODEL_CALLBACK_HEADER = "mdl:h";
 var SR_MODEL_LABELS = {
   "sr-gemini-2.5-pro": "Gemini 2.5 Pro",
   "sr-gemini-2.5-flash": "Gemini 2.5 Flash",
@@ -46126,20 +46127,28 @@ function busyReply(deps) {
     html: true
   };
 }
+function headerRow(label) {
+  return [{ text: label, callback_data: MODEL_CALLBACK_HEADER }];
+}
 function menuKeyboard(claudeOptions, srOptions) {
-  const rows = claudeOptions.map((o) => [
-    {
+  const hasBothGroups = claudeOptions.length > 0 && srOptions.length > 0;
+  const rows = [];
+  if (hasBothGroups)
+    rows.push(headerRow("\u2500\u2500 Claude (Max / Pro subscription) \u2500\u2500"));
+  for (const o of claudeOptions) {
+    rows.push([{
       text: o.current ? `\u2705 ${o.label}` : o.label,
       callback_data: modelSelectCallbackData(o.label)
-    }
-  ]);
-  for (const o of srOptions) {
-    rows.push([
-      {
+    }]);
+  }
+  if (srOptions.length > 0) {
+    rows.push(headerRow("\u2500\u2500 OpenRouter / external \u2500\u2500"));
+    for (const o of srOptions) {
+      rows.push([{
         text: `\uD83C\uDF10 ${srFriendlyLabel(o.label)}`,
         callback_data: `${MODEL_CALLBACK_SR}${o.label}`
-      }
-    ]);
+      }]);
+    }
   }
   rows.push([{ text: "\uD83D\uDD04 Refresh", callback_data: MODEL_CALLBACK_REFRESH }]);
   return rows;
@@ -46147,9 +46156,10 @@ function menuKeyboard(claudeOptions, srOptions) {
 async function buildModelMenu(deps) {
   if (deps.isBusy())
     return busyReply(deps);
-  const [discovered, quota] = await Promise.all([
+  const [discovered, quota, srNames] = await Promise.all([
     deps.discover(deps.getAgentName()),
-    deps.getQuotaBrief().catch(() => null)
+    deps.getQuotaBrief().catch(() => null),
+    deps.discoverSrModels().catch(() => [])
   ]);
   if (!discovered.ok) {
     const v1 = await handleModelCommand({ kind: "show" }, deps);
@@ -46159,7 +46169,8 @@ async function buildModelMenu(deps) {
       html: true
     };
   }
-  const { claude: claudeOptions, sr: srOptions } = classifyDiscoveredOptions(discovered.options);
+  const { claude: claudeOptions } = classifyDiscoveredOptions(discovered.options);
+  const srOptions = srNames.map((name, i) => ({ index: i, label: name, detail: "", current: false }));
   const current = claudeOptions.find((o) => o.current);
   const lines = [`<b>Model \u2014 ${deps.escapeHtml(deps.getAgentName())}</b>`];
   if (discovered.dismissFailed) {
@@ -46174,8 +46185,9 @@ async function buildModelMenu(deps) {
   if (quota)
     lines.push(`Quota: ${deps.escapeHtml(quota)}`);
   lines.push("", "Tap a model to switch the <b>live session</b>:");
-  if (srOptions.length > 0)
-    lines.push("\uD83C\uDF10 = non-Anthropic via LiteLLM (session only)");
+  if (srOptions.length > 0) {
+    lines.push("Claude models use your Max/Pro subscription. \uD83C\uDF10 models are billed separately via OpenRouter.");
+  }
   lines.push(PERSIST_NOTE);
   return { text: lines.join(`
 `), html: true, keyboard: menuKeyboard(claudeOptions, srOptions) };
@@ -46184,6 +46196,9 @@ async function handleModelMenuCallback(data, deps) {
   if (data === MODEL_CALLBACK_REFRESH) {
     return { answer: "Refreshed", reply: await buildModelMenu(deps) };
   }
+  if (data === MODEL_CALLBACK_HEADER) {
+    return { answer: "Tap a model in this section to switch", reply: { text: "", html: true }, toastOnly: true };
+  }
   if (data.startsWith(MODEL_CALLBACK_SR)) {
     const srName = data.slice(MODEL_CALLBACK_SR.length);
     if (!isValidModelArg(srName)) {
@@ -55998,10 +56013,10 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.16.5";
-var COMMIT_SHA = "6821d14b";
-var COMMIT_DATE = "2026-06-28T02:45:06Z";
-var LATEST_PR = 2608;
+var VERSION = "0.16.7";
+var COMMIT_SHA = "696eea91";
+var COMMIT_DATE = "2026-06-28T04:56:27Z";
+var LATEST_PR = 2615;
 var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
@@ -65195,6 +65210,27 @@ bot.command("clear", async (ctx) => {
 function buildModelDeps() {
   return {
     discover: (a) => discoverModels(a),
+    discoverSrModels: async () => {
+      const base = process.env.ANTHROPIC_BASE_URL;
+      const headers = process.env.ANTHROPIC_CUSTOM_HEADERS;
+      if (!base || !headers)
+        return [];
+      const keyMatch = headers.match(/x-litellm-api-key:\s*Bearer\s*(\S+)/);
+      if (!keyMatch)
+        return [];
+      try {
+        const res = await fetch(`${base.replace(/\/$/, "")}/model/info`, {
+          headers: { Authorization: `Bearer ${keyMatch[1]}` },
+          signal: AbortSignal.timeout(5000)
+        });
+        if (!res.ok)
+          return [];
+        const data = await res.json();
+        return (data.data ?? []).map((m) => m.model_name).filter((n) => n.startsWith("sr-")).sort();
+      } catch {
+        return [];
+      }
+    },
     select: (a, label) => selectModel(a, label),
     isBusy: () => currentTurn !== null,
     getAgentName: getMyAgentName,
@@ -68141,6 +68177,10 @@ bot.on("callback_query:data", async (ctx) => {
       await ctx.answerCallbackQuery({ text: "\u23F3 Agent is mid-turn \u2014 tap again when it\u2019s idle", show_alert: false }).catch(() => {});
       return;
     }
+    if (data === MODEL_CALLBACK_HEADER) {
+      await ctx.answerCallbackQuery({ text: "Tap a model in this section to switch" }).catch(() => {});
+      return;
+    }
     await ctx.answerCallbackQuery({ text: "Switching\u2026" }).catch(() => {});
     try {
       const outcome = await handleModelMenuCallback(data, modelDeps);

package/telegram-plugin/gateway/gateway.ts

@@ -276,6 +276,7 @@ import {
   buildModelMenu,
   handleModelMenuCallback,
   MODEL_CALLBACK_PREFIX,
+  MODEL_CALLBACK_HEADER,
   type ModelMenuDeps,
   type ModelCommandDeps,
   type ModelMenuReply,
@@ -15980,6 +15981,27 @@ bot.command('clear', async ctx => {
 function buildModelDeps(): ModelMenuDeps & ModelCommandDeps {
   return {
     discover: (a) => discoverModels(a),
+    discoverSrModels: async () => {
+      const base = process.env.ANTHROPIC_BASE_URL
+      const headers = process.env.ANTHROPIC_CUSTOM_HEADERS
+      if (!base || !headers) return []
+      const keyMatch = headers.match(/x-litellm-api-key:\s*Bearer\s*(\S+)/)
+      if (!keyMatch) return []
+      try {
+        const res = await fetch(`${base.replace(/\/$/, '')}/model/info`, {
+          headers: { Authorization: `Bearer ${keyMatch[1]}` },
+          signal: AbortSignal.timeout(5000),
+        })
+        if (!res.ok) return []
+        const data = (await res.json()) as { data?: Array<{ model_name: string }> }
+        return (data.data ?? [])
+          .map((m) => m.model_name)
+          .filter((n) => n.startsWith('sr-'))
+          .sort()
+      } catch {
+        return []
+      }
+    },
     select: (a, label) => selectModel(a, label),
     isBusy: () => currentTurn !== null,
     getAgentName: getMyAgentName,
@@ -20721,6 +20743,11 @@ bot.on('callback_query:data', async ctx => {
     // drive behind the pane lock. A callback can only be answered once, so
     // the rich result (what was set / why it failed) is conveyed by the
     // message edit — which now ALWAYS keeps the menu buttons.
+    // Header rows are section labels — informational, no model switch.
+    if (data === MODEL_CALLBACK_HEADER) {
+      await ctx.answerCallbackQuery({ text: 'Tap a model in this section to switch' }).catch(() => {})
+      return
+    }
     await ctx.answerCallbackQuery({ text: 'Switching…' }).catch(() => {})
     try {
       const outcome = await handleModelMenuCallback(data, modelDeps)

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

@@ -214,6 +214,11 @@ export interface ModelMenuDeps {
   getAgentName: () => string
   /** One-line quota summary (e.g. "29% / 5h · 33% / 7d") or null. */
   getQuotaBrief: () => Promise<string | null>
+  /**
+   * Fetch sr-* model names available via LiteLLM for this agent.
+   * Returns [] when LiteLLM is not configured or the probe fails.
+   */
+  discoverSrModels: () => Promise<string[]>
   escapeHtml: (s: string) => string
 }
 
@@ -235,6 +240,8 @@ const MODEL_CALLBACK_SELECT = 'mdl:s:'
 export const MODEL_CALLBACK_REFRESH = 'mdl:r'
 /** Callback prefix for sr-* (LiteLLM non-Anthropic) model selection. */
 export const MODEL_CALLBACK_SR = 'mdl:sr:'
+/** Callback for section-header rows — shows an informational toast, no action. */
+export const MODEL_CALLBACK_HEADER = 'mdl:h'
 
 /**
  * Friendly display names for sr-* synthetic model names. An sr-* model in
@@ -296,29 +303,38 @@ function busyReply(deps: Pick<ModelMenuDeps, 'escapeHtml'>): ModelMenuReply {
   }
 }
 
+function headerRow(label: string): ModelMenuKeyboardButton[] {
+  return [{ text: label, callback_data: MODEL_CALLBACK_HEADER }]
+}
+
 function menuKeyboard(
   claudeOptions: ModelPickerOption[],
   srOptions: ModelPickerOption[],
 ): ModelMenuKeyboardButton[][] {
-  // One option per row (labels + ✔ render cleanly at full width on
-  // mobile), refresh on a trailing row.
-  const rows: ModelMenuKeyboardButton[][] = claudeOptions.map((o) => [
-    {
+  const hasBothGroups = claudeOptions.length > 0 && srOptions.length > 0
+  const rows: ModelMenuKeyboardButton[][] = []
+
+  if (hasBothGroups) rows.push(headerRow('── Claude (Max / Pro subscription) ──'))
+  for (const o of claudeOptions) {
+    rows.push([{
       text: o.current ? `✅ ${o.label}` : o.label,
       callback_data: modelSelectCallbackData(o.label),
-    },
-  ])
+    }])
+  }
+
   // sr-* models are non-Anthropic (routed via LiteLLM → OpenRouter).
   // Selection uses text-inject rather than cursor-nav — more reliable
   // when the picker has many models (GATEWAY_MODEL_DISCOVERY=1).
-  for (const o of srOptions) {
-    rows.push([
-      {
+  if (srOptions.length > 0) {
+    rows.push(headerRow('── OpenRouter / external ──'))
+    for (const o of srOptions) {
+      rows.push([{
         text: `🌐 ${srFriendlyLabel(o.label)}`,
         callback_data: `${MODEL_CALLBACK_SR}${o.label}`,
-      },
-    ])
+      }])
+    }
   }
+
   rows.push([{ text: '🔄 Refresh', callback_data: MODEL_CALLBACK_REFRESH }])
   return rows
 }
@@ -333,9 +349,10 @@ export async function buildModelMenu(
 ): Promise<ModelMenuReply> {
   if (deps.isBusy()) return busyReply(deps)
 
-  const [discovered, quota] = await Promise.all([
+  const [discovered, quota, srNames] = await Promise.all([
     deps.discover(deps.getAgentName()),
     deps.getQuotaBrief().catch(() => null),
+    deps.discoverSrModels().catch(() => [] as string[]),
   ])
 
   if (!discovered.ok) {
@@ -353,7 +370,10 @@ export async function buildModelMenu(
   // 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 { claude: claudeOptions, sr: srOptions } = classifyDiscoveredOptions(discovered.options)
+  // sr-* models come from LiteLLM (/model/info via discoverSrModels), not the
+  // claude picker — the CLI only knows Anthropic models.
+  const { claude: claudeOptions } = classifyDiscoveredOptions(discovered.options)
+  const srOptions: ModelPickerOption[] = srNames.map((name, i) => ({ index: i, label: name, detail: '', current: false }))
   const current = claudeOptions.find((o) => o.current)
   const lines: string[] = [`<b>Model — ${deps.escapeHtml(deps.getAgentName())}</b>`]
   if (discovered.dismissFailed) {
@@ -367,7 +387,9 @@ export async function buildModelMenu(
   }
   if (quota) lines.push(`Quota: ${deps.escapeHtml(quota)}`)
   lines.push('', 'Tap a model to switch the <b>live session</b>:')
-  if (srOptions.length > 0) lines.push('🌐 = non-Anthropic via LiteLLM (session only)')
+  if (srOptions.length > 0) {
+    lines.push('Claude models use your Max/Pro subscription. 🌐 models are billed separately via OpenRouter.')
+  }
   lines.push(PERSIST_NOTE)
 
   return { text: lines.join('\n'), html: true, keyboard: menuKeyboard(claudeOptions, srOptions) }
@@ -410,6 +432,13 @@ export async function handleModelMenuCallback(
     return { answer: 'Refreshed', reply: await buildModelMenu(deps) }
   }
 
+  if (data === MODEL_CALLBACK_HEADER) {
+    // Section-header row — the gateway handles this with a direct answerCallbackQuery
+    // before calling this function, so this branch is dead in practice. Guard
+    // for callers that skip gateway.ts (tests, future refactors).
+    return { answer: 'Tap a model in this section to switch', reply: { text: '', html: true }, toastOnly: true }
+  }
+
   // sr-* model tap: text-inject `/model sr-<name>` rather than cursor-nav.
   // Text-inject is more reliable when the picker has many models; sr-* names
   // are safe (no entry in model_group_settings → no OAuth forwarding). See I6.

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

@@ -255,6 +255,7 @@ import {
   sessionModelFromConfirmation,
   classifyDiscoveredOptions,
   MODEL_CALLBACK_REFRESH,
+  MODEL_CALLBACK_HEADER,
   MODEL_CALLBACK_SR,
   SR_MODEL_LABELS,
   type ModelMenuDeps,
@@ -282,6 +283,7 @@ function makeMenuDeps(overrides: Partial<ModelMenuDeps> = {}) {
     },
     isBusy: () => false,
     getQuotaBrief: async () => "29% / 5h · 33% / 7d",
+    discoverSrModels: async () => [],
     ...overrides,
   };
   return { deps, calls, injectCalls: base.calls };
@@ -474,13 +476,10 @@ describe("SR_MODEL_LABELS", () => {
 });
 
 describe("buildModelMenu — with sr-* models", () => {
+  // sr-* models now come from discoverSrModels (LiteLLM), not the claude picker.
   function makeMenuDepsWithSr(overrides: Partial<ModelMenuDeps> = {}) {
     return makeMenuDeps({
-      discover: async () => ({
-        ok: true as const,
-        options: OPTIONS_WITH_SR,
-        currentLabel: "Sonnet",
-      }),
+      discoverSrModels: async () => ["sr-gemini-2.5-pro", "sr-deepseek-r1"],
       ...overrides,
     });
   }
@@ -506,27 +505,50 @@ describe("buildModelMenu — with sr-* models", () => {
     expect(srButton?.callback_data).toBe(`${MODEL_CALLBACK_SR}sr-gemini-2.5-pro`);
   });
 
-  it("shows 🌐 = non-Anthropic legend when sr-* models are present", async () => {
+  it("shows section header rows when both claude and sr-* models present", async () => {
     const { deps } = makeMenuDepsWithSr();
     const menu = await buildModelMenu(deps);
-    expect(menu.text).toContain("🌐 = non-Anthropic");
+    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");
+  });
+
+  it("no section headers when only claude models (no sr-*)", 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);
+    expect(headers.length).toBe(0);
+  });
+
+  it("header-row tap returns toastOnly without inject or model change", async () => {
+    const { deps, injectCalls } = makeMenuDepsWithSr();
+    const out = await handleModelMenuCallback(MODEL_CALLBACK_HEADER, deps);
+    expect(out.toastOnly).toBe(true);
+    expect(out.selectedModel).toBeUndefined();
+    expect(injectCalls).toHaveLength(0);
+  });
+
+  it("shows subscription/OpenRouter legend when sr-* models are present", async () => {
+    const { deps } = makeMenuDepsWithSr();
+    const menu = await buildModelMenu(deps);
+    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("🌐 = non-Anthropic");
+    expect(menu.text).not.toContain("OpenRouter");
   });
 });
 
 describe("handleModelMenuCallback — sr-* selection", () => {
   function makeMenuDepsWithSr(overrides: Partial<ModelMenuDeps> = {}) {
     return makeMenuDeps({
-      discover: async () => ({
-        ok: true as const,
-        options: OPTIONS_WITH_SR,
-        currentLabel: "Sonnet",
-      }),
+      discoverSrModels: async () => ["sr-gemini-2.5-pro", "sr-deepseek-r1"],
       ...overrides,
     });
   }

package/telegram-plugin/uat/scenarios/jtbd-model-litellm-sr-dm.test.ts

@@ -0,0 +1,147 @@
+/**
+ * UAT — /model with LiteLLM sr-* (OpenRouter) model switching + spend tracking.
+ *
+ * Covers:
+ *   1. /model menu shows section headers ("Claude (Max / Pro subscription)" and
+ *      "OpenRouter / external") when sr-* models are available.
+ *   2. Tapping an sr-* button switches the live session (text-inject path,
+ *      not cursor-nav) and the confirmation banner appears.
+ *   3. After switching, the agent replies on the new model, and LiteLLM
+ *      spend logs show agent:test-harness attribution.
+ *   4. Session resets to the configured model on restart (out of scope for
+ *      this test — asserted in jtbd-always-on-after-restart-dm).
+ *
+ * Self-skips green when:
+ *   - SWITCHROOM_UAT_DRIVER_SESSION is not set (no Telegram driver)
+ *   - LiteLLM admin key unavailable (SWITCHROOM_UAT_LITELLM_ADMIN_KEY unset)
+ *   - No sr-* buttons found in the menu (agent not LiteLLM-enabled or no
+ *     sr-* models registered in LiteLLM)
+ */
+
+import { describe, expect, it } from "vitest";
+import { spinUp } from "../harness.js";
+
+const AGENT = "test-harness";
+const LITELLM_URL = process.env.SWITCHROOM_UAT_LITELLM_URL ?? "http://127.0.0.1:4010";
+const LITELLM_ADMIN_KEY = process.env.SWITCHROOM_UAT_LITELLM_ADMIN_KEY ?? "";
+
+async function getLiteLLMSpendForAgent(agent: string): Promise<number> {
+  if (!LITELLM_ADMIN_KEY) return -1;
+  const res = await fetch(`${LITELLM_URL}/spend/tags`, {
+    headers: { Authorization: `Bearer ${LITELLM_ADMIN_KEY}` },
+  }).catch(() => null);
+  if (!res?.ok) return -1;
+  const tags: Array<{ individual_request_tag: string; log_count: number }> = await res.json();
+  return tags.find((t) => t.individual_request_tag === `agent:${agent}`)?.log_count ?? 0;
+}
+
+describe("uat: /model sr-* LiteLLM routing — section headers + session switch + spend attribution", () => {
+  it(
+    "menu shows Claude/OpenRouter section headers, sr-* tap switches session and LiteLLM logs the request",
+    async () => {
+      const sc = await spinUp({ agent: AGENT });
+      try {
+        await sc.sendDM("/model");
+        const menu = await sc.expectMessage(/Default \(new sessions\):/i, {
+          from: "bot",
+          timeout: 30_000,
+        });
+
+        // ── 1. Section headers ──────────────────────────────────────────
+        const kb = await sc.driver.getKeyboard(sc.botUserId, menu.messageId);
+        const flat = (kb ?? []).flat().filter((b) => b.callbackData);
+
+        const claudeHeader = flat.find(
+          (b) => b.text.includes("Claude") && b.text.includes("subscription") && b.callbackData === "mdl:h",
+        );
+        const openrouterHeader = flat.find(
+          (b) => b.text.includes("OpenRouter") && b.callbackData === "mdl:h",
+        );
+        const srButton = flat.find((b) => b.callbackData?.startsWith("mdl:sr:"));
+
+        if (!srButton) {
+          console.log("No sr-* buttons in menu — agent not LiteLLM-enabled or no sr-* models registered. Skipping.");
+          return;
+        }
+
+        expect(claudeHeader, "Claude (Max / Pro subscription) header row").toBeDefined();
+        expect(openrouterHeader, "OpenRouter / external header row").toBeDefined();
+        expect(menu.text).toContain("Max/Pro subscription");
+        expect(menu.text).toContain("OpenRouter");
+
+        // ── 2. sr-* switch ─────────────────────────────────────────────
+        const spendBefore = await getLiteLLMSpendForAgent(AGENT);
+        const srName = srButton.callbackData!.replace("mdl:sr:", "");
+
+        await sc.driver.pressButton(sc.botUserId, menu.messageId, srButton.callbackData!);
+        // Allow text-inject + claude's /model response to propagate
+        await new Promise((r) => setTimeout(r, 8_000));
+
+        const afterMenu = await sc.driver.getMessage(sc.botUserId, menu.messageId);
+        expect(afterMenu?.text ?? "", "confirmation banner after sr-* tap").toMatch(
+          /Set model to|Switched|session/i,
+        );
+        // Card must keep its buttons (#2270 — no dead card)
+        const kbAfter = await sc.driver.getKeyboard(sc.botUserId, menu.messageId);
+        expect((kbAfter ?? []).flat().length, "menu keeps buttons after sr-* tap").toBeGreaterThan(0);
+
+        // ── 3. Send a quick message to generate a LiteLLM-routed turn ──
+        await sc.sendDM("Just reply with the word OK.");
+        await sc.expectMessage(/ok/i, { from: "bot", timeout: 60_000 });
+
+        // ── 4. LiteLLM spend attribution ────────────────────────────────
+        if (spendBefore >= 0) {
+          // Give LiteLLM a moment to flush the log
+          await new Promise((r) => setTimeout(r, 3_000));
+          const spendAfter = await getLiteLLMSpendForAgent(AGENT);
+          expect(spendAfter, `agent:${AGENT} log_count increased after turn`).toBeGreaterThan(spendBefore);
+        }
+
+        // ── Restore: switch back to configured model ────────────────────
+        const currentKb = await sc.driver.getKeyboard(sc.botUserId, menu.messageId);
+        const restoreBtn = (currentKb ?? []).flat().find(
+          (b) => b.callbackData?.startsWith("mdl:s:") && /Default|Sonnet|claude-sonnet/i.test(b.text),
+        );
+        if (restoreBtn?.callbackData) {
+          await sc.driver.pressButton(sc.botUserId, menu.messageId, restoreBtn.callbackData);
+          await new Promise((r) => setTimeout(r, 4_000));
+        }
+
+        console.log(`✅ sr-* model switch (${srName}) verified end-to-end through LiteLLM`);
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    180_000,
+  );
+
+  it(
+    "header row tap shows toast without switching model or opening picker",
+    async () => {
+      const sc = await spinUp({ agent: AGENT });
+      try {
+        await sc.sendDM("/model");
+        const menu = await sc.expectMessage(/Default \(new sessions\):/i, {
+          from: "bot",
+          timeout: 30_000,
+        });
+        const kb = await sc.driver.getKeyboard(sc.botUserId, menu.messageId);
+        const flat = (kb ?? []).flat();
+        const headerBtn = flat.find((b) => b.callbackData === "mdl:h");
+        if (!headerBtn) {
+          console.log("No header row — agent not LiteLLM-enabled. Skipping.");
+          return;
+        }
+        // Pressing the header should NOT change the menu text
+        const textBefore = menu.text;
+        await sc.driver.pressButton(sc.botUserId, menu.messageId, "mdl:h");
+        await new Promise((r) => setTimeout(r, 3_000));
+        const after = await sc.driver.getMessage(sc.botUserId, menu.messageId);
+        expect(after?.text ?? "").toBe(textBefore);
+      } finally {
+        await sc.tearDown();
+      }
+    },
+    60_000,
+  );
+});