talon-agent 4.3.2 → 4.3.3

package/src/frontend/telegram/admin/health.ts

@@ -0,0 +1,81 @@
+/**
+ * `/admin stats` / `errors` / `logs` / `daily` — the daemon-health
+ * subcommands.
+ */
+
+import type { Context } from "grammy";
+import { readFileSync } from "node:fs";
+import { files, dirs } from "../../../util/paths.js";
+import { tailFile } from "../../../util/tail-file.js";
+import { escapeHtml } from "../formatting.js";
+import { getAllSessions } from "../../../storage/sessions.js";
+import { todayLogDate } from "../../../storage/daily-log.js";
+import { getActiveCount } from "../../../core/engine/dispatcher.js";
+import { getHealthStatus, getRecentErrors } from "../../../util/watchdog.js";
+import { formatDuration } from "../helpers/index.js";
+
+export async function replyStats(ctx: Context): Promise<void> {
+  const h = getHealthStatus();
+  const sessions = getAllSessions();
+  const turns = sessions.reduce((s, x) => s + x.info.turns, 0);
+  const mem = process.memoryUsage();
+  await ctx.reply(
+    [
+      `<b>🦅 Talon Stats</b>`,
+      "",
+      `<b>Uptime:</b> ${formatDuration(h.uptimeMs)}`,
+      `<b>Messages:</b> ${h.totalMessagesProcessed}`,
+      `<b>Sessions:</b> ${sessions.length}`,
+      `<b>Turns:</b> ${turns}`,
+      `<b>Last active:</b> ${h.msSinceLastMessage < 60000 ? "now" : formatDuration(h.msSinceLastMessage) + " ago"}`,
+      "",
+      `<b>Memory:</b> ${(mem.heapUsed / 1024 / 1024).toFixed(1)}MB heap / ${(mem.rss / 1024 / 1024).toFixed(1)}MB rss`,
+      `<b>Queue:</b> ${getActiveCount()}`,
+      `<b>Errors:</b> ${h.recentErrorCount}`,
+    ].join("\n"),
+    { parse_mode: "HTML" },
+  );
+}
+
+export async function replyRecentErrors(ctx: Context): Promise<void> {
+  const errors = getRecentErrors(5);
+  if (errors.length === 0) {
+    await ctx.reply("No recent errors.");
+    return;
+  }
+  const lines = errors.map(
+    (e) =>
+      `<code>[${new Date(e.timestamp).toISOString().slice(11, 19)}]</code> ${escapeHtml(e.message.slice(0, 200))}`,
+  );
+  await ctx.reply(
+    `<b>Recent Errors (${errors.length})</b>\n\n` + lines.join("\n\n"),
+    { parse_mode: "HTML" },
+  );
+}
+
+export async function replyLogTail(ctx: Context): Promise<void> {
+  const logPath = files.log;
+  try {
+    const lines = tailFile(logPath);
+    await ctx.reply(`<pre>${escapeHtml(lines.slice(0, 3800))}</pre>`, {
+      parse_mode: "HTML",
+    });
+  } catch {
+    await ctx.reply(`Could not read ${logPath}`);
+  }
+}
+
+export async function replyDailyLog(ctx: Context): Promise<void> {
+  const today = todayLogDate();
+  const logPath = `${dirs.logs}/${today}.md`;
+  try {
+    const content = readFileSync(logPath, "utf-8");
+    const lines = content.trim().split("\n").slice(-30).join("\n");
+    await ctx.reply(
+      `<b>Daily log (${today})</b>\n\n<pre>${escapeHtml(lines.slice(0, 3800))}</pre>`,
+      { parse_mode: "HTML" },
+    );
+  } catch {
+    await ctx.reply(`No daily log for ${today}.`);
+  }
+}

package/src/frontend/telegram/admin/sessions.ts

