switchroom 0.16.8 → 0.16.9

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.8";
-var COMMIT_SHA = "c2668516";
+var VERSION = "0.16.9";
+var COMMIT_SHA = "1a926737";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {

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.8";
+var VERSION = "0.16.9";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {

package/package.json

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

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

@@ -46004,6 +46004,15 @@ var MODEL_ARG_RE = /^[A-Za-z0-9][A-Za-z0-9._\[\]-]{0,99}$/;
 function isValidModelArg(arg) {
   return MODEL_ARG_RE.test(arg);
 }
+function isSrModel(name) {
+  return name.startsWith("sr-");
+}
+function isClaudeModel(name) {
+  const lower = name.toLowerCase();
+  if (MODEL_ALIASES.includes(lower))
+    return true;
+  return lower.startsWith("claude-");
+}
 function parseModelCommand(text) {
   const m = text.match(/^\/model(?:@[A-Za-z0-9_]+)?(?:\s+([\s\S]*))?$/);
   if (!m)
@@ -46053,6 +46062,26 @@ async function handleModelCommand(parsed, deps) {
   if (!isValidModelArg(parsed.model)) {
     return helpText2(deps, `not a valid model name: ${parsed.model}`);
   }
+  const currentSession = deps.getActiveSessionModel();
+  if (currentSession !== null && isSrModel(currentSession) && isClaudeModel(parsed.model)) {
+    try {
+      await deps.scheduleRestart(`user: /model ${parsed.model} (sr-to-claude restart)`);
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return {
+        text: `\u274c Could not schedule restart: ${deps.escapeHtml(msg)}`,
+        html: true
+      };
+    }
+    return {
+      text: [
+        `Switching from <code>${deps.escapeHtml(currentSession)}</code> back to Claude \u2014 restarting session cleanly. Claude will be ready in ~30s.`,
+        PERSIST_NOTE
+      ].join(`
+`),
+      html: true
+    };
+  }
   const verbHtml = `<code>/model ${deps.escapeHtml(parsed.model)}</code>`;
   let result;
   try {
@@ -46272,6 +46301,9 @@ async function handleModelMenuCallback(data, deps) {
     selectedModel: sessionModelFromConfirmation(result.confirmation) ?? target.label
   };
 }
+function isSrToClaudeTransition(prevModel, nextModel) {
+  return !!prevModel?.startsWith("sr-") && !nextModel.startsWith("sr-");
+}
 function sessionModelFromConfirmation(confirmation) {
   const m = /(?:Set model to|Switched to)\s+(.+?)(?:\s+for (?:this|the) session|\s*\(|\s*$)/i.exec(confirmation.trim());
   const name = m?.[1]?.trim();
@@ -56015,11 +56047,11 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.16.8";
-var COMMIT_SHA = "c2668516";
-var COMMIT_DATE = "2026-06-28T15:28:08+10:00";
-var LATEST_PR = null;
-var COMMITS_AHEAD_OF_TAG = 5;
+var VERSION = "0.16.9";
+var COMMIT_SHA = "1a926737";
+var COMMIT_DATE = "2026-06-28T06:20:58Z";
+var LATEST_PR = 2622;
+var COMMITS_AHEAD_OF_TAG = 0;
 
 // gateway/boot-version.ts
 function formatRelativeAgo(iso) {
@@ -65209,7 +65241,7 @@ bot.command("compact", async (ctx) => {
 bot.command("clear", async (ctx) => {
   await handleInjectCommand(ctx, buildInjectDeps({ open: true, fixedVerb: "/clear" }));
 });
-function buildModelDeps() {
+function buildModelDeps(restartCtx) {
   return {
     discover: (a) => discoverModels(a),
     discoverSrModels: async () => {
@@ -65258,7 +65290,39 @@ function buildModelDeps() {
       return data?.agents?.find((a) => a.name === getMyAgentName())?.model ?? null;
     },
     escapeHtml: escapeHtmlForTg,
-    preBlock
+    preBlock,
+    getActiveSessionModel: () => activeSessionModelOverride,
+    scheduleRestart: async (reason) => {
+      const name = getMyAgentName();
+      const existing = readRestartMarker();
+      if (existing && Date.now() - existing.ts < 15000)
+        return;
+      if (restartCtx) {
+        writeRestartMarker({
+          chat_id: restartCtx.chatId,
+          thread_id: restartCtx.threadId ?? null,
+          ack_message_id: null,
+          ts: Date.now()
+        });
+      }
+      stampUserRestartReason(reason);
+      await sweepBeforeSelfRestart();
+      const hostdResp = await tryHostdDispatch(name, {
+        v: 1,
+        op: "agent_restart",
+        request_id: hostdRequestId("gw-model-restart"),
+        args: { name, force: true, reason }
+      });
+      if (hostdResp === "not-configured") {
+        warnLegacySpawnIfHostdDisabled("agent_restart");
+        spawnSwitchroomDetached(["agent", "restart", name, "--force"], notifyDetachedFailure(restartCtx?.chatId ?? "", restartCtx?.threadId ?? null, `restart ${name}`));
+        return;
+      }
+      if (hostdResp.result !== "started" && hostdResp.result !== "completed") {
+        clearRestartMarker();
+        throw new Error(`hostd restart failed (result=${hostdResp.result}): ${hostdResp.error ?? "(no details)"}`);
+      }
+    }
   };
 }
 function modelMenuReplyMarkup(reply) {
@@ -65277,7 +65341,9 @@ bot.command("model", async (ctx) => {
     return;
   const text2 = ctx.message?.text ?? ctx.channelPost?.text ?? "";
   const parsed = parseModelCommand(text2) ?? { kind: "show" };
-  const deps = buildModelDeps();
+  const chatId = String(ctx.chat.id);
+  const threadId = resolveThreadId(chatId, ctx.message?.message_thread_id);
+  const deps = buildModelDeps({ chatId, threadId });
   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) });
@@ -68174,7 +68240,9 @@ bot.on("callback_query:data", async (ctx) => {
       }).catch(() => {});
       return;
     }
-    const modelDeps = buildModelDeps();
+    const cbChatId = String(ctx.chat?.id ?? "");
+    const cbThreadId = resolveThreadId(cbChatId, ctx.callbackQuery?.message?.message_thread_id);
+    const modelDeps = buildModelDeps({ chatId: cbChatId, threadId: cbThreadId });
     if (modelDeps.isBusy()) {
       await ctx.answerCallbackQuery({ text: "\u23F3 Agent is mid-turn \u2014 tap again when it\u2019s idle", show_alert: false }).catch(() => {});
       return;
@@ -68185,12 +68253,25 @@ bot.on("callback_query:data", async (ctx) => {
     }
     await ctx.answerCallbackQuery({ text: "Switching\u2026" }).catch(() => {});
     try {
+      const prevSessionModel = activeSessionModelOverride;
       const outcome = await handleModelMenuCallback(data, modelDeps);
       if (outcome.selectedModel) {
         activeSessionModelOverride = outcome.selectedModel;
       }
       if (outcome.toastOnly)
         return;
+      if (outcome.selectedModel && isSrToClaudeTransition(prevSessionModel, outcome.selectedModel)) {
+        const agentName3 = getMyAgentName();
+        await ctx.editMessageText(`\uD83D\uDD04 Switching from <b>${escapeHtmlForTg(prevSessionModel)}</b> back to Claude \u2014 restarting session cleanly. Claude will be ready in ~30s.`, { parse_mode: "HTML", reply_markup: { inline_keyboard: [] } }).catch(() => {});
+        writeRestartMarker({ chat_id: cbChatId, thread_id: cbThreadId ?? null, ack_message_id: null, ts: Date.now() });
+        stampUserRestartReason("user: sr-to-claude model switch (menu)");
+        if (turnInFlightForGate()) {
+          pendingRestarts.set(agentName3, Date.now());
+        } else {
+          sweepBeforeSelfRestart().finally(() => triggerSelfRestart(agentName3, "sr-to-claude-model-switch", 1500));
+        }
+        return;
+      }
       await ctx.editMessageText(outcome.reply.text, {
         parse_mode: "HTML",
         reply_markup: modelMenuReplyMarkup(outcome.reply) ?? { inline_keyboard: [] }

package/telegram-plugin/gateway/gateway.ts

@@ -275,6 +275,7 @@ import {
   handleModelCommand,
   buildModelMenu,
   handleModelMenuCallback,
+  isSrToClaudeTransition,
   MODEL_CALLBACK_PREFIX,
   MODEL_CALLBACK_HEADER,
   type ModelMenuDeps,
@@ -15978,7 +15979,12 @@ bot.command('clear', async ctx => {
 // 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.
-function buildModelDeps(): ModelMenuDeps & ModelCommandDeps {
+interface ModelDepsRestartContext {
+  chatId: string
+  threadId: number | undefined
+}
+
+function buildModelDeps(restartCtx?: ModelDepsRestartContext): ModelMenuDeps & ModelCommandDeps {
   return {
     discover: (a) => discoverModels(a),
     discoverSrModels: async () => {
@@ -16029,6 +16035,55 @@ function buildModelDeps(): ModelMenuDeps & ModelCommandDeps {
     },
     escapeHtml: escapeHtmlForTg,
     preBlock,
+    getActiveSessionModel: () => activeSessionModelOverride,
+    /**
+     * Graceful restart for sr-* → Claude model switch. Same mechanism as
+     * the /restart command: writes a restart marker (so the post-restart
+     * greeting lands in the originating chat), stamps the reason, and
+     * dispatches via hostd (or legacy detached spawn as fallback).
+     */
+    scheduleRestart: async (reason: string) => {
+      const name = getMyAgentName()
+      // Debounce: mirror the /restart command's 15 s guard to prevent
+      // double-dispatch on a rapid double-tap of /model <claude-alias>.
+      const existing = readRestartMarker()
+      if (existing && Date.now() - existing.ts < 15_000) return
+      if (restartCtx) {
+        writeRestartMarker({
+          chat_id: restartCtx.chatId,
+          thread_id: restartCtx.threadId ?? null,
+          ack_message_id: null,
+          ts: Date.now(),
+        })
+      }
+      stampUserRestartReason(reason)
+      await sweepBeforeSelfRestart()
+      const hostdResp = await tryHostdDispatch(name, {
+        v: 1,
+        op: 'agent_restart',
+        request_id: hostdRequestId('gw-model-restart'),
+        args: { name, force: true, reason },
+      })
+      if (hostdResp === 'not-configured') {
+        warnLegacySpawnIfHostdDisabled('agent_restart')
+        spawnSwitchroomDetached(
+          ['agent', 'restart', name, '--force'],
+          notifyDetachedFailure(
+            restartCtx?.chatId ?? '',
+            restartCtx?.threadId ?? null,
+            `restart ${name}`,
+          ),
+        )
+        return
+      }
+      // hostd is configured but returned an error/denied result.
+      if (hostdResp.result !== 'started' && hostdResp.result !== 'completed') {
+        clearRestartMarker()
+        throw new Error(
+          `hostd restart failed (result=${hostdResp.result}): ${hostdResp.error ?? '(no details)'}`,
+        )
+      }
+    },
   }
 }
 
@@ -16046,7 +16101,9 @@ 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()
+  const chatId = String(ctx.chat!.id)
+  const threadId = resolveThreadId(chatId, ctx.message?.message_thread_id)
+  const deps = buildModelDeps({ chatId, threadId })
   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) })
@@ -20726,7 +20783,9 @@ bot.on('callback_query:data', async ctx => {
         .catch(() => {})
       return
     }
-    const modelDeps = buildModelDeps()
+    const cbChatId = String(ctx.chat?.id ?? '')
+    const cbThreadId = resolveThreadId(cbChatId, ctx.callbackQuery?.message?.message_thread_id)
+    const modelDeps = buildModelDeps({ chatId: cbChatId, threadId: cbThreadId })
     // Mid-turn refusal is INSTANT (a sync isBusy() check, no picker drive),
     // so handle it before the "Working…" ack: toast WHY and leave the menu
     // message untouched (buttons intact) so the operator taps again when
@@ -20750,6 +20809,7 @@ bot.on('callback_query:data', async ctx => {
     }
     await ctx.answerCallbackQuery({ text: 'Switching…' }).catch(() => {})
     try {
+      const prevSessionModel = activeSessionModelOverride
       const outcome = await handleModelMenuCallback(data, modelDeps)
       // Record a successful session switch so /status reflects what's
       // actually running. In-memory only → clears when the gateway (and thus
@@ -20760,6 +20820,35 @@ bot.on('callback_query:data', async ctx => {
       // toastOnly: a no-op outcome that should not disturb the menu (defence
       // in depth — the isBusy() short-circuit above is the live path).
       if (outcome.toastOnly) return
+
+      // sr-* → Claude transition via the model menu: trigger a graceful restart.
+      // Switching FROM an sr-* (LiteLLM/OpenRouter) model BACK to a Claude model
+      // via the picker requires a session restart — the picker-select only changes
+      // the session model label, but the sr-* LiteLLM routing context persists
+      // until the session is torn down. Same mechanism as the /restart command.
+      if (outcome.selectedModel && isSrToClaudeTransition(prevSessionModel, outcome.selectedModel)) {
+        const agentName = getMyAgentName()
+        // Replace the menu with a restart notice (no buttons — session is ending).
+        await ctx
+          .editMessageText(
+            `🔄 Switching from <b>${escapeHtmlForTg(prevSessionModel!)}</b> back to Claude — restarting session cleanly. Claude will be ready in ~30s.`,
+            { parse_mode: 'HTML', reply_markup: { inline_keyboard: [] } },
+          )
+          .catch(() => {})
+        // Write the restart marker so the post-restart boot card edits into this chat.
+        writeRestartMarker({ chat_id: cbChatId, thread_id: cbThreadId ?? null, ack_message_id: null, ts: Date.now() })
+        stampUserRestartReason('user: sr-to-claude model switch (menu)')
+        if (turnInFlightForGate()) {
+          // Defer restart until the in-flight turn completes (same gate as /restart).
+          pendingRestarts.set(agentName, Date.now())
+        } else {
+          void sweepBeforeSelfRestart().finally(() =>
+            triggerSelfRestart(agentName, 'sr-to-claude-model-switch', 1500),
+          )
+        }
+        return
+      }
+
       await ctx
         .editMessageText(outcome.reply.text, {
           parse_mode: 'HTML',

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

@@ -62,6 +62,23 @@ export function isValidModelArg(arg: string): boolean {
   return MODEL_ARG_RE.test(arg)
 }
 
+/** True when `name` is an sr-* (LiteLLM/OpenRouter) model identifier. */
+export function isSrModel(name: string): boolean {
+  return name.startsWith('sr-')
+}
+
+/**
+ * True when `name` is a Claude model — either a well-known alias or a
+ * full `claude-*` id (including `[1m]` variants). This is intentionally
+ * broader than MODEL_ALIASES: any `claude-…` string from claude's own
+ * picker (e.g. `claude-opus-4-8`) qualifies.
+ */
+export function isClaudeModel(name: string): boolean {
+  const lower = name.toLowerCase()
+  if ((MODEL_ALIASES as readonly string[]).includes(lower)) return true
+  return lower.startsWith('claude-')
+}
+
 export type ParsedModelCommand =
   | { kind: 'show' }
   | { kind: 'set'; model: string }
@@ -100,6 +117,22 @@ export interface ModelCommandDeps {
   getConfiguredModel: () => string | null
   escapeHtml: (s: string) => string
   preBlock: (s: string) => string
+  /**
+   * The active session-model override set by a prior `/model` switch.
+   * Null when no session override is active (using configured/default model).
+   * Used to detect whether the current session is on an sr-* (OpenRouter)
+   * model so a switch back to Claude can trigger a graceful restart instead
+   * of an in-place inject (which would leave stale sr-* routing in place).
+   */
+  getActiveSessionModel: () => string | null
+  /**
+   * Schedule a graceful restart of this agent. Called instead of inject
+   * when switching from an sr-* model back to Claude — the restart clears
+   * the sr-* session context cleanly, whereas an in-place inject would
+   * leave LiteLLM routing active. The gateway wires this to the same
+   * mechanism as the `/restart` command (hostd-first, SIGTERM fallback).
+   */
+  scheduleRestart: (reason: string) => Promise<void>
 }
 
 export interface ModelCommandReply {
@@ -148,6 +181,32 @@ export async function handleModelCommand(
   if (!isValidModelArg(parsed.model)) {
     return helpText(deps, `not a valid model name: ${parsed.model}`)
   }
+
+  // sr-* → Claude: an in-place `/model` inject would leave LiteLLM routing
+  // active in the live session because the sr-* model context was set by
+  // the proxy at session start, not by claude's own REPL. A graceful restart
+  // is the only clean path back to the native OAuth route. This matches the
+  // behaviour of the `/restart` command (same mechanism, same marker logic).
+  const currentSession = deps.getActiveSessionModel()
+  if (currentSession !== null && isSrModel(currentSession) && isClaudeModel(parsed.model)) {
+    try {
+      await deps.scheduleRestart(`user: /model ${parsed.model} (sr-to-claude restart)`)
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err)
+      return {
+        text: `❌ Could not schedule restart: ${deps.escapeHtml(msg)}`,
+        html: true,
+      }
+    }
+    return {
+      text: [
+        `Switching from <code>${deps.escapeHtml(currentSession)}</code> back to Claude — restarting session cleanly. Claude will be ready in ~30s.`,
+        PERSIST_NOTE,
+      ].join('\n'),
+      html: true,
+    }
+  }
+
   const verbHtml = `<code>/model ${deps.escapeHtml(parsed.model)}</code>`
   let result: InjectResult
   try {
@@ -549,6 +608,20 @@ export async function handleModelMenuCallback(
   }
 }
 
+/**
+ * True when the transition from `prevModel` to `nextModel` is a switch FROM
+ * an sr-* (LiteLLM/OpenRouter) model BACK TO a native Claude model. This
+ * signals that a session restart is required — an in-place model-picker select
+ * cannot undo the LiteLLM routing that the sr-* switch established in the live
+ * session. Null / undefined prev means no prior sr-* session — not a transition.
+ */
+export function isSrToClaudeTransition(
+  prevModel: string | null | undefined,
+  nextModel: string,
+): boolean {
+  return !!prevModel?.startsWith('sr-') && !nextModel.startsWith('sr-')
+}
+
 /**
  * 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

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

@@ -18,6 +18,8 @@ import {
   parseModelCommand,
   handleModelCommand,
   isValidModelArg,
+  isSrModel,
+  isClaudeModel,
   MODEL_ALIASES,
   type ModelCommandDeps,
 } from "../gateway/model-command.js";
@@ -35,6 +37,7 @@ function okResult(output: string): InjectResult {
 
 function makeDeps(overrides: Partial<ModelCommandDeps> = {}) {
   const calls: Array<{ agent: string; command: string }> = [];
+  const restartCalls: string[] = [];
   const deps: ModelCommandDeps = {
     inject: async (agent, command) => {
       calls.push({ agent, command });
@@ -45,9 +48,11 @@ function makeDeps(overrides: Partial<ModelCommandDeps> = {}) {
     escapeHtml: (s) =>
       s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;"),
     preBlock: (s) => `<pre>${s}</pre>`,
+    getActiveSessionModel: () => null,
+    scheduleRestart: async (reason) => { restartCalls.push(reason); },
     ...overrides,
   };
-  return { deps, calls };
+  return { deps, calls, restartCalls };
 }
 
 describe("parseModelCommand", () => {
@@ -237,6 +242,97 @@ describe("handleModelCommand — set", () => {
   });
 });
 
+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("sonnet")).toBe(false);
+    expect(isSrModel("")).toBe(false);
+  });
+
+  it("isClaudeModel is true for aliases and claude-* ids", () => {
+    for (const alias of MODEL_ALIASES) {
+      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("sr-gemini-2.5-pro")).toBe(false);
+    expect(isClaudeModel("gpt-4")).toBe(false);
+  });
+});
+
+describe("handleModelCommand — sr-* → Claude graceful restart", () => {
+  it("schedules restart instead of injecting when session is on sr-* and target is Claude alias", async () => {
+    const { deps, calls, restartCalls } = makeDeps({
+      getActiveSessionModel: () => "sr-gemini-2.5-pro",
+    });
+    const reply = await handleModelCommand({ kind: "set", model: "opus" }, deps);
+    // Must NOT inject
+    expect(calls).toHaveLength(0);
+    // Must schedule a restart
+    expect(restartCalls).toHaveLength(1);
+    expect(restartCalls[0]).toContain("opus");
+    expect(restartCalls[0]).toContain("sr-to-claude");
+    // Reply mentions the sr-* model and ~30s
+    expect(reply.text).toContain("sr-gemini-2.5-pro");
+    expect(reply.text).toContain("30s");
+    expect(reply.html).toBe(true);
+  });
+
+  it("schedules restart when session is on sr-* and target is a full claude-* id", async () => {
+    const { deps, calls, restartCalls } = makeDeps({
+      getActiveSessionModel: () => "sr-deepseek-r1",
+    });
+    const reply = await handleModelCommand({ kind: "set", model: "claude-opus-4-8" }, deps);
+    expect(calls).toHaveLength(0);
+    expect(restartCalls).toHaveLength(1);
+    expect(reply.text).toContain("sr-deepseek-r1");
+    expect(reply.text).toContain("30s");
+  });
+
+  it("does NOT restart when switching between Claude models (no sr-* session)", async () => {
+    const { deps, calls, restartCalls } = makeDeps({
+      getActiveSessionModel: () => "Opus 4.8",
+    });
+    const reply = await handleModelCommand({ kind: "set", model: "sonnet" }, deps);
+    // Normal inject path: still injects, no restart
+    expect(calls).toHaveLength(1);
+    expect(restartCalls).toHaveLength(0);
+    expect(reply.text).toContain("Set model to sonnet");
+  });
+
+  it("does NOT restart when switching from Claude to sr-* (no session override)", async () => {
+    const { deps, calls, restartCalls } = makeDeps({
+      getActiveSessionModel: () => null,
+    });
+    await handleModelCommand({ kind: "set", model: "sr-gemini-2.5-pro" }, deps);
+    // sr-* is not a Claude model — no restart
+    expect(restartCalls).toHaveLength(0);
+    expect(calls).toHaveLength(1);
+  });
+
+  it("surfaces scheduleRestart failures without propagating the error", async () => {
+    const { deps, calls } = makeDeps({
+      getActiveSessionModel: () => "sr-deepseek-r1",
+      scheduleRestart: async () => { throw new Error("hostd unreachable"); },
+    });
+    const reply = await handleModelCommand({ kind: "set", model: "sonnet" }, deps);
+    expect(calls).toHaveLength(0);
+    expect(reply.text).toContain("Could not schedule restart");
+    expect(reply.text).toContain("hostd unreachable");
+  });
+
+  it("null session model (no prior override) still uses normal inject path for Claude target", async () => {
+    const { deps, calls, restartCalls } = makeDeps({
+      getActiveSessionModel: () => null,
+    });
+    await handleModelCommand({ kind: "set", model: "opus" }, deps);
+    expect(calls).toHaveLength(1);
+    expect(restartCalls).toHaveLength(0);
+  });
+});
+
 describe("inject allowlist contract", () => {
   it("/model stays on the inject allowlist (the set path depends on it)", async () => {
     const { INJECT_COMMANDS } = await import("../../src/agents/inject.js");
@@ -258,6 +354,7 @@ import {
   MODEL_CALLBACK_HEADER,
   MODEL_CALLBACK_SR,
   SR_MODEL_LABELS,
+  isSrToClaudeTransition,
   type ModelMenuDeps,
 } from "../gateway/model-command.js";
 import { labelTag } from "../../src/agents/model-picker.js";
@@ -578,3 +675,29 @@ describe("handleModelMenuCallback — sr-* selection", () => {
     expect(out.answer).toBe("Invalid model name");
   });
 });
+
+// ---------------------------------------------------------------------------
+// isSrToClaudeTransition helper (used by gateway callback handler)
+// ---------------------------------------------------------------------------
+
+describe("isSrToClaudeTransition", () => {
+  it("true when prev is sr-* and next is not sr-*", () => {
+    expect(isSrToClaudeTransition("sr-gemini-2.5-pro", "Haiku 4.5")).toBe(true);
+    expect(isSrToClaudeTransition("sr-deepseek-r1", "Fable 5")).toBe(true);
+    expect(isSrToClaudeTransition("sr-deepseek-r1", "claude-opus-4-8")).toBe(true);
+  });
+
+  it("false when prev is not sr-* (Claude → Claude)", () => {
+    expect(isSrToClaudeTransition("Opus 4.8", "Haiku 4.5")).toBe(false);
+    expect(isSrToClaudeTransition(null, "Sonnet")).toBe(false);
+    expect(isSrToClaudeTransition(undefined, "Sonnet")).toBe(false);
+  });
+
+  it("false when prev is sr-* but next is also sr-* (sr-* → sr-*)", () => {
+    expect(isSrToClaudeTransition("sr-gemini-2.5-pro", "sr-deepseek-r1")).toBe(false);
+  });
+
+  it("false when switching to sr-* from Claude (Claude → sr-*)", () => {
+    expect(isSrToClaudeTransition("Sonnet", "sr-gemini-2.5-pro")).toBe(false);
+  });
+});

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

@@ -57,7 +57,12 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
         const openrouterHeader = flat.find(
           (b) => b.text.includes("OpenRouter") && b.callbackData === "mdl:h",
         );
-        const srButton = flat.find((b) => b.callbackData?.startsWith("mdl:sr:"));
+        // Prefer a fast non-reasoning model for the E2E test; reasoning models
+        // (deepseek-r1, o1, o3) take 2-5 min per response and hit the silence poke.
+        const srButton =
+          flat.find((b) => b.callbackData?.startsWith("mdl:sr:") && /flash/.test(b.callbackData)) ??
+          flat.find((b) => b.callbackData?.startsWith("mdl:sr:") && !/r1|o1|o3|thinking/.test(b.callbackData)) ??
+          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.");
@@ -86,8 +91,10 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
         expect((kbAfter ?? []).flat().length, "menu keeps buttons after sr-* tap").toBeGreaterThan(0);
 
         // ── 3. Send a quick message to generate a LiteLLM-routed turn ──
+        // Use 120s — fast models (gemini-flash, deepseek-v3) respond in <10s,
+        // but the request still has to go through the model switch inject + proxy.
         await sc.sendDM("Just reply with the word OK.");
-        await sc.expectMessage(/ok/i, { from: "bot", timeout: 60_000 });
+        await sc.expectMessage(/ok/i, { from: "bot", timeout: 120_000 });
 
         // ── 4. LiteLLM spend attribution ────────────────────────────────
         if (spendBefore >= 0) {
@@ -97,14 +104,19 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
           expect(spendAfter, `agent:${AGENT} log_count increased after turn`).toBeGreaterThan(spendBefore);
         }
 
-        // ── Restore: switch back to configured model ────────────────────
+        // ── Restore: switch back to a Claude subscription model ─────────
+        // Re-fetch keyboard so we have the latest state after sr-* switch.
+        // Look for any Claude model (mdl:s:) button — those are Max/Pro
+        // subscription models and don't trigger slow reasoning. If graceful
+        // restart is implemented, pressing a claude button fires a restart
+        // (not a deepseek/gemini inject), so no secondary LiteLLM calls.
         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),
-        );
+        const restoreBtn = (currentKb ?? []).flat().find((b) => b.callbackData?.startsWith("mdl:s:"));
         if (restoreBtn?.callbackData) {
           await sc.driver.pressButton(sc.botUserId, menu.messageId, restoreBtn.callbackData);
-          await new Promise((r) => setTimeout(r, 4_000));
+          // Wait for the restart to complete (graceful restart PR #2619) or for
+          // the in-place inject to propagate — 15s is sufficient for either path.
+          await new Promise((r) => setTimeout(r, 15_000));
         }
 
         console.log(`✅ sr-* model switch (${srName}) verified end-to-end through LiteLLM`);
@@ -112,7 +124,7 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
         await sc.tearDown();
       }
     },
-    180_000,
+    210_000,
   );
 
   it(
@@ -121,9 +133,11 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
       const sc = await spinUp({ agent: AGENT });
       try {
         await sc.sendDM("/model");
+        // 60s — test 2 runs after test 1's restore restart, which takes ~15s.
+        // If the restart is still finishing when /model lands, it may be queued.
         const menu = await sc.expectMessage(/Default \(new sessions\):/i, {
           from: "bot",
-          timeout: 30_000,
+          timeout: 60_000,
         });
         const kb = await sc.driver.getKeyboard(sc.botUserId, menu.messageId);
         const flat = (kb ?? []).flat();
@@ -142,6 +156,6 @@ describe("uat: /model sr-* LiteLLM routing — section headers + session switch
         await sc.tearDown();
       }
     },
-    60_000,
+    120_000,
   );
 });