switchroom 0.16.7 → 0.16.9

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.7";
+var VERSION = "0.16.9";
 
 // src/cli/resolve-version.ts
 function readPackageVersion() {
@@ -22827,7 +22827,7 @@ function parseUpdateResultLine(stdout) {
 // src/host-control/config-edit-validator.ts
 import { mkdtempSync, writeFileSync as writeFileSync2, rmSync as rmSync2, existsSync as existsSync7, readFileSync as readFileSync5 } from "node:fs";
 import { tmpdir } from "node:os";
-import { join as join4, isAbsolute as isAbsolute2, normalize } from "node:path";
+import { join as join4, isAbsolute as isAbsolute2, normalize, basename as basename2 } from "node:path";
 import { spawnSync as spawnSync2 } from "node:child_process";
 import { isDeepStrictEqual } from "node:util";
 var MAX_PATCH_BYTES = 1024 * 1024;
@@ -22847,7 +22847,7 @@ function isTargetPathHeader(headerPath, targetBasename) {
   const norm = normalize(p);
   if (norm.includes("..") || isAbsolute2(norm))
     return false;
-  return norm === targetBasename;
+  return norm === targetBasename || basename2(norm) === targetBasename;
 }
 function validateShape(unifiedDiff, targetPath) {
   const byteLen = Buffer.byteLength(unifiedDiff, "utf8");
@@ -22923,8 +22923,8 @@ function applyPatch(unifiedDiff, configPath, gitBin) {
   const liveContent = readFileSync5(configPath, "utf8");
   const scratchDir = mkdtempSync(join4(tmpdir(), "config-propose-edit-"));
   try {
-    const basename2 = configPath.split("/").pop() ?? "switchroom.yaml";
-    const scratchFile = join4(scratchDir, basename2);
+    const basename3 = configPath.split("/").pop() ?? "switchroom.yaml";
+    const scratchFile = join4(scratchDir, basename3);
     writeFileSync2(scratchFile, liveContent);
     const patchFile = join4(scratchDir, "proposal.patch");
     writeFileSync2(patchFile, unifiedDiff);

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "switchroom",
-  "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.",
+  "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/profiles/_base/start.sh.hbs

@@ -51,6 +51,41 @@ if [ "$SWITCHROOM_RUNTIME" = "docker" ] && [ -z "$SWITCHROOM_DOCKER_TMUX_INNER"
 {{/each}}
 {{/if}}
 
+  # LiteLLM virtual-key fetch for the GATEWAY process (outer-pass hoist).
+  # The INNER block below fetches this same key for the `claude` process;
+  # the gateway daemon forks HERE (in the outer pass) so it needs
+  # ANTHROPIC_CUSTOM_HEADERS exported BEFORE the gateway fork below, or
+  # discoverSrModels() returns [] and /model never shows OpenRouter entries.
+  #
+  # Mirrors the INNER block's fail-open logic exactly:
+  #   - missing key   → log + skip export (gateway talks direct OAuth)
+  #   - proxy down    → log + strip ALL routing env (fail-open)
+  #   - ANTHROPIC_CUSTOM_HEADERS already set → skip (idempotent)
+  #
+  # SWITCHROOM_AGENT_NAME is injected by compose env (compose.ts:1816)
+  # so it is available here, before the inner-pass export at line ~320.
+  if [ -n "$SWITCHROOM_LITELLM" ] && [ -z "$ANTHROPIC_CUSTOM_HEADERS" ] && command -v switchroom >/dev/null 2>&1; then
+    sr_ll_key="$(switchroom vault get "litellm/$SWITCHROOM_AGENT_NAME/api-key" 2>/dev/null || true)"
+    sr_ll_ok=""
+    if [ -z "$sr_ll_key" ]; then
+      echo "litellm(outer): no virtual key for agent '$SWITCHROOM_AGENT_NAME' — gateway will use 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(outer): 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
+      unset ANTHROPIC_BASE_URL ANTHROPIC_SMALL_FAST_MODEL SWITCHROOM_LITELLM
+    fi
+    unset sr_ll_key sr_ll_ok
+  fi
+
   # Tiny in-process supervisor: runs cmd in a respawn loop with
   # exponential backoff (1→2→4…→60s cap) and NEVER permanently gives
   # up. Rationale (RFC J / install-validation 2026-05-17): the

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();
@@ -54803,6 +54835,8 @@ function naturalAction(toolName, inputPreview) {
       return "update its task list";
     case "ExitPlanMode":
       return "exit plan mode";
+    case "config_propose_edit":
+      return "edit switchroom config";
     default:
       return `use ${toolName}`;
   }
@@ -56013,10 +56047,10 @@ function readTurnActiveMarkerAgeMs(stateDir, now) {
 }
 
 // ../src/build-info.ts
-var VERSION = "0.16.7";
-var COMMIT_SHA = "696eea91";
-var COMMIT_DATE = "2026-06-28T04:56:27Z";
-var LATEST_PR = 2615;
+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
@@ -65207,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 () => {
@@ -65256,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) {
@@ -65275,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) });
@@ -68172,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;
@@ -68183,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/permission-title.ts

@@ -212,6 +212,11 @@ export function naturalAction(
       return "update its task list";
     case "ExitPlanMode":
       return "exit plan mode";
+    // hostd config-edit verb (#2605) — not mcp__-prefixed (it's a direct
+    // wire call from the agent-config MCP server), so it falls through to
+    // the switch rather than naturalMcpAction. Give it a readable title.
+    case "config_propose_edit":
+      return "edit switchroom config";
     default:
       return `use ${toolName}`;
   }