@@ -0,0 +1,105 @@
+/**
+ * `/admin chats` / `broadcast` / `kill` — the session-level subcommands.
+ */
+
+import type { Bot, Context } from "grammy";
+import type { TalonConfig } from "../../../util/config.js";
+import { escapeHtml } from "../formatting.js";
+import { resetSession, getAllSessions } from "../../../storage/sessions.js";
+import { clearHistory } from "../../../storage/history.js";
+import { getChatSettings } from "../../../storage/chat-settings.js";
+import { formatModelLabel } from "../helpers/index.js";
+import { replyHtmlChunked } from "./chunked-reply.js";
+
+/** `/admin chats` — every active session, newest first, titled via getChat. */
+export async function replyActiveChats(
+  ctx: Context,
+  _rest: string[],
+  bot: Bot,
+  config: TalonConfig,
+): Promise<void> {
+  const sessions = getAllSessions();
+  if (sessions.length === 0) {
+    await ctx.reply("No active sessions.");
+    return;
+  }
+  sessions.sort((a, b) => (b.info.lastActive || 0) - (a.info.lastActive || 0));
+
+  const titles = new Map<string, string>();
+  await Promise.all(
+    sessions.map(async (s) => {
+      try {
+        const id = parseInt(s.chatId, 10);
+        if (isNaN(id)) return;
+        const chat = await bot.api.getChat(id);
+        titles.set(
+          s.chatId,
+          "title" in chat
+            ? (chat.title ?? "DM")
+            : "first_name" in chat
+              ? (chat.first_name ?? "DM")
+              : "DM",
+        );
+      } catch {
+        /* inaccessible */
+      }
+    }),
+  );
+
+  const lines = sessions.map((s) => {
+    const age = s.info.lastActive
+      ? `${Math.round((Date.now() - s.info.lastActive) / 60000)}m ago`
+      : "?";
+    const title = titles.get(s.chatId) ?? s.chatId;
+    const model = formatModelLabel(
+      getChatSettings(s.chatId).model ?? config.model,
+    );
+    // `model` is a catalog id (OpenRouter/Kilo ids are free-form), so
+    // it gets the same escaping the title already had.
+    return `<b>${escapeHtml(title)}</b> <code>${s.chatId}</code>\n  ${s.info.turns} turns | ${age} | ${escapeHtml(model)}`;
+  });
+  await replyHtmlChunked(
+    ctx,
+    `<b>Active chats (${sessions.length})</b>\n\n` + lines.join("\n\n"),
+  );
+}
+
+export async function broadcast(
+  ctx: Context,
+  rest: string[],
+  bot: Bot,
+): Promise<void> {
+  const text = rest.join(" ");
+  if (!text) {
+    await ctx.reply("Usage: /admin broadcast <text>");
+    return;
+  }
+  const sessions = getAllSessions();
+  let sent = 0,
+    failed = 0;
+  for (const s of sessions) {
+    const id = parseInt(s.chatId, 10);
+    if (isNaN(id)) continue;
+    try {
+      await bot.api.sendMessage(id, text);
+      sent++;
+      await new Promise((r) => setTimeout(r, 40));
+    } catch {
+      failed++;
+    }
+  }
+  await ctx.reply(
+    `Broadcast: ${sent} sent, ${failed} failed (${sessions.length} total).`,
+  );
+}
+
+export async function killSession(ctx: Context, rest: string[]): Promise<void> {
+  const target = rest[0];
+  if (!target) {
+    await ctx.reply("Usage: /admin kill <chatId>");
+    return;
+  }
+  resetSession(target);
+  clearHistory(target);
+  await ctx.reply(`Session ${target} reset.`);
+}

package/src/frontend/telegram/admin.ts

@@ -1,91 +1,64 @@
 /**
  * Admin command handlers — /admin subcommands for bot operators.
+ *
+ * The table maps each subcommand to its handler in `admin/`:
+ *   - `sessions`   — chats / broadcast / kill
+ *   - `health`     — stats / errors / logs / daily
+ *   - `background` — cron / pulse
+ * Anything else (including no subcommand) gets the usage listing.
  */
 
 import type { Bot, Context } from "grammy";
-import { readFileSync } from "node:fs";
 import type { TalonConfig } from "../../util/config.js";
