talon-agent 5.25.1 → 5.26.1

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,
     [
       {

package/src/frontend/terminal/builtins/model.ts

@@ -5,8 +5,11 @@ import { resolveModelId as resolveModelName } from "../../../core/models/catalog
 import {
   getChatSettings,
   setChatModel,
-  setChatEffort,
 } from "../../../storage/chat-settings.js";
+import {
+  describeChatEffort,
+  setChatEffortLevel,
+} from "../../presentation/model-commands.js";
 import type { Command, CommandContext } from "../command-registry.js";
 
 type BackendRef = CommandContext["backend"];
@@ -178,20 +181,26 @@ export const modelCommand: Command = {
 export const effortCommand: Command = {
   name: "effort",
   argHint: "[lvl]",
-  description: "Thinking effort (off/low/medium/high/max)",
+  description: "Thinking effort for the active model",
   async handler(args, ctx) {
-    if (!args) {
+    // Same resolution and validation as every chat frontend: the levels
+    // the active model registers, plus adaptive/reset/default.
+    const deps = {
+      config: ctx.config,
+      gateway: { backend: ctx.backend ?? null },
+    };
+    const arg = args.trim();
+    if (!arg) {
+      const { current, levels } = await describeChatEffort(ctx.chatId(), deps);
       ctx.renderer.writeSystem(
-        `Effort: ${getChatSettings(ctx.chatId()).effort ?? "adaptive"}`,
+        levels.length
+          ? `Effort: ${current} (${levels.join(", ")}, adaptive)`
+          : `Effort: ${current}`,
       );
     } else {
-      setChatEffort(
-        ctx.chatId(),
-        args === "adaptive"
-          ? undefined
-          : (args as "off" | "low" | "medium" | "high" | "max"),
-      );
-      ctx.renderer.writeSystem(`Effort → ${args}`);
+      const outcome = await setChatEffortLevel(ctx.chatId(), arg, deps);
+      if (outcome.ok) ctx.renderer.writeSystem(outcome.text);
+      else ctx.renderer.writeError(outcome.text);
     }
     ctx.reprompt();
   },

package/src/frontend/whatsapp/commands.ts

@@ -5,8 +5,9 @@
  * WhatsApp has no inline buttons, so everything Telegram does with a
  * picker is done here with typed arguments: `/model` prints a numbered
  * catalog, `/model 3` (or `/model <id>`, `/model <backend>`) picks from
- * it. The state changes come from frontend/presentation/model-commands.ts;
- * this module only parses, authorises, and renders.
+ * it. The replies are shared with the native bridge
+ * (frontend/presentation/text-commands.ts); this module only parses,
+ * authorises, and delivers.
  *
  * Replies are written in Markdown — `sendText` translates them into
  * WhatsApp's dialect and splits long listings into bubbles.
@@ -14,38 +15,17 @@
 
 import { log } from "../../util/log.js";
 import { recordMessageProcessed } from "../../util/watchdog.js";
-import { getChatSettings } from "../../storage/chat-settings.js";
-import { isPulseEnabled } from "../../core/background/pulse/pulse.js";
+import { performSessionReset } from "../presentation/session-status.js";
 import {
-  DEFAULT_PULSE_INTERVAL_MS,
-  formatBytes,
-  formatDuration,
-  formatModelLabel,
-  formatTokenCount,
-  formatUsd,
-} from "../presentation/format.js";
-import {
-  collectSessionStatus,
-  performSessionReset,
-  type SessionStatusData,
-} from "../presentation/session-status.js";
-import {
-  formatCacheTempLine,
-  formatDaemonLine,
-} from "../presentation/status-context.js";
-import {
-  describeChatEffort,
-  describeChatModels,
-  matchBackendArg,
-  resetChatBackend,
-  resetChatModel,
   resolveChatBackendPair,
-  selectChatModel,
-  setChatEffortLevel,
-  switchChatBackend,
   type ModelCommandDeps,
-  type ModelOverview,
 } from "../presentation/model-commands.js";
+import {
+  effortCommandReply,
+  modelCommandReply,
+  settingsCommandReply,
+  statusCommandReply,
+} from "../presentation/text-commands.js";
 import { sendText } from "./actions/send.js";
 import { identityAllowed, type Identity } from "./connection/identity.js";
 import type { WhatsAppChatInfo } from "./registry.js";
@@ -73,9 +53,6 @@ export type CommandInbound = {
   isGroup: boolean;
 };
 
-/** How many catalog entries `/model` prints before pointing at `/model <id>`. */
-const MAX_LISTED_MODELS = 40;
-
 /**
  * Parse a slash command out of message text. Group messages in mention
  * mode arrive as "@<number> /model", so leading @mentions are skipped.
@@ -112,120 +89,6 @@ export function canChangeSettings(
   return identityAllowed(inbound.identity, runtime.allowedDms);
 }
 
-// ── Renderers ───────────────────────────────────────────────────────────────
-
-function renderModelOverview(view: ModelOverview): string {
-  const lines: string[] = [];
-  lines.push(
-    view.activeModel
-      ? `**Model:** \`${view.activeModel}\`${
-          view.activeDisplay && view.activeDisplay !== view.activeModel
-            ? ` (${view.activeDisplay})`
-            : ""
-        }${view.hasModelOverride ? " — chat override" : ""}`
-      : "**Model:** none selected — messages will be refused until you pick one",
-  );
-  lines.push(
-    `**Backend:** ${view.backendLabel} (\`${view.backendId}\`)${view.hasBackendOverride ? " — chat override" : ""}`,
-  );
-  if (view.backends.length > 1) {
-    lines.push(
-      `Backends: ${view.backends.map((b) => `\`${b.id}\``).join(", ")} — \`/model <backend>\` switches (session restarts).`,
-    );
-  }
-  if (view.choices.length === 0) {
-    lines.push(
-      "",
-      "This backend has no browsable catalog; `/model <id>` sets one directly.",
-    );
-  } else {
-    lines.push("", `**Models** (${view.choices.length}):`);
-    for (const c of view.choices.slice(0, MAX_LISTED_MODELS)) {
-      const marker = c.id === view.activeModel ? " ✓" : "";
-      const free = c.free ? " · free" : "";
-      lines.push(`${c.index}. ${c.displayName} — \`${c.id}\`${free}${marker}`);
-    }
-    if (view.choices.length > MAX_LISTED_MODELS) {
-      lines.push(
-        `… ${view.choices.length - MAX_LISTED_MODELS} more — \`/model <id>\` picks any of them.`,
-      );
-    }
-  }
-  lines.push(
-    "",
-    "`/model <number>` or `/model <id>` picks; `/model default` clears the chat's pick" +
-      (view.hasBackendOverride
-        ? "; `/model backend default` reverts the backend."
-        : "."),
-  );
-  return lines.join("\n");
-}
-
-function renderSettings(
-  view: ModelOverview,
-  effort: { current: string; levels: string[] },
-  pulseOn: boolean,
-  pulseIntervalMs: number | undefined,
-  freeOnly: boolean,
-): string {
-  const lines = [
-    "**Settings**",
-    `Model: \`${view.activeModel ?? "none selected"}\`${view.hasModelOverride ? " (chat override)" : ""}`,
-    `Backend: ${view.backendLabel} (\`${view.backendId}\`)${view.hasBackendOverride ? " (chat override)" : ""}`,
-    `Effort: ${effort.current}${effort.levels.length ? ` — levels: ${effort.levels.join(", ")}` : ""}`,
-    `Pulse: ${pulseOn ? "on" : "off"} (every ${formatDuration(pulseIntervalMs ?? DEFAULT_PULSE_INTERVAL_MS)})`,
-  ];
-  if (freeOnly) lines.push("Free-only models: on");
-  lines.push(
-    "",
-    "Change with `/model`, `/effort`; `/reset` starts a fresh session.",
-  );
-  return lines.join("\n");
-}
-
-function renderStatus(s: SessionStatusData): string {
-  const used = s.context.known ? formatTokenCount(s.context.used) : "unknown";
-  const max = s.context.max > 0 ? formatTokenCount(s.context.max) : "unknown";
-  const pct = s.context.known ? `${s.context.pct}%` : "unknown";
-  const lines = [
-    `**Talon** · \`${formatModelLabel(s.activeModel)}\`${s.backendLabel ? ` · ${s.backendLabel}` : ""} · effort: ${s.effortName}${s.turnInProgress ? " · ⏳ turn running" : ""}`,
-    "",
-    `**Context** ${used} / ${max} (${pct})${s.context.warn ? " ⚠️ consider /reset" : ""}`,
-    `\`${s.context.bar}\``,
-    "",
-    "**Session stats**",
-    `Response: last ${s.lastResponseMs ? formatDuration(s.lastResponseMs) : "—"} · avg ${s.avgResponseMs ? formatDuration(s.avgResponseMs) : "—"} · best ${s.fastestMs ? formatDuration(s.fastestMs) : "—"}`,
-    `Turns: ${s.turns}${s.turnsModelLabel ? ` (${formatModelLabel(s.turnsModelLabel)})` : ""}`,
-    `Tokens: in ${formatTokenCount(s.inputTokens)} · out ${formatTokenCount(s.outputTokens)}${s.costUsd > 0 ? ` · cost ${formatUsd(s.costUsd)}` : ""}`,
-  ];
-  if (s.cache) {
-    lines.push(
-      `Cache: ${s.cache.hitPct}% hit · read ${formatTokenCount(s.cache.read)}${s.cache.showsWrite ? ` · write ${formatTokenCount(s.cache.write)}` : ""}`,
-    );
-  }
-  if (s.cacheTemp) lines.push(formatCacheTempLine(s.cacheTemp));
-  if (s.plan) {
-    lines.push(
-      "",
-      `**Plan**${s.plan.plan ? ` ${s.plan.plan}` : ""}${s.plan.ageLabel ? ` (${s.plan.ageLabel})` : ""}`,
-      ...s.plan.windows.map(
-        (w) =>
-          `\`${w.label.padEnd(6)}${w.bar} ${String(w.percent).padStart(3)}%\`${w.resetLabel ? ` reset ${w.resetLabel}` : ""}`,
-      ),
-    );
-  }
-  lines.push(
-    "",
-    `**Pulse** ${s.pulseOn ? "on" : "off"}`,
-    `**Workspace** ${formatBytes(s.diskBytes)}`,
-    `**Session** ${s.sessionName ? `"${s.sessionName}" ` : ""}${s.sessionId ? `\`${s.sessionId.slice(0, 8)}…\`` : "(new)"} · ${s.sessionAge} old`,
-    `**Uptime** ${s.uptime} · ${s.activeSessionCount} active session${s.activeSessionCount === 1 ? "" : "s"}`,
-    `**Runtime** ${s.runtime} · ${formatBytes(s.rssBytes)} RSS`,
-    formatDaemonLine(s.daemon),
-  );
-  return lines.join("\n");
-}
-
 const HELP_TEXT = [
   "**Commands**",
   "/model — list backends and models; `/model <n|id>` picks, `/model <backend>` switches",
@@ -238,71 +101,6 @@ const HELP_TEXT = [
 
 // ── Handlers ────────────────────────────────────────────────────────────────
 
-async function runModelCommand(
-  chatId: string,
-  arg: string,
-  deps: ModelCommandDeps,
-): Promise<string> {
-  if (!arg) return renderModelOverview(await describeChatModels(chatId, deps));
-  const lower = arg.toLowerCase();
-  // `/reset` keeps history on WhatsApp because the local store is the only
-  // chat record; a backend switch keeps it for the same reason.
-  if (lower === "backend default" || lower === "backend reset") {
-    return (await resetChatBackend(chatId, deps, { keepHistory: true })).text;
-  }
-  if (lower === "reset" || lower === "default") {
-    return (await resetChatModel(chatId, deps)).text;
-  }
-  const backend = matchBackendArg(arg, deps.config);
-  if (backend) {
-    return (
-      await switchChatBackend(chatId, backend, deps, { keepHistory: true })
-    ).text;
-  }
-  return (await selectChatModel(chatId, arg, deps)).text;
-}
-
-async function runEffortCommand(
-  chatId: string,
-  arg: string,
-  deps: ModelCommandDeps,
-): Promise<string> {
-  if (arg) return (await setChatEffortLevel(chatId, arg, deps)).text;
-  const effort = await describeChatEffort(chatId, deps);
-  if (effort.levels.length === 0) {
-    return `No reasoning levels available for ${effort.activeModel ?? "the active model"} on backend ${effort.backendId}.`;
-  }
-  return `**Effort:** ${effort.current}\nLevels: ${effort.levels.join(", ")}, or adaptive — \`/effort <level>\` sets one.`;
-}
-
-async function runSettingsCommand(
-  chatId: string,
-  deps: ModelCommandDeps,
-): Promise<string> {
-  const [view, effort] = await Promise.all([
-    describeChatModels(chatId, deps),
-    describeChatEffort(chatId, deps),
-  ]);
-  const sets = getChatSettings(chatId);
-  return renderSettings(
-    view,
-    effort,
-    isPulseEnabled(chatId),
-    sets.pulseIntervalMs,
-    sets.freeOnly === true,
-  );
-}
-
-async function runStatusCommand(
-  chatId: string,
-  deps: ModelCommandDeps,
-): Promise<string> {
-  const { backend, backendId } = resolveChatBackendPair(chatId, deps);
-  return renderStatus(
-    await collectSessionStatus(chatId, deps.config, backend, backendId),
-  );
-}
-
 async function runResetCommand(
   chatId: string,
   senderName: string,
@@ -337,13 +135,15 @@ export async function executeWhatsAppCommand(
   }
   switch (cmd.name) {
     case "model":
-      return runModelCommand(chatId, cmd.arg, deps);
+      // `/reset` keeps history on WhatsApp because the local store is the
+      // only chat record; a backend switch keeps it for the same reason.
+      return modelCommandReply(chatId, cmd.arg, deps, { keepHistory: true });
     case "effort":
-      return runEffortCommand(chatId, cmd.arg, deps);
+      return effortCommandReply(chatId, cmd.arg, deps);
     case "settings":
-      return runSettingsCommand(chatId, deps);
+      return settingsCommandReply(chatId, deps);
     case "status":
-      return runStatusCommand(chatId, deps);
+      return statusCommandReply(chatId, deps);
     case "reset":
       return runResetCommand(chatId, inbound.senderName, deps);
     case "help":

package/src/frontend/whatsapp/messages/inbound.ts

@@ -1,7 +1,8 @@
 /**
  * One inbound message, from `messages.upsert` to the model's turn:
  * access gates → media saved to the workspace → history recorded →
- * slash commands (../commands.ts) → catch-up policy → `execute()`.
+ * slash commands (../commands.ts; skipped in the catch-up backlog) →
+ * catch-up policy → `execute()`.
  */
 
 import { isJidGroup, type WAMessage } from "baileys";
@@ -17,7 +18,7 @@ import {
   recordMessageReceived,
 } from "../../../util/watchdog.js";
 import { isAddressedToSelf, isGroupAllowed } from "../access.js";
-import { handleWhatsAppCommand } from "../commands.js";
+import { handleWhatsAppCommand, parseWhatsAppCommand } from "../commands.js";
 import { sendText } from "../actions/send.js";
 import {
   bareId,
@@ -207,6 +208,32 @@ function catchUpDeservesReply(inbound: RecordedMessage): boolean {
   return true;
 }
 
+/**
+ * A slash command in the catch-up backlog was issued against an earlier
+ * state of the chat — replaying `/reset` or `/model x` after a restart
+ * would silently undo whatever happened since. It stays recorded but does
+ * not run; while fresh, the sender is told so they can resend it.
+ */
+async function skipCatchUpCommand(
+  runtime: WhatsAppRuntime,
+  inbound: RecordedMessage,
+  name: string,
+): Promise<void> {
+  const { chat, senderName } = inbound;
+  log(
+    "whatsapp",
+    `[${chat.chatId}] Skipped /${name} from ${senderName} (sent while offline)`,
+  );
+  recordMessageProcessed();
+  const sock = runtime.sock;
+  if (!sock || !shouldReplyToCatchUp(inbound.platformTs)) return;
+  await sendText(
+    { sock, gateway: runtime.gateway },
+    chat,
+    `Not run: /${name} was sent while offline. Send it again to run it.`,
+  ).catch(() => {});
+}
+
 async function onTurnEvent(
   runtime: WhatsAppRuntime,
   chat: WhatsAppChatInfo,
@@ -307,6 +334,10 @@ export async function handleInbound(
   if (!admitted) return;
   const inbound = await recordInbound(runtime, msg, admitted);
   if (!inbound) return;
+  if (options.catchUp) {
+    const cmd = parseWhatsAppCommand(inbound.text);
+    if (cmd) return skipCatchUpCommand(runtime, inbound, cmd.name);
+  }
   if (await handleWhatsAppCommand(runtime, inbound)) return;
   if (options.catchUp && !catchUpDeservesReply(inbound)) return;
   await runInboundTurn(runtime, inbound);