talon-agent 3.16.1 → 3.18.0

package/src/core/doctor.ts

@@ -29,6 +29,12 @@ export interface DoctorCheck {
    * starts but a backend won't work.
    */
   issue?: boolean;
+  /**
+   * A backend that is configured but not serving chats. Renderers group
+   * these away from the environment so a handful of idle providers can't
+   * bury the checks that describe the running deployment.
+   */
+  inactive?: boolean;
 }
 
 /** One embedded native module: provenance plus a live self-test result. */
@@ -59,6 +65,8 @@ export interface DoctorReport {
 export interface DoctorConfigSlice {
   frontend: string | string[];
   backend?: string;
+  /** Backends config exposes. Empty / absent means every registered one. */
+  enabledBackends?: string[];
   model?: string;
   heartbeatModel?: string;
   heartbeatBackend?: string;
@@ -284,12 +292,55 @@ async function checkClaudeConfiguredModels(
   return checks;
 }
 
-/** Binary / auth checks for the active backend only. */
+/** Every backend id doctor knows how to inspect. */
+const KNOWN_BACKENDS = [
+  "claude",
+  "codex",
+  "kilo",
+  "opencode",
+  "openai-agents",
+] as const;
+
+/**
+ * Binary / auth checks across every backend the config exposes.
+ *
+ * Only the active one counts toward the issue total; the rest are reported
+ * so a switch doesn't have to be the thing that discovers a backend can't
+ * run. That distinction matters now that a chat can be rebound at runtime —
+ * a report of all-green while two backends are one click from failing is
+ * worse than no report.
+ */
 async function checkBackend(
   config: DoctorConfigSlice | undefined,
+): Promise<DoctorCheck[]> {
+  const active = config?.backend ?? "claude";
+  const exposed = config?.enabledBackends?.length
+    ? config.enabledBackends
+    : [...KNOWN_BACKENDS];
+
+  const checks = await checkOneBackend(active, config, true);
+  for (const id of exposed) {
+    if (id === active || !KNOWN_BACKENDS.includes(id as never)) continue;
+    // An idle backend's missing binary is a heads-up, not a fault of this
+    // deployment: downgrade it and keep it out of the issue count.
+    for (const check of await checkOneBackend(id, config, false)) {
+      checks.push({
+        ...check,
+        status: check.status === "fail" ? "warn" : check.status,
+        issue: false,
+        inactive: true,
+      });
+    }
+  }
+  return checks;
+}
+
+async function checkOneBackend(
+  backend: string,
+  config: DoctorConfigSlice | undefined,
+  isActive: boolean,
 ): Promise<DoctorCheck[]> {
   const checks: DoctorCheck[] = [];
-  const backend = config?.backend ?? "claude";
 
   if (backend === "claude") {
     if (config?.claudeBinary) {
@@ -313,7 +364,9 @@ async function checkBackend(
           : { label: "Claude Code not found", status: "fail" },
       );
     }
-    checks.push(...(await checkClaudeConfiguredModels(config)));
+    // Model resolution spawns a probe — worth it for the backend actually
+    // serving chats, wasteful for one nobody is using.
+    if (isActive) checks.push(...(await checkClaudeConfiguredModels(config)));
   } else if (backend === "codex") {
     if (!binaryOnPath("codex")) {
       checks.push({
@@ -349,11 +402,21 @@ async function checkBackend(
       });
     }
   } else if (backend === "kilo" || backend === "opencode") {
-    // Bundled as npm deps — no external binary to check.
-    checks.push({
-      label: `${backend === "kilo" ? "Kilo" : "OpenCode"} SDK bundled`,
-      status: "ok",
-    });
+    // The SDK ships as an npm dep but only talks to a server it spawns from
+    // the CLI of the same name (`cross-spawn` → PATH lookup). A present
+    // package with an absent binary fails at the first turn with a bare
+    // ENOENT, so check what actually gets executed.
+    const label = backend === "kilo" ? "Kilo" : "OpenCode";
+    checks.push(
+      binaryOnPath(backend)
+        ? { label: `${label} CLI installed`, status: "ok" }
+        : {
+            label: `${label} CLI not found`,
+            status: "fail",
+            detail: `the ${label} SDK spawns \`${backend}\` — install it or this backend cannot start`,
+            issue: true,
+          },
+    );
   } else if (backend === "openai-agents") {
     checks.push({ label: "OpenAI Agents SDK bundled", status: "ok" });
     const hasEnvKey = Boolean(process.env.OPENAI_API_KEY);

package/src/frontend/discord/callbacks/components.ts

@@ -29,6 +29,14 @@ import {
 } from "discord.js";
 import type { TalonConfig } from "../../../util/config.js";
 import type { Gateway } from "../../../core/engine/gateway.js";
+import {
+  buildModelPickerView,
+  buildBackendPickerView,
+  decodeModelNav,
+  MODEL_NAV_PREFIX,
+  MODEL_PAGE_SIZE,
+} from "../model-picker.js";
+import { metricsViewRow, renderMetricsView } from "../commands/admin.js";
 import {
   getChatSettings,
   setChatModelForBackend,
@@ -52,7 +60,12 @@ import { execute } from "../../../core/engine/dispatcher.js";
 import {
   getBackendIdForChat,
   resolveChatBackend,
+  listAvailableBackends,
+  rebindChat,
 } from "../../../core/engine/backend-controller/index.js";
+import { resetSession } from "../../../storage/sessions.js";
+import { clearHistory } from "../../../storage/history.js";
+import { resetPulseCheckpoint } from "../../../core/background/pulse.js";
 import { resolveActiveModelForChat } from "../../../core/models/active-model.js";
 import {
   displayReasoningEffort,
@@ -286,6 +299,38 @@ export async function handleComponentInteraction(
     const be = resolveChatBackend(chatId, gateway?.backend);
     const beId = getBackendIdForChat(chatId);
 
+    // In the provider view the select carries chips, not models — picking
+    // one drills into that provider rather than choosing anything.
+    if (value?.startsWith("provider:") && be?.models?.getSettingsPresentation) {
+      const providerId = value.slice("provider:".length);
+      const { model: activeNow } = await resolveActiveModelForChat(
+        chatId,
+        be,
+        beId,
+        config,
+      );
+      const pres = await be.models.getSettingsPresentation(activeNow ?? "", {
+        callbackPrefix: "model:",
+        navCallbackPrefix: MODEL_NAV_PREFIX,
+        pageSize: MODEL_PAGE_SIZE,
+        provider: providerId,
+      });
+      const view = buildModelPickerView(
+        pres,
+        activeNow ?? "_No model selected_",
+        beId,
+      );
+      try {
+        await interaction.update({
+          content: view.content,
+          components: view.components,
+        });
+      } catch {
+        /* ignore */
+      }
+      return;
+    }
+
     if (value === "reset") {
       // Clear THIS backend's slot only — other backends stay intact.
       setChatModelForBackend(chatId, beId, undefined);
@@ -319,35 +364,234 @@ export async function handleComponentInteraction(
       const current = resolvedCurrent ?? "";
       const pres = await be.models?.getSettingsPresentation(current, {
         callbackPrefix: "model:",
+        navCallbackPrefix: MODEL_NAV_PREFIX,
+        pageSize: MODEL_PAGE_SIZE,
       });
       const modelInfo = resolvedCurrent
         ? await be.models?.getRawModelInfo?.(resolvedCurrent)
         : undefined;
       const displayName =
         modelInfo?.displayName ?? resolvedCurrent ?? "_No model selected_";
-      const menu = new StringSelectMenuBuilder()
-        .setCustomId("model:select")
-        .setPlaceholder("Pick a model")
-        .addOptions(
-          pres.modelButtons.slice(0, 25).map((b) => ({
-            label: safeSlice(b.text.replace(/^✓ /, ""), 100),
-            value: safeSlice(b.callback_data.replace(/^model:/, ""), 100),
-            default: b.text.startsWith("✓"),
-          })),
-        );
-      const row = new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(
-        menu,
+      const view = buildModelPickerView(pres, displayName, beId);
+      try {
+        await interaction.update({
+          content: view.content,
+          components: view.components,
+        });
+      } catch {
+        /* ignore */
+      }
+    }
+    return;
+  }
+
+  // ── /model pager — page arrows, free-tier toggle, provider drill ────────
+  // Pure navigation: re-render the same panel at the requested page without
+  // touching the chat's selected model.
+  if (customId.startsWith(`${MODEL_NAV_PREFIX}:`)) {
+    // Backend submenu — the one nav action that isn't a re-page.
+    if (customId === `${MODEL_NAV_PREFIX}:backends`) {
+      const view = buildBackendPickerView(
+        listAvailableBackends(config),
+        getBackendIdForChat(chatId),
       );
       try {
         await interaction.update({
-          content: [`**Model:** \`${displayName}\``, ...pres.modelDetails].join(
-            "\n",
-          ),
-          components: [row],
+          content: view.content,
+          components: view.components,
         });
       } catch {
         /* ignore */
       }
+      return;
+    }
+
+    const target = decodeModelNav(customId);
+    if (!target) {
+      try {
+        await interaction.deferUpdate();
+      } catch {
+        /* ignore */
+      }
+      return;
+    }
+    const be = resolveChatBackend(chatId, gateway?.backend);
+    const beId = getBackendIdForChat(chatId);
+    const { model: current } = await resolveActiveModelForChat(
+      chatId,
+      be,
+      beId,
+      config,
+    );
+    if (!be?.models?.getSettingsPresentation) {
+      try {
+        await interaction.deferUpdate();
+      } catch {
+        /* ignore */
+      }
+      return;
+    }
+    const pres = await be.models.getSettingsPresentation(current ?? "", {
+      callbackPrefix: "model:",
+      navCallbackPrefix: MODEL_NAV_PREFIX,
+      pageSize: MODEL_PAGE_SIZE,
+      page: target.page,
+      filter: target.filter,
+      ...(target.provider ? { provider: target.provider } : {}),
+    });
+    const modelInfo = current
+      ? await be.models?.getRawModelInfo?.(current)
+      : undefined;
+    const view = buildModelPickerView(
+      pres,
+      modelInfo?.displayName ?? current ?? "_No model selected_",
+      beId,
+    );
+    try {
+      await interaction.update({
+        content: view.content,
+        components: view.components,
+      });
+    } catch {
+      /* ignore */
+    }
+    return;
+  }
+
+  // ── /model backend switch ───────────────────────────────────────────────
+  // Rebinding drops this chat's session (it isn't portable across backends)
+  // but keeps each backend's remembered model pick, so switching back
+  // restores what was selected there before.
+  if (customId === "model:backend-select" && interaction.isStringSelectMenu()) {
+    const backendId = interaction.values[0] ?? "";
+    const available = listAvailableBackends(config);
+    if (!available.some((b) => b.id === backendId)) {
+      await interaction.reply({
+        content: "Backend not available.",
+        flags: MessageFlags.Ephemeral,
+      });
+      return;
+    }
+
+    // Booting a cold backend takes seconds — Kilo and OpenCode spawn a server
+    // and sweep MCP registrations — and Discord drops an interaction that
+    // isn't acknowledged within three. Ack first, edit the panel after.
+    try {
+      await interaction.deferUpdate();
+    } catch {
+      /* already acknowledged */
+    }
+    const fail = async (text: string): Promise<void> => {
+      try {
+        await interaction.followUp({
+          content: text,
+          flags: MessageFlags.Ephemeral,
+        });
+      } catch {
+        /* ignore */
+      }
+    };
+
+    // Resolve the outgoing backend before rebinding — afterwards the chat
+    // already points at the new one and the old instance is unreachable.
+    const previousId = getBackendIdForChat(chatId);
+    const previous = resolveChatBackend(chatId, gateway?.backend);
+    const alreadyThere = previousId === backendId;
+    const result = alreadyThere
+      ? { ok: true as const }
+      : await rebindChat(chatId, backendId, config);
+    if (!result.ok) {
+      await fail(result.error?.slice(0, 200) ?? "Rebind failed.");
+      return;
+    }
+    setChatBackend(chatId, backendId);
+
+    // The pool accepts a backend whose SDK is installed, but the SDK may only
+    // be a client for a CLI that isn't (OpenCode and Kilo spawn `opencode` /
+    // `kilo`). That surfaces here, on the first real call. Reading the
+    // catalog is the cheapest way to find out, and it is needed for the panel
+    // anyway — so treat a throw as "this backend can't serve" and put the
+    // chat back where it was rather than stranding it somewhere unusable.
+    let next = resolveChatBackend(chatId, gateway?.backend);
+    let newModel: string | undefined;
+    let pres;
+    try {
+      newModel =
+        (await resolveActiveModelForChat(chatId, next, backendId, config))
+          .model ?? undefined;
+      if (next?.models?.getSettingsPresentation) {
+        pres = await next.models.getSettingsPresentation(newModel ?? "", {
+          callbackPrefix: "model:",
+          navCallbackPrefix: MODEL_NAV_PREFIX,
+          pageSize: MODEL_PAGE_SIZE,
+        });
+      }
+    } catch (err) {
+      const reason = err instanceof Error ? err.message : String(err);
+      logError("discord", `Backend switch to ${backendId} failed`, err);
+      if (!alreadyThere) {
+        await rebindChat(chatId, previousId, config).catch(() => undefined);
+        setChatBackend(chatId, previousId);
+      }
+      await fail(
+        `⚠️ \`${backendId}\` could not start — staying on \`${previousId}\`.\n` +
+          `\`\`\`\n${safeSlice(reason, 300)}\n\`\`\``,
+      );
+      return;
+    }
+
+    // Only now is the switch known to hold. Session state doesn't port across
+    // backends, so it goes — but each backend's remembered model pick stays.
+    // A re-pick of the backend already in use clears nothing: the retry after
+    // a timed-out interaction must not cost the session a second time.
+    if (!alreadyThere) {
+      resetSession(chatId);
+      clearHistory(chatId);
+      resetPulseCheckpoint(chatId);
+      previous?.sessions?.resetChat?.(chatId);
+    }
+
+    next = resolveChatBackend(chatId, gateway?.backend);
+    // Warming is fire-and-forget: it can take seconds on OpenCode/Kilo and
+    // the interaction still has a panel to redraw.
+    if (next && next !== previous) {
+      void Promise.resolve(next.sessions?.warmSession?.(chatId)).catch(
+        () => undefined,
+      );
+    }
+
+    try {
+      await interaction.editReply(
+        pres
+          ? {
+              ...buildModelPickerView(
+                pres,
+                newModel ?? "_No model selected_",
+                backendId,
+              ),
+            }
+          : {
+              content: `**Backend:** \`${backendId}\` · model \`${newModel ?? "none"}\``,
+              components: [],
+            },
+      );
+    } catch {
+      /* ignore */
+    }
+    return;
+  }
+
+  // ── /metrics today ↔ all-time toggle ────────────────────────────────────
+  if (customId === "metrics:today" || customId === "metrics:all") {
+    const view = customId === "metrics:all" ? "all" : "today";
+    const messages = renderMetricsView(view);
+    try {
+      await interaction.update({
+        content: messages[0]!,
+        components: [metricsViewRow(view).toJSON()],
+      });
+    } catch {
+      /* ignore */
     }
     return;
   }

package/src/frontend/discord/commands/admin.ts

@@ -3,16 +3,37 @@
  * All gate on `isAdmin`.
  */
 
-import { type ChatInputCommandInteraction, MessageFlags } from "discord.js";
+import {
+  type ChatInputCommandInteraction,
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  MessageFlags,
+} from "discord.js";
 import type { TalonConfig } from "../../../util/config.js";
 import type { Gateway } from "../../../core/engine/gateway.js";
 import { respawnSelf } from "../../../util/respawn.js";
 import { forceDream } from "../../../core/background/dream.js";
-import { formatDuration, renderMetricsMessages } from "../helpers.js";
+import {
+  formatDuration,
+  renderMetricsMessages,
+  renderDoctorMessages,
+} from "../helpers.js";
+import { collectDoctorReport } from "../../../core/doctor.js";
+import { getSoul } from "../../../core/soul/service.js";
 import { getMetrics, getTodayMetrics } from "../../../storage/metrics.js";
 import { handleAdminSubcommand } from "../admin.js";
 import { isAdmin } from "../handlers/index.js";
-import { suppressMentions, DISCORD_MAX_TEXT } from "../formatting.js";
+import {
+  suppressMentions,
+  DISCORD_MAX_TEXT,
+  safeSlice,
+  escapeForCodeBlock,
+} from "../formatting.js";
+import {
+  getRepoRoot,
+  runSelfUpdate,
+} from "../../../core/update/self-update.js";
 import { reply } from "./shared.js";
 
 export async function handleRestart(
@@ -34,18 +55,112 @@ export async function handleMetrics(
     return;
   }
   // Ephemeral — admin counters (token usage, latencies, errors) shouldn't leak
-  // into a public channel where non-admins can read them.
-  const messages = [
-    ...renderMetricsMessages(getMetrics()),
-    ...renderMetricsMessages(
-      getTodayMetrics(),
-      undefined,
-      "📊 Metrics — today (UTC)",
-    ),
-  ];
-  for (const m of messages) {
-    await reply(i, m, true);
+  // into a public channel where non-admins can read them. Both views are one
+  // button apart rather than two bursts of messages.
+  await i.deferReply({ flags: MessageFlags.Ephemeral });
+  const messages = renderMetricsMessages(
+    getTodayMetrics(),
+    undefined,
+    "📊 Metrics — today (UTC)",
+  );
+  await i.editReply({
+    content: messages[0]!,
+    components: [metricsViewRow("today").toJSON()],
+  });
+  for (const extra of messages.slice(1)) {
+    await i.followUp({ content: extra, flags: MessageFlags.Ephemeral });
+  }
+}
+
+/** Today / all-time toggle under the metrics panel. */
+export function metricsViewRow(
+  view: MetricsView,
+): ActionRowBuilder<ButtonBuilder> {
+  return new ActionRowBuilder<ButtonBuilder>().addComponents(
+    new ButtonBuilder()
+      .setCustomId("metrics:today")
+      .setLabel("Today")
+      .setStyle(view === "today" ? ButtonStyle.Primary : ButtonStyle.Secondary)
+      .setDisabled(view === "today"),
+    new ButtonBuilder()
+      .setCustomId("metrics:all")
+      .setLabel("All time")
+      .setStyle(view === "all" ? ButtonStyle.Primary : ButtonStyle.Secondary)
+      .setDisabled(view === "all"),
+  );
+}
+
+export type MetricsView = "today" | "all";
+
+/** Panel body for one view — shared by the command and the toggle. */
+export function renderMetricsView(view: MetricsView): string[] {
+  return view === "today"
+    ? renderMetricsMessages(
+        getTodayMetrics(),
+        undefined,
+        "📊 Metrics — today (UTC)",
+      )
+    : renderMetricsMessages(getMetrics(), undefined, "📊 Metrics — all time");
+}
+
+export async function handleDoctor(
+  i: ChatInputCommandInteraction,
+  config: TalonConfig,
+): Promise<void> {
+  if (!isAdmin(i.user.id)) {
+    await reply(i, "Not authorized.", true);
+    return;
+  }
+  await i.deferReply({ flags: MessageFlags.Ephemeral });
+  await i.editReply("🩺 Running checks...");
+  try {
+    // Same checks as `talon doctor` — config exists by definition when the
+    // bot is processing this command.
+    const report = await collectDoctorReport({ config, hasConfigFile: true });
+    const messages = renderDoctorMessages(report);
+    await i.editReply(messages[0]!);
+    for (const extra of messages.slice(1))
+      await i.followUp({
+        content: extra,
+        flags: MessageFlags.Ephemeral,
+      });
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    await i.editReply(`🩺 Doctor failed: ${msg}`);
+  }
+}
+
+/**
+ * /soul — read-only introspection of the compiled identity. `action:dream`
+ * runs the organic maintenance pass and is admin-only. Inert while the soul
+ * is disabled, so it is safe to ship dormant.
+ */
+export async function handleSoul(
+  i: ChatInputCommandInteraction,
+): Promise<void> {
+  const soul = getSoul();
+  if (!soul.enabled) {
+    await reply(
+      i,
+      "Soul is disabled (set TALON_SOUL_ENABLED to enable).",
+      true,
+    );
+    return;
+  }
+  if (i.options.getString("action") === "dream") {
+    if (!isAdmin(i.user.id)) {
+      await reply(i, "Not authorized.", true);
+      return;
+    }
+    await i.deferReply({ flags: MessageFlags.Ephemeral });
+    await i.editReply("🧠 Soul dreaming...");
+    soul
+      .dream()
+      .then(() => i.editReply("🧠 Soul dream complete."))
+      .catch(() => undefined);
+    return;
   }
+  await reply(i, suppressMentions(soul.introspect()), true);
 }
 
 export async function handleDream(
@@ -71,6 +186,65 @@ export async function handleDream(
     });
 }
 
+/**
+ * /update — pull, reinstall, run setup, restart. Only reachable on developer
+ * builds running from a git checkout; the command is not registered at all
+ * otherwise (see buildCommandDefinitions).
+ */
+export async function handleUpdate(
+  i: ChatInputCommandInteraction,
+  config: TalonConfig,
+): Promise<void> {
+  if (!isAdmin(i.user.id)) {
+    await reply(i, "Not authorized.", true);
+    return;
+  }
+  const repoRoot = config.devBuild ? getRepoRoot() : null;
+  if (!repoRoot) {
+    await reply(i, "Update is only available on developer builds.", true);
+    return;
+  }
+  const remote = config.update?.remote ?? "origin";
+  const branch = config.update?.branch ?? "main";
+  await i.deferReply({ flags: MessageFlags.Ephemeral });
+  await i.editReply(`⏳ Updating from \`${remote}/${branch}\`…`);
+  const edit = (text: string) => i.editReply(safeSlice(text, DISCORD_MAX_TEXT));
+
+  // Fire-and-forget so the gateway keeps processing other interactions.
+  runSelfUpdate({
+    remote,
+    branch,
+    setup: config.update?.setup,
+    repoRoot,
+  })
+    .then(async (res) => {
+      if (!res.ok) {
+        const tail = res.steps[res.steps.length - 1]?.output ?? "";
+        await edit(
+          `⚠️ Update failed: ${res.error ?? "unknown error"}` +
+            (tail
+              ? `\n\`\`\`\n${escapeForCodeBlock(tail.slice(-1200))}\n\`\`\``
+              : ""),
+        );
+        return;
+      }
+      if (!res.changed) {
+        await edit(
+          `✅ Already up to date at \`${res.before ?? "?"}\` — no restart needed.`,
+        );
+        return;
+      }
+      await edit(
+        `✅ Updated \`${res.before ?? "?"}\` → \`${res.after ?? "?"}\`. ♻️ Restarting…`,
+      );
+      respawnSelf("discord /update");
+    })
+    .catch(async (err: unknown) => {
+      const msg = err instanceof Error ? err.message : String(err);
+      await edit(`⚠️ Update crashed: ${msg}`);
+    });
+}
+
 export async function handleAdmin(
   i: ChatInputCommandInteraction,
   config: TalonConfig,