-import { files, dirs } from "../../util/paths.js";
-import { tailFile } from "../../util/tail-file.js";
-import { escapeHtml, splitMessage } from "./formatting.js";
-import { TELEGRAM_MAX_TEXT } from "./actions/types.js";
-import { resetSession, getAllSessions } from "../../storage/sessions.js";
-import { clearHistory } from "../../storage/history.js";
-import { todayLogDate } from "../../storage/daily-log.js";
-import { getChatSettings } from "../../storage/chat-settings.js";
+import { replyActiveChats, broadcast, killSession } from "./admin/sessions.js";
 import {
-  getAllCronJobs,
-  describeSchedule,
-  nextRunAt,
-} from "../../storage/cron.js";
-import { getActiveCount } from "../../core/engine/dispatcher.js";
-import { getPulseStatus } from "../../core/background/pulse.js";
-import { getHealthStatus, getRecentErrors } from "../../util/watchdog.js";
-import { formatDuration, formatModelLabel } from "./helpers/index.js";
-
-/**
- * Reply with an HTML listing, split across messages when it outgrows
- * Telegram's 4096-char cap. The per-item listings below (chats, cron,
- * pulse) scale with the daemon's chat count, and a single oversized
- * `ctx.reply` fails the whole command with 400 "message is too long".
- * Entries are `\n\n`-separated and each carries balanced tags, so the
- * paragraph-first splitter never cuts through markup.
- */
-async function replyHtmlChunked(ctx: Context, text: string): Promise<void> {
-  for (const chunk of splitMessage(text, TELEGRAM_MAX_TEXT)) {
-    await ctx.reply(chunk, { parse_mode: "HTML" });
-  }
-}
-
-/** `/admin chats` — every active session, newest first, titled via getChat. */
-async function replyActiveChats(
+  replyStats,
+  replyRecentErrors,
+  replyLogTail,
+  replyDailyLog,
+} from "./admin/health.js";
+import { replyCronJobs, replyPulseStatus } from "./admin/background.js";
+
+type AdminSubcommand = (
   ctx: Context,
+  rest: string[],
   bot: Bot,
   config: TalonConfig,
-): Promise<void> {
-  const sessions = getAllSessions();
-  if (sessions.length === 0) {
-    await ctx.reply("No active sessions.");
-    return;
-  }
-  sessions.sort((a, b) => (b.info.lastActive || 0) - (a.info.lastActive || 0));
-
-  const titles = new Map<string, string>();
-  await Promise.all(
-    sessions.map(async (s) => {
-      try {
-        const id = parseInt(s.chatId, 10);
-        if (isNaN(id)) return;
-        const chat = await bot.api.getChat(id);
-        titles.set(
-          s.chatId,
-          "title" in chat
-            ? (chat.title ?? "DM")
-            : "first_name" in chat
-              ? (chat.first_name ?? "DM")
-              : "DM",
-        );
-      } catch {
-        /* inaccessible */
-      }
-    }),
-  );
-
-  const lines = sessions.map((s) => {
-    const age = s.info.lastActive
-      ? `${Math.round((Date.now() - s.info.lastActive) / 60000)}m ago`
-      : "?";
-    const title = titles.get(s.chatId) ?? s.chatId;
-    const model = formatModelLabel(
-      getChatSettings(s.chatId).model ?? config.model,
-    );
-    // `model` is a catalog id (OpenRouter/Kilo ids are free-form), so
-    // it gets the same escaping the title already had.
-    return `<b>${escapeHtml(title)}</b> <code>${s.chatId}</code>\n  ${s.info.turns} turns | ${age} | ${escapeHtml(model)}`;
-  });
-  await replyHtmlChunked(
-    ctx,
-    `<b>Active chats (${sessions.length})</b>\n\n` + lines.join("\n\n"),
+) => Promise<void>;
+
+// Null-prototype so `/admin constructor` can't resolve an inherited
+// Object.prototype method via `handlers[subcommand]`.
+const ADMIN_SUBCOMMANDS: Record<string, AdminSubcommand> = Object.assign(
+  Object.create(null),
+  {
+    chats: replyActiveChats,
+    broadcast,
+    kill: killSession,
+    logs: replyLogTail,
+    stats: replyStats,
+    errors: replyRecentErrors,
+    cron: replyCronJobs,
+    pulse: replyPulseStatus,
+    daily: replyDailyLog,
+  } satisfies Record<string, AdminSubcommand>,
+);
+
+async function replyUsage(ctx: Context): Promise<void> {
+  await ctx.reply(
+    [
+      "<b>/admin commands</b>",
+      "",
+      "  stats    uptime, messages, memory",
+      "  errors   last 5 errors",
+      "  chats    list all active chats",
+      "  daily    today's interaction log",
+      "  pulse    pulse status per chat",
+      "  cron     list all cron jobs",
+      "  broadcast &lt;text&gt;  send to all chats",
+      "  kill &lt;chatId&gt;     reset a chat session",
+      "  logs     last 20 lines of log",
+    ].join("\n"),
+    { parse_mode: "HTML" },
   );
 }
 
@@ -96,188 +69,10 @@ export async function handleAdminCommand(
 ): Promise<void> {
   const args = ((ctx.match as string) ?? "").trim();
   const [subcommand, ...rest] = args.split(/\s+/);
-
-  switch (subcommand) {
-    case "chats": {
-      await replyActiveChats(ctx, bot, config);
-      return;
-    }
-
-    case "broadcast": {
-      const text = rest.join(" ");
-      if (!text) {
-        await ctx.reply("Usage: /admin broadcast <text>");
-        return;
-      }
-      const sessions = getAllSessions();
-      let sent = 0,
-        failed = 0;
-      for (const s of sessions) {
-        const id = parseInt(s.chatId, 10);
-        if (isNaN(id)) continue;
-        try {
-          await bot.api.sendMessage(id, text);
-          sent++;
-          await new Promise((r) => setTimeout(r, 40));
-        } catch {
-          failed++;
-        }
-      }
-      await ctx.reply(
-        `Broadcast: ${sent} sent, ${failed} failed (${sessions.length} total).`,
-      );
-      return;
-    }
-
-    case "kill": {
-      const target = rest[0];
-      if (!target) {
-        await ctx.reply("Usage: /admin kill <chatId>");
-        return;
-      }
-      resetSession(target);
-      clearHistory(target);
-      await ctx.reply(`Session ${target} reset.`);
-      return;
-    }
-
-    case "logs": {
-      const logPath = files.log;
-      try {
-        const lines = tailFile(logPath);
-        await ctx.reply(`<pre>${escapeHtml(lines.slice(0, 3800))}</pre>`, {
-          parse_mode: "HTML",
-        });
-      } catch {
-        await ctx.reply(`Could not read ${logPath}`);
-      }
-      return;
-    }
-
-    case "stats": {
-      const h = getHealthStatus();
-      const sessions = getAllSessions();
-      const turns = sessions.reduce((s, x) => s + x.info.turns, 0);
-      const mem = process.memoryUsage();
-      await ctx.reply(
-        [
-          `<b>\uD83E\uDD85 Talon Stats</b>`,
-          "",
-          `<b>Uptime:</b> ${formatDuration(h.uptimeMs)}`,
-          `<b>Messages:</b> ${h.totalMessagesProcessed}`,
-          `<b>Sessions:</b> ${sessions.length}`,
-          `<b>Turns:</b> ${turns}`,
-          `<b>Last active:</b> ${h.msSinceLastMessage < 60000 ? "now" : formatDuration(h.msSinceLastMessage) + " ago"}`,
-          "",
-          `<b>Memory:</b> ${(mem.heapUsed / 1024 / 1024).toFixed(1)}MB heap / ${(mem.rss / 1024 / 1024).toFixed(1)}MB rss`,
-          `<b>Queue:</b> ${getActiveCount()}`,
-          `<b>Errors:</b> ${h.recentErrorCount}`,
-        ].join("\n"),
-        { parse_mode: "HTML" },
-      );
-      return;
-    }
-
-    case "errors": {
-      const errors = getRecentErrors(5);
-      if (errors.length === 0) {
-        await ctx.reply("No recent errors.");
-        return;
-      }
-      const lines = errors.map(
-        (e) =>
-          `<code>[${new Date(e.timestamp).toISOString().slice(11, 19)}]</code> ${escapeHtml(e.message.slice(0, 200))}`,
-      );
-      await ctx.reply(
-        `<b>Recent Errors (${errors.length})</b>\n\n` + lines.join("\n\n"),
-        { parse_mode: "HTML" },
-      );
-      return;
-    }
-
-    case "cron": {
-      const jobs = getAllCronJobs();
-      if (jobs.length === 0) {
-        await ctx.reply("No cron jobs.");
-        return;
-      }
-      const lines = jobs.map((j) => {
-        const nextMs = nextRunAt(j);
-        const last = j.lastRunAt
-          ? new Date(j.lastRunAt).toISOString().slice(0, 16).replace("T", " ")
-          : "never";
-        const next = nextMs
-          ? new Date(nextMs).toISOString().slice(0, 16).replace("T", " ")
-          : "?";
-        return `${j.enabled ? "\u2713" : "\u2717"} <b>${escapeHtml(j.name)}</b>\n  <code>${escapeHtml(describeSchedule(j))}</code> | ${j.type} | runs: ${j.runCount} | last: ${last} | next: ${next}`;
-      });
-      await replyHtmlChunked(
-        ctx,
-        `<b>Cron Jobs (${jobs.length})</b>\n\n` + lines.join("\n\n"),
-      );
-      return;
-    }
-
-    case "pulse": {
-      const chats = getPulseStatus();
-      if (chats.length === 0) {
-        await ctx.reply("No pulse chats.");
-        return;
-      }
-      const lines = await Promise.all(
-        chats.map(async (p) => {
-          let title = p.chatId;
-          try {
-            const id = parseInt(p.chatId, 10);
-            if (!isNaN(id)) {
-              const chat = await bot.api.getChat(id);
-              title = "title" in chat ? (chat.title ?? p.chatId) : p.chatId;
-            }
-          } catch {
-            /* skip */
-          }
-          return `${p.enabled ? "\u2713" : "\u2717"} ${escapeHtml(title)}`;
-        }),
-      );
-      await replyHtmlChunked(
-        ctx,
-        `<b>Pulse (${chats.length})</b>\n\n` + lines.join("\n"),
-      );
-      return;
-    }
-
-    case "daily": {
-      const today = todayLogDate();
-      const logPath = `${dirs.logs}/${today}.md`;
-      try {
-        const content = readFileSync(logPath, "utf-8");
-        const lines = content.trim().split("\n").slice(-30).join("\n");
-        await ctx.reply(
-          `<b>Daily log (${today})</b>\n\n<pre>${escapeHtml(lines.slice(0, 3800))}</pre>`,
-          { parse_mode: "HTML" },
-        );
-      } catch {
-        await ctx.reply(`No daily log for ${today}.`);
-      }
-      return;
-    }
-
-    default:
-      await ctx.reply(
-        [
-          "<b>/admin commands</b>",
-          "",
-          "  stats    uptime, messages, memory",
-          "  errors   last 5 errors",
-          "  chats    list all active chats",
-          "  daily    today's interaction log",
-          "  pulse    pulse status per chat",
-          "  cron     list all cron jobs",
-          "  broadcast &lt;text&gt;  send to all chats",
-          "  kill &lt;chatId&gt;     reset a chat session",
-          "  logs     last 20 lines of log",
-        ].join("\n"),
-        { parse_mode: "HTML" },
-      );
+  const run = ADMIN_SUBCOMMANDS[subcommand];
+  if (!run) {
+    await replyUsage(ctx);
+    return;
   }
+  await run(ctx, rest, bot, config);
 }

package/src/frontend/telegram/callbacks/model/backend.ts

@@ -0,0 +1,156 @@
+/**
+ * Backend switching — `model:backend:<id>` and `model:backend-default`.
+ * Both drop Talon's per-chat stores for the outgoing backend and hand the
+ * session over (see `handOffBackendSession`).
+ */
+
+import type { Context } from "grammy";
+import { setChatBackend } from "../../../../storage/chat-settings.js";
+import { resetSession } from "../../../../storage/sessions.js";
+import { clearHistory } from "../../../../storage/history.js";
+import {
+  getBackendIdForChat,
+  listAvailableBackends,
+  rebindChat,
+  releaseChat,
+} from "../../../../core/engine/backend-controller/index.js";
+import { resetPulseCheckpoint } from "../../../../core/background/pulse.js";
+import { resolveActiveModelForChat } from "../../../../core/models/active-model.js";
+import { logWarn } from "../../../../util/log.js";
+import type { ModelCallback } from "../../model-callbacks.js";
+import { resolveBackendForChat } from "../../model-menu.js";
+import { answerCallbackQuerySafe, type CallbackDeps } from "../shared.js";
+import type { ModelOutcome } from "./types.js";
+
+/**
+ * Run the backend-side half of a chat's session handoff.
+ *
+ * A backend switch already clears Talon's own stores (session row,
+ * history, pulse checkpoint), but those are only half the state.
+ * `performSessionReset` also drives the backend capability slots, and
+ * the switch path skipped them entirely:
+ *
+ *   - the OUTGOING backend keeps in-process per-chat state that no
+ *     amount of clearing Talon's stores touches. openai-agents holds a
+ *     `MemorySession` map keyed by chat id, so switching away and back
+ *     resurrected the old conversation the operator meant to drop.
+ *   - the INCOMING backend was never warmed, so the first turn after a
+ *     switch paid the full cold start — on OpenCode/Kilo that is session
+ *     creation plus a per-plugin MCP registration sweep.
+ *
+ * The warm is deliberately fire-and-forget: it can take seconds, and the
+ * callback still has a toast to answer and a menu to redraw. Telegram
+ * expires an unanswered callback query, so blocking here would trade a
+ * cold first turn for a visibly stuck button.
+ */
+function handOffBackendSession(
+  chatId: string,
+  previousBackend: ReturnType<typeof resolveBackendForChat>,
+  gateway: CallbackDeps["gateway"],
+): void {
+  previousBackend?.sessions?.resetChat?.(chatId);
+  const nextBackend = resolveBackendForChat(chatId, gateway);
+  // Same instance on a no-op switch — warming it again is harmless
+  // (every step is idempotent) but pointless, so skip it.
+  if (!nextBackend || nextBackend === previousBackend) return;
+  void Promise.resolve(nextBackend.sessions?.warmSession?.(chatId)).catch(
+    (err) =>
+      logWarn(
+        "bot",
+        `[${chatId}] warm after backend switch failed: ${err instanceof Error ? err.message : String(err)}`,
+      ),
+  );
+}
+
+export async function handleBackendSelect(
+  ctx: Context,
+  action: Extract<ModelCallback, { kind: "backend-select" }>,
+  cid: string,
+  { config, gateway }: CallbackDeps,
+): Promise<ModelOutcome | undefined> {
+  // Rebind chat to the chosen backend. Verify the requested id
+  // is on the enabled list to keep the menu and the operation
+  // in sync — `config.enabledBackends` is a UX filter and we
+  // honour it here too.
+  const available = listAvailableBackends(config);
+  if (!available.some((b) => b.id === action.backendId)) {
+    await answerCallbackQuerySafe(ctx, {
+      text: "Backend not available",
+    });
+    return undefined;
+  }
+  // Resolve the outgoing backend BEFORE rebinding — afterwards this
+  // chat already points at the new one and the old in-process state
+  // would be unreachable.
+  const previousBackend = resolveBackendForChat(cid, gateway);
+  const result = await rebindChat(cid, action.backendId, config);
+  if (!result.ok) {
+    await answerCallbackQuerySafe(ctx, {
+      text: result.error?.slice(0, 200) ?? "Rebind failed",
+    });
+    return undefined;
+  }
+  setChatBackend(cid, action.backendId);
+  // Switching backends drops the previous backend's per-chat
+  // session state (it's not portable across backends). We DO
+  // NOT clear `modelByBackend` — keeping each backend's prior
+  // pick means switching back-and-forth restores each side's
+  // last choice automatically (Codex chat keeps gpt-5.5,
+  // OpenRouter chat keeps owl-alpha, etc).
+  resetSession(cid);
+  clearHistory(cid);
+  resetPulseCheckpoint(cid);
+  handOffBackendSession(cid, previousBackend, gateway);
+  const label =
+    available.find((b) => b.id === action.backendId)?.label ?? action.backendId;
+  // Toast names the model the new backend will actually run
+  // (per-chat slot if remembered, else canonical / operator
+  // default; "no default" if catalog-driven with no config).
+  const newBackend = resolveBackendForChat(cid, gateway);
+  const { model: resolvedNewModel } = await resolveActiveModelForChat(
+    cid,
+    newBackend,
+    action.backendId,
+    config,
+  );
+  return {
+    toast: resolvedNewModel
+      ? `Backend: ${label} (model: ${resolvedNewModel})`
+      : `Backend: ${label} — no default model, /model to pick one`,
+    view: { kind: "menu" },
+  };
+}
+
+export async function handleBackendDefault(
+  _ctx: Context,
+  _action: Extract<ModelCallback, { kind: "backend-default" }>,
+  cid: string,
+  { config, gateway }: CallbackDeps,
+): Promise<ModelOutcome> {
+  // Drop the per-chat backend override; chat reverts to the
+  // global chat-role backend. Per-backend model picks are
+  // preserved (modelByBackend stays intact) so reverting and
+  // switching back later still restores prior choices.
+  const previousBackend = resolveBackendForChat(cid, gateway);
+  await releaseChat(cid);
+  setChatBackend(cid, undefined);
+  resetSession(cid);
+  clearHistory(cid);
+  resetPulseCheckpoint(cid);
+  handOffBackendSession(cid, previousBackend, gateway);
+  // Resolve the now-default backend's model for the toast.
+  const defaultBackend = resolveBackendForChat(cid, gateway);
+  const defaultBackendId = getBackendIdForChat(cid);
+  const { model: resolvedRoleModel } = await resolveActiveModelForChat(
+    cid,
+    defaultBackend,
+    defaultBackendId,
+    config,
+  );
+  return {
+    toast: resolvedRoleModel
+      ? `Backend reset to default (model: ${resolvedRoleModel})`
+      : `Backend reset to default — no model picked, /model to pick one`,
+    view: { kind: "menu" },
+  };
+}