talon-agent 5.25.0 → 5.26.0

package/src/frontend/telegram/commands/backup.ts

@@ -1,15 +1,17 @@
 /**
  * /backup — the snapshot panel (admin only).
  *
- *   /backup                    status: schedule, sizes, targets
+ *   /backup                    the interactive panel: status + buttons
  *   /backup now                take a snapshot now
  *   /backup checkpoint <label> take a labelled, pinned-on-request snapshot
  *   /backup list               recent snapshots
  *   /backup pin|unpin <id>     keep past retention, or release
  *   /backup restore <id>       confirm button → staged restore + restart
  *
- * Restore is the only destructive one, so it is the only one behind a
- * button. It does not restore in place: a running daemon holds the
+ * The bare command opens a panel (render/backup-panel.ts) whose buttons —
+ * Back up now, Snapshots, How restore works, Refresh — are handled in
+ * callbacks/backup.ts. Restore is the only destructive action, so it is
+ * always behind an explicit confirmation button. It does not restore in place: a running daemon holds the
  * database it would replace, so the request is staged to
  * ~/.talon/restore-pending.json and applied by the next boot before
  * anything opens the database (see core/backup/restore.ts).
@@ -17,8 +19,6 @@
 
 import type { Bot, Context } from "grammy";
 import {
-  collectBackupStatus,
-  formatBackupStatus,
   formatSnapshotList,
   isSnapshotId,
   listSnapshots,
@@ -29,13 +29,16 @@ import {
 } from "../../../core/backup/index.js";
 import { respawnSelf } from "../../../core/daemon/respawn.js";
 import { escapeHtml } from "../formatting.js";
+import { renderRestoreConfirm } from "../../presentation/backup-panel.js";
+import { TELEGRAM_REPORTS } from "../render/html.js";
+import { inlineKeyboard, loadStatusPanel } from "../render/backup-panel.js";
 import { logError } from "../../../util/log.js";
 import { isAuthorizedAdmin } from "./state.js";
 
 const HELP = [
   "<b>/backup</b> — snapshots and checkpoints",
   "",
-  "<code>/backup</code> — status",
+  "<code>/backup</code> — the backup panel",
   "<code>/backup now</code> — take a snapshot",
   "<code>/backup checkpoint &lt;label&gt;</code> — labelled checkpoint",
   "<code>/backup list</code> — recent snapshots",
@@ -48,8 +51,11 @@ function pre(text: string): string {
 }
 
 async function sendStatus(ctx: Context): Promise<void> {
-  const status = await collectBackupStatus();
-  await ctx.reply(pre(formatBackupStatus(status)), { parse_mode: "HTML" });
+  const view = await loadStatusPanel();
+  await ctx.reply(view.text, {
+    parse_mode: "HTML",
+    reply_markup: { inline_keyboard: inlineKeyboard(view.buttons) },
+  });
 }
 
 async function sendList(ctx: Context): Promise<void> {
@@ -57,13 +63,14 @@ async function sendList(ctx: Context): Promise<void> {
   await ctx.reply(pre(formatSnapshotList(snapshots)), { parse_mode: "HTML" });
 }
 
-async function takeSnapshot(ctx: Context, label?: string): Promise<void> {
-  const sent = await ctx.reply(
-    label
-      ? `📸 Taking checkpoint “${escapeHtml(label)}”…`
-      : "📸 Taking a snapshot…",
-    { parse_mode: "HTML" },
-  );
+/**
+ * Run one snapshot and describe the outcome as a single HTML line. Shared
+ * by `/backup now|checkpoint` and the panel's 📸 button, which edit their
+ * own messages with it. Never throws: a failure is the line.
+ */
+export async function runSnapshotForChat(
+  label?: string,
+): Promise<{ ok: boolean; text: string }> {
   try {
     const manifest = await runBackup({
       kind: label ? "checkpoint" : "backup",
@@ -71,25 +78,35 @@ async function takeSnapshot(ctx: Context, label?: string): Promise<void> {
       pinned: Boolean(label),
       trigger: "command",
     });
-    await ctx.api.editMessageText(
-      ctx.chat!.id,
-      sent.message_id,
-      `✅ <code>${escapeHtml(manifest.id)}</code> — ${manifest.parts.length} part(s), ` +
+    return {
+      ok: true,
+      text:
+        `✅ <code>${escapeHtml(manifest.id)}</code> — ${manifest.parts.length} part(s), ` +
         `${(manifest.sizeBytes / 1024 / 1024).toFixed(1)} MB` +
         (label ? " (pinned)" : ""),
-      { parse_mode: "HTML" },
-    );
+    };
   } catch (err) {
     logError("backup", "/backup now failed", err);
-    await ctx.api.editMessageText(
-      ctx.chat!.id,
-      sent.message_id,
-      `⚠️ Backup failed: ${escapeHtml(err instanceof Error ? err.message : String(err))}`,
-      { parse_mode: "HTML" },
-    );
+    return {
+      ok: false,
+      text: `⚠️ Backup failed: ${escapeHtml(err instanceof Error ? err.message : String(err))}`,
+    };
   }
 }
 
+async function takeSnapshot(ctx: Context, label?: string): Promise<void> {
+  const sent = await ctx.reply(
+    label
+      ? `📸 Taking checkpoint “${escapeHtml(label)}”…`
+      : "📸 Taking a snapshot…",
+    { parse_mode: "HTML" },
+  );
+  const result = await runSnapshotForChat(label);
+  await ctx.api.editMessageText(ctx.chat!.id, sent.message_id, result.text, {
+    parse_mode: "HTML",
+  });
+}
+
 async function setPinned(
   ctx: Context,
   id: string,
@@ -124,27 +141,20 @@ async function askToRestore(ctx: Context, id: string): Promise<void> {
     );
     return;
   }
-  await ctx.reply(
-    `♻️ <b>Restore <code>${escapeHtml(id)}</code>?</b>\n` +
-      (manifest.label ? `“${escapeHtml(manifest.label)}”\n` : "") +
-      `Taken ${new Date(manifest.createdAt).toISOString()}\n\n` +
-      "This replaces config, prompts, keys, sessions, the database and memory, " +
-      "then restarts. A pinned checkpoint of the current state is taken first.",
-    {
-      parse_mode: "HTML",
-      reply_markup: {
-        inline_keyboard: [
-          [
-            {
-              text: "♻️ Restore and restart",
-              callback_data: `backup:restore:${id}`,
-            },
-            { text: "Cancel", callback_data: "backup:cancel" },
-          ],
+  await ctx.reply(renderRestoreConfirm(TELEGRAM_REPORTS, manifest), {
+    parse_mode: "HTML",
+    reply_markup: {
+      inline_keyboard: [
+        [
+          {
+            text: "♻️ Restore and restart",
+            callback_data: `backup:restore:${id}`,
+          },
+          { text: "Cancel", callback_data: "backup:cancel" },
         ],
-      },
+      ],
     },
-  );
+  });
 }
 
 /**

package/src/frontend/telegram/commands/index.ts

@@ -34,10 +34,11 @@ export { setAdminUserId } from "./state.js";
 export function registerCommands(
   bot: Bot,
   config: TalonConfig,
-  gateway?: { backend: Backend | null },
+  gateway?: { backend: Backend | null; isListening?: () => boolean },
 ): void {
   const deps = { config, gateway };
-  registerInfoCommands(bot);
+  const isListening = gateway?.isListening?.bind(gateway);
+  registerInfoCommands(bot, { bridgeListening: isListening });
   registerMemoryCommand(bot);
   registerSessionCommands(bot, deps);
   registerSettingsCommands(bot, deps);

package/src/frontend/telegram/commands/info.ts

@@ -16,7 +16,50 @@ import { getLoadedPlugins } from "../../../core/plugin/index.js";
 import { getMeshService } from "../../../core/mesh/index.js";
 import type { MeshPingResult } from "../../../core/mesh/devices/service.js";
 
-export function registerInfoCommands(bot: Bot): void {
+/**
+ * `/ping` — Bot API round trip, plus live bridge and userbot state. The
+ * reply landing at all is the Bot API check; its round trip is the
+ * latency. The Bridge field is omitted when no health source is wired.
+ */
+function registerPingCommand(
+  bot: Bot,
+  bridgeListening: (() => boolean) | undefined,
+): void {
+  bot.command("ping", async (ctx) => {
+    const start = Date.now();
+    const sent = await ctx.reply("...");
+    const latency = Date.now() - start;
+
+    const userbotOk = isUserClientReady();
+    const uptime = formatDuration(process.uptime() * 1000);
+
+    const statusLine = [
+      ...(bridgeListening ? [`Bridge: ${bridgeListening() ? "✓" : "✗"}`] : []),
+      `Userbot: ${userbotOk ? "✓" : "✗"}`,
+      `Uptime: ${uptime}`,
+    ].join(" | ");
+
+    try {
+      await bot.api.editMessageText(
+        ctx.chat.id,
+        sent.message_id,
+        `Pong! ${latency}ms\n${statusLine}`,
+      );
+    } catch {
+      // ignore edit failure
+    }
+  });
+}
+
+export type InfoCommandDeps = {
+  /** Tool-bridge health; the Bridge field is omitted when absent. */
+  bridgeListening?: () => boolean;
+};
+
+export function registerInfoCommands(
+  bot: Bot,
+  { bridgeListening }: InfoCommandDeps = {},
+): void {
   bot.command("start", (ctx) =>
     ctx.reply(
       [
@@ -87,31 +130,7 @@ export function registerInfoCommands(bot: Bot): void {
     ),
   );
 
-  bot.command("ping", async (ctx) => {
-    const start = Date.now();
-    const sent = await ctx.reply("...");
-    const latency = Date.now() - start;
-
-    const bridgeOk = true;
-    const userbotOk = isUserClientReady();
-    const uptime = formatDuration(process.uptime() * 1000);
-
-    const statusLine = [
-      `Bridge: ${bridgeOk ? "✓" : "✗"}`,
-      `Userbot: ${userbotOk ? "✓" : "✗"}`,
-      `Uptime: ${uptime}`,
-    ].join(" | ");
-
-    try {
-      await bot.api.editMessageText(
-        ctx.chat.id,
-        sent.message_id,
-        `Pong! ${latency}ms\n${statusLine}`,
-      );
-    } catch {
-      // ignore edit failure
-    }
-  });
+  registerPingCommand(bot, bridgeListening);
 
   /** True only in a 1:1 chat with the bot — never a group or channel. */
   const isPrivate = (ctx: Context): boolean => ctx.chat?.type === "private";

package/src/frontend/telegram/commands/memory.ts

@@ -2,10 +2,8 @@
  * `/memory` — a read-only window on the typed memory store.
  *
  * Four shapes, all reads: the ranked listing, a full-text search, one
- * row's provenance (`why <id>`) and a per-kind listing. Nothing here
- * writes: asserting, superseding and dropping are the write path's job
- * (rollout PR 6), so the operator can always ask what Talon remembers
- * without the answer being able to change it.
+ * row's provenance (`why <id>`) and a per-kind listing — rendered by
+ * frontend/presentation/memory-report.ts, which the native bridge shares.
  *
  * Admin only, and only in a private chat. The store holds the operator's
  * private notes — people, places, health, relationships — so a read of it
@@ -13,28 +11,16 @@
  * reply, and anyone else who can reach the bot must not see it at all.
  *
  * Every line is model- or user-authored text reaching an HTML-parsed
- * send, so it goes through `escapeHtml` before it is joined; the reply
- * is chunked because a listing of 15 rows can outgrow Telegram's
- * 4096-char cap on its own.
+ * send, so the report escapes it with the HTML dialect; the reply is
+ * chunked because a listing of 15 rows can outgrow Telegram's 4096-char
+ * cap on its own.
  */
 
 import type { Bot, Context } from "grammy";
-import { escapeHtml } from "../formatting.js";
 import { replyHtmlChunked } from "../admin/chunked-reply.js";
+import { TELEGRAM_REPORTS } from "../render/html.js";
+import { renderMemoryReport } from "../../presentation/memory-report.js";
 import { isAuthorizedAdmin } from "./state.js";
-import {
-  formatMemory,
-  getMemory,
-  isMemoryKind,
-  listMemories,
-  memoryHistory,
-  searchMemories,
-  MEMORY_KINDS,
-  type MemoryRow,
-} from "../../../storage/memory.js";
-
-/** Rows per reply — a chat listing is a glance, not an export. */
-const LIST_LIMIT = 15;
 
 export function registerMemoryCommand(bot: Bot): void {
   bot.command("memory", async (ctx: Context) => {
@@ -48,7 +34,7 @@ export function registerMemoryCommand(bot: Bot): void {
       return;
     }
     const arg = (ctx.match ?? "").toString().trim();
-    await replyHtmlChunked(ctx, renderMemory(arg));
+    await replyHtmlChunked(ctx, renderMemoryReport(arg, TELEGRAM_REPORTS));
   });
 }
 
@@ -62,73 +48,3 @@ function memoryAccess(ctx: Context): "ok" | "not-admin" | "not-private" {
   if (ctx.chat?.type !== "private") return "not-private";
   return "ok";
 }
-
-/** Route the argument to one of the four reads. Returns ready HTML. */
-function renderMemory(arg: string): string {
-  const why = /^why\b\s*(.*)$/is.exec(arg);
-  if (why) return renderWhy(why[1]!.trim());
-  const kind = /^kind\b\s*(.*)$/is.exec(arg);
-  if (kind) return renderKind(kind[1]!.trim());
-  if (!arg)
-    return renderRows(
-      listMemories({ limit: LIST_LIMIT }),
-      "Nothing remembered yet.",
-    );
-  return renderRows(
-    searchMemories(arg, { limit: LIST_LIMIT }),
-    `No memories matching "${arg}".`,
-  );
-}
-
-/** One escaped line per row, or the (escaped) empty-case sentence. */
-function renderRows(rows: MemoryRow[], empty: string): string {
-  if (rows.length === 0) return escapeHtml(empty);
-  return rows.map((row) => escapeHtml(formatMemory(row))).join("\n");
-}
-
-function renderKind(kind: string): string {
-  if (!isMemoryKind(kind))
-    return escapeHtml(
-      `No such kind "${kind}". Valid kinds: ${MEMORY_KINDS.join(", ")}.`,
-    );
-  return renderRows(
-    listMemories({ kind, limit: LIST_LIMIT }),
-    `Nothing remembered under ${kind}.`,
-  );
-}
-
-/**
- * Provenance for one row: the row itself, the numbers that decide where
- * it ranks, and its audit trail. Reads by id rather than by the live
- * listing, so a superseded or dropped row still explains itself.
- */
-function renderWhy(raw: string): string {
-  const id = Number(raw);
-  if (!raw || !Number.isInteger(id))
-    return escapeHtml(`No memory with id ${raw || "(none given)"}.`);
-  const row = getMemory(id);
-  if (!row) return escapeHtml(`No memory with id ${id}.`);
-  const lines = [
-    escapeHtml(formatMemory(row)),
-    "",
-    escapeHtml(
-      `trust ${row.trust} · confidence ${row.confidence} · hits ${row.hitCount} · salience ${row.salience}`,
-    ),
-    escapeHtml(
-      `created ${isoTime(row.createdAt)} · last seen ${isoTime(row.lastSeenAt)}`,
-    ),
-  ];
-  const history = memoryHistory(row.id);
-  if (history.length > 0) {
-    lines.push("", "<b>History</b>");
-    for (const entry of history) {
-      const reason = entry.reason ? ` — ${entry.reason}` : "";
-      lines.push(escapeHtml(`${isoTime(entry.at)} ${entry.op}${reason}`));
-    }
-  }
-  return lines.join("\n");
-}
-
-function isoTime(ms: number): string {
-  return new Date(ms).toISOString();
-}

package/src/frontend/telegram/commands/settings.ts

@@ -30,7 +30,6 @@ import {
   renderEffortRows,
   renderModelMenuText,
   renderModelMenuKeyboard,
-  type SettingsButton,
 } from "../render/menu.js";
 import {
   buildModelMenuViewForChat,
@@ -175,6 +174,17 @@ function registerEffortCommand(bot: Bot, { config, gateway }: RegisterDeps) {
       config,
     });
 
+    // Reset first: adaptive needs no model levels, so it must stay
+    // reachable on a model that registers none.
+    if (arg === "reset" || arg === "default" || arg === "adaptive") {
+      setChatEffort(cid, undefined);
+      await ctx.reply(
+        "Effort reset to <b>adaptive</b> (model decides when to think)",
+        { parse_mode: "HTML" },
+      );
+      return;
+    }
+
     if (reasoning.levels.length === 0) {
       const modelText = reasoning.activeModel
         ? `<code>${escapeHtml(formatModelLabel(reasoning.activeModel))}</code>`
@@ -201,15 +211,6 @@ function registerEffortCommand(bot: Bot, { config, gateway }: RegisterDeps) {
       return;
     }
 
-    if (arg === "reset" || arg === "default" || arg === "adaptive") {
-      setChatEffort(cid, undefined);
-      await ctx.reply(
-        "Effort reset to <b>adaptive</b> (model decides when to think)",
-        { parse_mode: "HTML" },
-      );
-      return;
-    }
-
     if (supportsReasoningLevel(arg, reasoning.levels)) {
       setChatEffort(cid, arg as EffortLevel);
       await ctx.reply(`Effort set to <b>${arg}</b>`, { parse_mode: "HTML" });
@@ -311,36 +312,6 @@ function registerSettingsCommand(bot: Bot, { config, gateway }: RegisterDeps) {
       reasoning.levels,
     );
     const pulseOn = isPulseEnabled(cid);
-    let modelButtons: Array<SettingsButton> | undefined;
-    let pager:
-      | {
-          page: number;
-          totalPages: number;
-          filter: "all" | "free";
-          freeCount: number;
-          totalCount: number;
-          provider?: string;
-        }
-      | undefined;
-    let view: "models" | "groups" = "models";
-    let activeProvider: string | undefined;
-    if (settingsBe?.models?.getSettingsPresentation && resolvedSettingsModel) {
-      const pres = await settingsBe.models?.getSettingsPresentation(
-        resolvedSettingsModel,
-      );
-      modelButtons = pres.modelButtons;
-      pager = {
-        page: pres.page,
-        totalPages: pres.totalPages,
-        filter: pres.filter,
-        freeCount: pres.freeCount,
-        totalCount: pres.totalCount,
-        provider: pres.provider,
-      };
-      view = pres.view;
-      activeProvider = pres.provider;
-    }
-
     await ctx.reply(
       renderSettingsText(
         activeModel,
@@ -352,14 +323,11 @@ function registerSettingsCommand(bot: Bot, { config, gateway }: RegisterDeps) {
         parse_mode: "HTML",
         reply_markup: {
           inline_keyboard: renderSettingsKeyboard(
-            activeModel,
+            resolvedSettingsModel,
             effortName,
             pulseOn,
-            modelButtons,
-            pager,
-            view,
-            activeProvider,
             reasoning.levels,
+            Boolean(settingsBe?.models?.getSettingsPresentation),
           ),
         },
       },

package/src/frontend/telegram/commands/whatsapp-pairing.ts

@@ -33,23 +33,27 @@ export function whatsAppPanel(): WhatsAppPanel {
   if (!provider) {
     return { text: WHATSAPP_NOT_ENABLED, keyboard: [] };
   }
-  const linked = provider.isLinked();
-  const text = linked
-    ? "<b>WhatsApp</b>\n✅ Linked and connected.\n\n" +
-      "Re-link only if the phone has unlinked this device."
-    : "<b>WhatsApp</b>\n📴 Not linked.\n\n" +
-      "Tap <b>Pair device</b> when you're holding the phone — I'll reply " +
-      "with a QR to scan (WhatsApp → ⋮ → Linked devices → Link a device).";
+  const refresh = { text: "🔄 Refresh", callback_data: "whatsapp:refresh" };
+  // No pair button while linked: pairing refuses on a linked account, and
+  // unlinking from here would drop a working link. When the phone unlinks
+  // this device the connection loop parks, isLinked() turns false, and
+  // the button comes back on the next refresh.
+  if (provider.isLinked()) {
+    return {
+      text:
+        "<b>WhatsApp</b>\n✅ Linked and connected.\n\n" +
+        "To link a different phone, unlink this device on the phone " +
+        "first, then pair here.",
+      keyboard: [[refresh]],
+    };
+  }
   return {
-    text,
+    text:
+      "<b>WhatsApp</b>\n📴 Not linked.\n\n" +
+      "Tap <b>Pair device</b> when you're holding the phone — I'll reply " +
+      "with a QR to scan (WhatsApp → ⋮ → Linked devices → Link a device).",
     keyboard: [
-      [
-        {
-          text: linked ? "🔗 Re-pair" : "🔗 Pair device",
-          callback_data: "whatsapp:pair",
-        },
-        { text: "🔄 Refresh", callback_data: "whatsapp:refresh" },
-      ],
+      [{ text: "🔗 Pair device", callback_data: "whatsapp:pair" }, refresh],
     ],
   };
 }

package/src/frontend/telegram/render/backup-panel.ts

@@ -0,0 +1,47 @@
+/**
+ * Telegram's spelling of the /backup panel: the shared views from
+ * `frontend/presentation/backup-panel.ts`, rendered in HTML and mapped
+ * onto inline keyboards. The command (`commands/backup.ts`) sends these;
+ * the `backup:*` callbacks (`callbacks/backup.ts`) edit them in place.
+ */
+
+import {
+  collectBackupStatus,
+  listSnapshots,
+} from "../../../core/backup/index.js";
+import {
+  GUIDE_BUTTONS,
+  backupPanelView,
+  renderRestoreGuide,
+  snapshotPageView,
+  type PanelButton,
+  type PanelView,
+} from "../../presentation/backup-panel.js";
+import { TELEGRAM_REPORTS } from "./html.js";
+import type { SettingsButton } from "./menu.js";
+
+export function inlineKeyboard(
+  rows: readonly PanelButton[][],
+): SettingsButton[][] {
+  return rows.map((row) =>
+    row.map((button) => ({ text: button.label, callback_data: button.data })),
+  );
+}
+
+/** The status panel, freshly collected. `notice` leads it (a result line). */
+export async function loadStatusPanel(notice?: string): Promise<PanelView> {
+  return backupPanelView(
+    TELEGRAM_REPORTS,
+    await collectBackupStatus(),
+    Date.now(),
+    notice,
+  );
+}
+
+export async function loadSnapshotPage(page: number): Promise<PanelView> {
+  return snapshotPageView(TELEGRAM_REPORTS, await listSnapshots(), page);
+}
+
+export function restoreGuideView(): PanelView {
+  return { text: renderRestoreGuide(TELEGRAM_REPORTS), buttons: GUIDE_BUTTONS };
+}

package/src/frontend/telegram/render/menu.ts

@@ -18,6 +18,7 @@ import {
   type ModelInfo,
 } from "../../../core/models/catalog.js";
 import { renderSettingsText as renderSettingsTextWith } from "../../presentation/reports.js";
+import { formatModelLabel } from "../../presentation/format.js";
 import { TELEGRAM_REPORTS } from "./html.js";
 
 /** Display name for a known ModelInfo. */
@@ -440,49 +441,39 @@ export function renderModelBrowseKeyboard(
   ];
 }
 
+/**
+ * The /settings keyboard: one button that opens the /model menu (the single
+ * place models are browsed and picked), the effort levels the active model
+ * registers, and the pulse toggle. `hasModelMenu` is false when the backend
+ * has no model catalog — the /model menu cannot render there, so the button
+ * would do nothing.
+ */
 export function renderSettingsKeyboard(
-  model: string,
+  model: string | null,
   effort: string,
   proactive: boolean,
-  modelButtons?: Array<SettingsButton>,
-  pager?: SettingsPager,
-  view: "models" | "groups" = "models",
-  activeProvider?: string,
   reasoningLevels: readonly ReasoningEffortLevel[] = [],
+  hasModelMenu = true,
 ): Array<Array<SettingsButton>> {
-  const selectedButtons = modelButtons?.length
-    ? modelButtons
-    : getTelegramModelOptions().map((m) => ({
-        text: isSelectedModel(model, m.id)
-          ? `✓ ${formatCompactModelLabel(m)}`
-          : formatCompactModelLabel(m),
-        callback_data: `settings:model:${m.id}`,
-      }));
-  const cols = modelButtons?.length ? 2 : 3;
-  const modelRows: Array<Array<SettingsButton>> = [];
-  for (let i = 0; i < selectedButtons.length; i += cols) {
-    modelRows.push(selectedButtons.slice(i, i + cols));
-  }
-
-  const controlRows = pager
-    ? renderModelPickerControlRows(
-        pager,
-        "settings:models",
-        "settings:noop",
-        view,
-        activeProvider,
-      )
-    : [];
-
   const effortRows = renderEffortRows(
     effort,
     reasoningLevels,
     "settings:effort:",
   );
 
+  const modelRows: Array<Array<SettingsButton>> = hasModelMenu
+    ? [
+        [
+          {
+            text: model ? `Model: ${formatModelLabel(model)}` : "Choose model",
+            callback_data: "model:menu",
+          },
+        ],
+      ]
+    : [];
+
   return [
     ...modelRows,
-    ...controlRows,
     ...effortRows,
     [
       {