talon-agent 3.16.1 → 3.18.0

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

@@ -15,8 +15,9 @@
 import { type Client, REST, Routes, SlashCommandBuilder } from "discord.js";
 import type { TalonConfig } from "../../../util/config.js";
 import { log, logError, logWarn } from "../../../util/log.js";
+import { getRepoRoot } from "../../../core/update/self-update.js";
 
-export function buildCommandDefinitions(): unknown[] {
+export function buildCommandDefinitions(devBuild = false): unknown[] {
   return [
     new SlashCommandBuilder()
       .setName("start")
@@ -97,6 +98,40 @@ export function buildCommandDefinitions(): unknown[] {
       .setName("plugins")
       .setDescription("List loaded plugins")
       .toJSON(),
+    new SlashCommandBuilder()
+      .setName("usage")
+      .setDescription("Plan limits across every backend")
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName("doctor")
+      .setDescription("Environment and native-module health (admin)")
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName("mesh")
+      .setDescription("Ping and list mesh devices")
+      .toJSON(),
+    new SlashCommandBuilder()
+      .setName("soul")
+      .setDescription("Inspect the compiled identity")
+      .addStringOption((o) =>
+        o
+          .setName("action")
+          .setDescription("Leave empty to introspect")
+          .setRequired(false)
+          .addChoices({ name: "dream", value: "dream" }),
+      )
+      .toJSON(),
+    // /update only exists on developer builds running from a git checkout —
+    // a packaged binary has no source tree to pull into, so the command is
+    // never registered there (same gate as the Telegram handler).
+    ...(devBuild && getRepoRoot()
+      ? [
+          new SlashCommandBuilder()
+            .setName("update")
+            .setDescription("Pull latest, reinstall, restart (admin)")
+            .toJSON(),
+        ]
+      : []),
     new SlashCommandBuilder()
       .setName("admin")
       .setDescription("Admin operations (admin only)")
@@ -128,7 +163,7 @@ export async function registerCommandsForGuilds(
 ): Promise<void> {
   const dc = config.discord!;
   const rest = new REST({ version: "10" }).setToken(dc.botToken);
-  const definitions = buildCommandDefinitions();
+  const definitions = buildCommandDefinitions(config.devBuild);
 
   // Step 1: clear or set global commands depending on DM setting.
   try {

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

@@ -7,8 +7,16 @@ import {
   type Client,
   MessageFlags,
 } from "discord.js";
-import { formatDuration } from "../helpers.js";
+import {
+  formatDuration,
+  renderMeshReport,
+  renderUsageMessage,
+} from "../helpers.js";
+import type { TalonConfig } from "../../../util/config.js";
+import { collectPlanUsage } from "../../shared/plan-usage-report.js";
 import { getLoadedPlugins } from "../../../core/plugin/index.js";
+import { getMeshService } from "../../../core/mesh/index.js";
+import type { MeshPingResult } from "../../../core/mesh/service.js";
 import { reply } from "./shared.js";
 
 export async function handleStart(
@@ -67,6 +75,35 @@ export async function handleHelp(
   );
 }
 
+/**
+ * /usage — plan limits across every exposed backend, not just this chat's.
+ * Not admin-gated: it says how close the shared account is to a wall, which
+ * is exactly what a user hitting one needs to know.
+ */
+export async function handleUsage(
+  i: ChatInputCommandInteraction,
+  config: TalonConfig,
+): Promise<void> {
+  await i.deferReply({ flags: MessageFlags.Ephemeral });
+  const entries = await collectPlanUsage(config);
+  await i.editReply(renderUsageMessage(entries));
+}
+
+export async function handleMesh(
+  i: ChatInputCommandInteraction,
+): Promise<void> {
+  await i.deferReply({ flags: MessageFlags.Ephemeral });
+  await i.editReply("Pinging mesh devices…");
+  let results: MeshPingResult[];
+  try {
+    results = await getMeshService().pingAll();
+  } catch {
+    await i.editReply("Could not reach the mesh service.");
+    return;
+  }
+  await i.editReply(renderMeshReport(results));
+}
+
 export async function handlePing(
   i: ChatInputCommandInteraction,
 ): Promise<void> {

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

@@ -22,7 +22,14 @@ import {
   handleModalSubmit,
 } from "../callbacks/index.js";
 import { chatIdFromInteraction, reply, client } from "./shared.js";
-import { handleStart, handleHelp, handlePing, handlePlugins } from "./info.js";
+import {
+  handleStart,
+  handleHelp,
+  handlePing,
+  handlePlugins,
+  handleMesh,
+  handleUsage,
+} from "./info.js";
 import { handleReset, handleStatus } from "./session.js";
 import {
   handleModel,
@@ -35,6 +42,9 @@ import {
   handleMetrics,
   handleDream,
   handleAdmin,
+  handleDoctor,
+  handleSoul,
+  handleUpdate,
 } from "./admin.js";
 
 export function registerInteractionRouter(
@@ -141,6 +151,16 @@ async function routeSlashCommand(
       return handleDream(interaction);
     case "plugins":
       return handlePlugins(interaction);
+    case "usage":
+      return handleUsage(interaction, config);
+    case "doctor":
+      return handleDoctor(interaction, config);
+    case "mesh":
+      return handleMesh(interaction);
+    case "soul":
+      return handleSoul(interaction);
+    case "update":
+      return handleUpdate(interaction, config);
     case "admin":
       return handleAdmin(interaction, config, gateway);
     default:

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

@@ -46,6 +46,11 @@ import {
 import { resolveActiveModelForChat } from "../../../core/models/active-model.js";
 import { safeSlice } from "../formatting.js";
 import { reply } from "./shared.js";
+import {
+  buildModelPickerView,
+  MODEL_NAV_PREFIX,
+  MODEL_PAGE_SIZE,
+} from "../model-picker.js";
 
 export async function handleModel(
   i: ChatInputCommandInteraction,
@@ -94,6 +99,8 @@ export async function handleModel(
     if (be?.models?.getSettingsPresentation) {
       const pres = await be.models?.getSettingsPresentation(activeModel, {
         callbackPrefix: "model:",
+        navCallbackPrefix: MODEL_NAV_PREFIX,
+        pageSize: MODEL_PAGE_SIZE,
       });
       const modelInfo = activeModel
         ? await be.models?.getRawModelInfo?.(activeModel)
@@ -102,25 +109,10 @@ export async function handleModel(
         modelInfo?.displayName ??
         (activeModel ? formatModelLabel(activeModel) : "_No model selected_");
 
-      // Build select menu from the top 25 models. Discord caps select-menu
-      // options at 25; if the backend exposes more, use `/model name:<value>`
-      // (autocomplete-backed) to pick anything outside this list.
-      const options = 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 menu = new StringSelectMenuBuilder()
-        .setCustomId("model:select")
-        .setPlaceholder("Pick a model")
-        .addOptions(options);
-      const row = new ActionRowBuilder<StringSelectMenuBuilder>().addComponents(
-        menu,
-      );
-      const lines = [`**Model:** \`${displayName}\``, ...pres.modelDetails];
+      const view = buildModelPickerView(pres, displayName, beId);
       await i.editReply({
-        content: lines.join("\n"),
-        components: [row],
+        content: view.content,
+        components: view.components,
         allowedMentions: { parse: [] },
       });
     } else {

package/src/frontend/discord/helpers.ts

@@ -8,10 +8,18 @@
  */
 
 import { REASONING_LEVEL_DESCRIPTIONS } from "../../core/models/reasoning-levels.js";
-import { DISCORD_MAX_TEXT, DISCORD_SAFE_RESERVE } from "./formatting.js";
+import {
+  DISCORD_MAX_TEXT,
+  DISCORD_SAFE_RESERVE,
+  splitMessage,
+} from "./formatting.js";
+import type { DoctorReport } from "../../core/doctor.js";
+import type { MeshPingResult } from "../../core/mesh/service.js";
+import type { BackendUsageEntry } from "../shared/plan-usage-report.js";
 import {
   DEFAULT_PULSE_INTERVAL_MS,
   formatDuration,
+  formatBytes,
   formatModelLabel,
 } from "../shared/format.js";
 
@@ -157,6 +165,145 @@ export function renderMetricsMessages(
   return chunks;
 }
 
+const DOCTOR_ICONS: Record<string, string> = {
+  ok: "✅",
+  warn: "⚠️",
+  fail: "❌",
+  info: "▫️",
+};
+
+/**
+ * Render a DoctorReport as Discord markdown, split to fit the message cap.
+ * Same data as `talon doctor` and Telegram's /doctor.
+ */
+export function renderDoctorMessages(
+  report: DoctorReport,
+  maxLen = DEFAULT_METRICS_MESSAGE_MAX,
+): string[] {
+  const lines = ["**🩺 Talon Doctor**", "", "**Environment**"];
+
+  const render = (check: DoctorReport["checks"][number]): string =>
+    `${DOCTOR_ICONS[check.status]} ${check.label}${check.detail ? ` (${check.detail})` : ""}`;
+
+  for (const check of report.checks.filter((c) => !c.inactive)) {
+    lines.push(render(check));
+  }
+
+  // Configured-but-idle backends get their own block: they describe what a
+  // switch would run into, not the state of the running deployment.
+  const idle = report.checks.filter((c) => c.inactive);
+  if (idle.length > 0) {
+    lines.push("", "**Other backends**", ...idle.map(render));
+  }
+
+  lines.push("", "**Native modules**");
+  for (const mod of report.native) {
+    const size =
+      mod.sizeBytes !== undefined ? ` · ${formatBytes(mod.sizeBytes)}` : "";
+    const note = mod.note ? ` (${mod.note})` : "";
+    lines.push(
+      `${mod.ok ? DOCTOR_ICONS.ok : DOCTOR_ICONS.fail} \`${mod.name}\` — ${mod.language} → ${mod.target}${size}${note}`,
+    );
+  }
+
+  lines.push(
+    "",
+    "**Process**",
+    `Uptime ${formatDuration(process.uptime() * 1000)} · PID ${process.pid} · Node ${process.versions.node}`,
+    "",
+    report.issues === 0
+      ? `${DOCTOR_ICONS.ok} All checks passed.`
+      : `${DOCTOR_ICONS.warn} ${report.issues} issue(s) found.`,
+  );
+
+  return splitMessage(lines.join("\n"), maxLen);
+}
+
+function meshDeviceLine(r: MeshPingResult, now: number): string {
+  const d = r.device;
+  const bits: string[] = [d.platform];
+  if (r.reachable && typeof r.latencyMs === "number") {
+    bits.push(`${r.latencyMs} ms`);
+  } else if (d.online && r.error) {
+    bits.push(r.error);
+  } else if (!d.online) {
+    bits.push(`last seen ${formatDuration(now - d.lastSeen)} ago`);
+  }
+  if (typeof d.battery === "number") {
+    bits.push(`${d.battery}%${d.charging ? " charging" : ""}`);
+  }
+  return `  **${d.name}** — ${bits.join(" · ")}`;
+}
+
+/**
+ * Render the /mesh fleet report as Discord markdown. Devices group under a
+ * state heading; empty groups are omitted.
+ */
+export function renderMeshReport(
+  results: MeshPingResult[],
+  now = Date.now(),
+): string {
+  if (results.length === 0) {
+    return "**Mesh**\n\n_No devices have registered yet._";
+  }
+
+  const responding = results
+    .filter((r) => r.reachable)
+    .sort((a, b) => (a.latencyMs ?? Infinity) - (b.latencyMs ?? Infinity));
+  const unreachable = results
+    .filter((r) => !r.reachable && r.device.online)
+    .sort((a, b) => a.device.name.localeCompare(b.device.name));
+  const offline = results
+    .filter((r) => !r.reachable && !r.device.online)
+    .sort((a, b) => b.device.lastSeen - a.device.lastSeen);
+
+  const summary = [
+    `${results.length} device${results.length === 1 ? "" : "s"}`,
+    `${responding.length} responding`,
+    ...(unreachable.length > 0 ? [`${unreachable.length} unreachable`] : []),
+    ...(offline.length > 0 ? [`${offline.length} offline`] : []),
+  ].join(" · ");
+
+  const lines = ["**Mesh**", summary];
+  const section = (title: string, entries: MeshPingResult[]): void => {
+    if (entries.length === 0) return;
+    lines.push(
+      "",
+      `**${title}**`,
+      ...entries.map((r) => meshDeviceLine(r, now)),
+    );
+  };
+  section("Responding", responding);
+  section("Unreachable", unreachable);
+  section("Offline", offline);
+
+  return lines.join("\n");
+}
+
+/** Render the `/usage` report — one block per exposed backend. */
+export function renderUsageMessage(entries: BackendUsageEntry[]): string {
+  const lines = ["**📊 Plan usage**"];
+
+  for (const entry of entries) {
+    const name = entry.label || entry.id;
+    if (!entry.plan) {
+      lines.push("", `**${name}** — _${entry.note ?? ""}_`);
+      continue;
+    }
+    const age = entry.plan.ageLabel ? ` *(${entry.plan.ageLabel})*` : "";
+    const plan = entry.plan.plan ? ` · ${entry.plan.plan}` : "";
+    lines.push("", `**${name}**${plan}${age}`);
+    for (const w of entry.plan.windows) {
+      const reset = w.resetLabel ? ` reset ${w.resetLabel}` : "";
+      lines.push(
+        `  \`${w.label.padEnd(6)}${w.bar} ${String(w.percent).padStart(3)}%\`${reset}`,
+      );
+    }
+  }
+
+  return lines.join("\n");
+}
+
 /** Settings panel: build the markdown body. */
 export function renderSettingsText(
   model: string,

package/src/frontend/discord/index.ts

@@ -73,8 +73,17 @@ export function createDiscordFrontend(
       GatewayIntentBits.MessageContent,
       GatewayIntentBits.DirectMessages,
       GatewayIntentBits.GuildMessageReactions,
+      GatewayIntentBits.DirectMessageReactions,
+    ],
+    // Partials.Reaction is what makes reactions on messages that predate the
+    // current cache arrive at all — without it the soul's reaction tap only
+    // ever sees freshly-cached messages.
+    partials: [
+      Partials.Channel,
+      Partials.Message,
+      Partials.User,
+      Partials.Reaction,
     ],
-    partials: [Partials.Channel, Partials.Message, Partials.User],
     allowedMentions: { parse: [] }, // never ping anyone unless we explicitly opt in
   });
 

package/src/frontend/discord/middleware.ts

@@ -21,6 +21,7 @@ import { pushMessage } from "../../storage/history.js";
 import { registerChat } from "../../core/background/pulse.js";
 import { deriveNumericChatId } from "../../util/chat-id.js";
 import { handleMessage, getSenderName } from "./handlers/index.js";
+import { recordReactionToBot } from "../../core/soul/taps.js";
 
 export function registerMiddleware(client: Client, config: TalonConfig): void {
   client.on("messageCreate", (msg: Message) => {
@@ -85,4 +86,27 @@ export function registerMiddleware(client: Client, config: TalonConfig): void {
       /* logged inside */
     });
   });
+
+  // ── Reaction tap — feed reactions on Talon's own messages to the soul ────
+  // The gateway records outgoing message ids as `Number(snowflake)`, so the
+  // lookup here must use the same conversion to match. Inert unless the soul
+  // is enabled.
+  client.on("messageReactionAdd", async (reaction, user) => {
+    if (user.id === client.user?.id) return;
+    try {
+      // A partial arrives when the message predates the cache; the chat id
+      // can't be built without the channel/guild it belongs to.
+      if (reaction.partial) await reaction.fetch();
+    } catch {
+      return;
+    }
+    const msg = reaction.message;
+    const emoji = reaction.emoji.name;
+    if (!emoji) return;
+    const chatId =
+      msg.channel.type === ChannelType.DM
+        ? `discord_dm_${msg.author?.id ?? user.id}`
+        : `discord_guild_${msg.guildId}_${msg.channelId}`;
+    recordReactionToBot(chatId, Number(msg.id), [emoji]);
+  });
 }

package/src/frontend/discord/model-picker.ts

@@ -0,0 +1,234 @@
+/**
+ * Model picker rendering — select menu plus pager controls.
+ *
+ * The backend already paginates and filters the catalog
+ * (`getSettingsPresentation` returns page / totalPages / filter / provider);
+ * this only lays that out as Discord components. A select menu caps at 25
+ * options, so without the pager everything past the first 25 models was
+ * unreachable from the UI.
+ *
+ * Navigation state rides in the custom_id — `model:nav:page:3:free` — which
+ * is what keeps the handler stateless across re-renders.
+ */
+
+import {
+  ActionRowBuilder,
+  ButtonBuilder,
+  ButtonStyle,
+  StringSelectMenuBuilder,
+  type APIActionRowComponent,
+  type APIComponentInMessageActionRow,
+} from "discord.js";
+import type { ModelPickerResult } from "../../core/types.js";
+import { safeSlice } from "./formatting.js";
+
+export const MODEL_NAV_PREFIX = "model:nav";
+/** Discord's hard cap on select-menu options — also the page size we request. */
+export const MODEL_PAGE_SIZE = 25;
+
+/** Where a nav button points. Decoded from a `model:nav:…` custom_id. */
+export type ModelNavTarget = {
+  page: number;
+  filter: "all" | "free";
+  provider?: string;
+};
+
+export function decodeModelNav(customId: string): ModelNavTarget | null {
+  if (!customId.startsWith(`${MODEL_NAV_PREFIX}:`)) return null;
+  const parts = customId.slice(MODEL_NAV_PREFIX.length + 1).split(":");
+  const [kind] = parts;
+
+  if (kind === "providers") return { page: 1, filter: "all" };
+  if (kind === "provider") {
+    return { page: 1, filter: "all", provider: parts[1] };
+  }
+  if (kind === "page") {
+    const page = Number(parts[1]);
+    const filter = parts[2] === "free" ? "free" : "all";
+    return {
+      page: Number.isFinite(page) && page > 0 ? page : 1,
+      filter,
+      ...(parts[3] ? { provider: parts[3] } : {}),
+    };
+  }
+  if (kind === "filter") {
+    const filter = parts[1] === "free" ? "free" : "all";
+    return { page: 1, filter, ...(parts[2] ? { provider: parts[2] } : {}) };
+  }
+  return null;
+}
+
+function navId(suffix: string, provider?: string): string {
+  const base = `${MODEL_NAV_PREFIX}:${suffix}`;
+  return provider ? `${base}:${provider}` : base;
+}
+
+/**
+ * Buttons under the select: page arrows, a page counter, the free-tier
+ * toggle, and a way back to the provider list. Five buttons is exactly one
+ * Action Row, so this never spills into a second row.
+ */
+function controlRow(
+  pres: ModelPickerResult,
+): ActionRowBuilder<ButtonBuilder> | null {
+  const buttons: ButtonBuilder[] = [];
+  const { page, totalPages, filter, freeCount, provider } = pres;
+
+  if (totalPages > 1) {
+    buttons.push(
+      new ButtonBuilder()
+        .setCustomId(navId(`page:${page - 1}:${filter}`, provider))
+        .setLabel("◀")
+        .setStyle(ButtonStyle.Secondary)
+        .setDisabled(page <= 1),
+      // A disabled button is the only way to render a static counter
+      // inline with the arrows.
+      new ButtonBuilder()
+        .setCustomId(navId("noop"))
+        .setLabel(`${page}/${totalPages}`)
+        .setStyle(ButtonStyle.Secondary)
+        .setDisabled(true),
+      new ButtonBuilder()
+        .setCustomId(navId(`page:${page + 1}:${filter}`, provider))
+        .setLabel("▶")
+        .setStyle(ButtonStyle.Secondary)
+        .setDisabled(page >= totalPages),
+    );
+  }
+
+  // A filter that would keep everything is just a button that does nothing —
+  // offer it only when part of the catalog costs money.
+  if (freeCount > 0 && freeCount < pres.totalCount) {
+    buttons.push(
+      new ButtonBuilder()
+        .setCustomId(
+          navId(`filter:${filter === "free" ? "all" : "free"}`, provider),
+        )
+        .setLabel(filter === "free" ? `All models` : `Free only (${freeCount})`)
+        .setStyle(ButtonStyle.Secondary),
+    );
+  }
+
+  if (provider) {
+    buttons.push(
+      new ButtonBuilder()
+        .setCustomId(navId("providers"))
+        .setLabel("← Providers")
+        .setStyle(ButtonStyle.Secondary),
+    );
+  }
+
+  if (buttons.length === 0) return null;
+  return new ActionRowBuilder<ButtonBuilder>().addComponents(buttons);
+}
+
+export interface ModelPickerView {
+  content: string;
+  components: APIActionRowComponent<APIComponentInMessageActionRow>[];
+}
+
+/** Select of the backends config exposes, plus a way back to the models. */
+export function buildBackendPickerView(
+  backends: { id: string; label: string }[],
+  currentId: string,
+): ModelPickerView {
+  const menu = new StringSelectMenuBuilder()
+    .setCustomId("model:backend-select")
+    .setPlaceholder("Pick a backend")
+    .addOptions(
+      backends.map((b) => ({
+        label: safeSlice(b.label || b.id, 100),
+        value: safeSlice(b.id, 100),
+        description: b.id === currentId ? "current" : undefined,
+        default: b.id === currentId,
+      })),
+    );
+
+  const back = new ActionRowBuilder<ButtonBuilder>().addComponents(
+    new ButtonBuilder()
+      .setCustomId(navId("page:1:all"))
+      .setLabel("← Models")
+      .setStyle(ButtonStyle.Secondary),
+  );
+
+  return {
+    content: [
+      `**Backend:** \`${currentId}\``,
+      "",
+      "_Switching clears this chat's session — each backend keeps its own model pick._",
+    ].join("\n"),
+    components: [
+      new ActionRowBuilder<StringSelectMenuBuilder>()
+        .addComponents(menu)
+        .toJSON(),
+      back.toJSON(),
+    ],
+  };
+}
+
+/**
+ * Lay out one page of the picker. In the `groups` view the select lists
+ * providers to drill into; in `models` it lists selectable models.
+ */
+export function buildModelPickerView(
+  pres: ModelPickerResult,
+  displayName: string,
+  backendId: string,
+): ModelPickerView {
+  const isGroups = pres.view === "groups";
+  const options = pres.modelButtons.slice(0, MODEL_PAGE_SIZE).map((b) => ({
+    // Discord's own guidance is ~38 characters before a label starts
+    // truncating visually, well under the 100-character hard cap.
+    label: safeSlice(b.text.replace(/^✓ /, ""), 100),
+    value: safeSlice(
+      isGroups
+        ? b.callback_data.replace(/^.*:provider:/, "provider:")
+        : b.callback_data.replace(/^model:/, ""),
+      100,
+    ),
+    default: !isGroups && b.text.startsWith("✓"),
+  }));
+
+  const components: APIActionRowComponent<APIComponentInMessageActionRow>[] =
+    [];
+
+  if (options.length > 0) {
+    const menu = new StringSelectMenuBuilder()
+      .setCustomId("model:select")
+      .setPlaceholder(isGroups ? "Pick a provider" : "Pick a model")
+      .addOptions(options);
+    components.push(
+      new ActionRowBuilder<StringSelectMenuBuilder>()
+        .addComponents(menu)
+        .toJSON(),
+    );
+  }
+
+  const controls = controlRow(pres);
+  if (controls) components.push(controls.toJSON());
+
+  // Own row: the control row is already at Discord's five-button ceiling
+  // whenever the catalog pages.
+  components.push(
+    new ActionRowBuilder<ButtonBuilder>()
+      .addComponents(
+        new ButtonBuilder()
+          .setCustomId(navId("backends"))
+          .setLabel(`⚙ Backend: ${backendId}`)
+          .setStyle(ButtonStyle.Secondary),
+      )
+      .toJSON(),
+  );
+
+  const scope = pres.provider ? ` · ${pres.provider}` : "";
+  const counts =
+    pres.totalPages > 1
+      ? ` · ${pres.totalCount} model${pres.totalCount === 1 ? "" : "s"}`
+      : "";
+  const lines = [
+    `**Model:** \`${displayName}\`${scope}${counts}`,
+    ...pres.modelDetails,
+  ];
+
+  return { content: lines.join("\n"), components };
+}