talon-agent 5.18.2 → 5.19.0

package/src/core/mesh/transfers/transfers.ts

@@ -55,6 +55,8 @@ type Transfer = {
     resolve: (bytes: number) => void;
     reject: (err: Error) => void;
   };
+  /** pull only — tears down the upload once its HTTP leg is streaming. */
+  abort?: AbortController;
 };
 
 export class TransferStore {
@@ -104,12 +106,19 @@ export class TransferStore {
     return { token };
   }
 
-  /** Drop a token (transfer arrangement failed before the HTTP leg). */
+  /**
+   * Drop a token — the arrangement failed, or the daemon gave up waiting.
+   * An upload already streaming is aborted too: otherwise a peer that
+   * stalls mid-body holds the request (and its temp file) open until the
+   * bridge's whole-request deadline, and one that finishes late renames a
+   * file into place after the caller was told the pull failed.
+   */
   cancel(token: string): void {
     const t = this.transfers.get(token);
     if (t?.uploadDone && !t.consumed) {
       t.uploadDone.reject(new Error("transfer cancelled"));
     }
+    t?.abort?.abort(new Error("transfer cancelled"));
     this.transfers.delete(token);
   }
 
@@ -129,11 +138,16 @@ export class TransferStore {
     if (!t)
       return { ok: false, error: "Unknown or already-used transfer token." };
     const tmp = `${t.localPath}.part-${randomBytes(4).toString("hex")}`;
+    const abort = new AbortController();
+    t.abort = abort;
     try {
       await mkdir(dirname(t.localPath), { recursive: true });
       let bytes = 0;
       body.on("data", (d: Buffer) => (bytes += d.length));
-      await pipeline(body, createWriteStream(tmp, { mode: 0o600 }));
+      await pipeline(body, createWriteStream(tmp, { mode: 0o600 }), {
+        signal: abort.signal,
+      });
+      abort.signal.throwIfAborted();
       await rename(tmp, t.localPath);
       this.transfers.delete(token);
       t.uploadDone?.resolve(bytes);
@@ -162,7 +176,6 @@ export class TransferStore {
       if (!s.isFile()) throw new Error("not a file");
       return { path: t.localPath, size: s.size };
     } catch {
-      this.transfers.delete(token);
       return null;
     } finally {
       // Single-use either way; the device retries by re-arranging.

package/src/core/models/active-model.ts

@@ -60,10 +60,7 @@
  * have their stored override returned verbatim — no way to validate.
  */
 
-import {
-  getChatModelForBackend,
-  getChatSettings,
-} from "../../storage/chat-settings.js";
+import { getChatModelForBackend } from "../../storage/chat-settings.js";
 import type { Backend } from "../agent-runtime/capabilities.js";
 import {
   isBackendId,
@@ -82,7 +79,7 @@ import { logWarn } from "../../util/log.js";
  * (default)" vs "Model: X (override)" vs "No model selected" without
  * second-guessing the chain.
  */
-export type ActiveModelSource =
+type ActiveModelSource =
   | "override-valid"
   | "override-invalid-fallback"
   | "backend-canonical"
@@ -311,25 +308,6 @@ async function safeBackendDefault(backend: Backend): Promise<string | null> {
   }
 }
 
-/**
- * Convenience: same as `resolveActiveModelForChat` but returns just
- * the model id (or `null`). Use when the source tag isn't needed.
- */
-export async function getActiveModelForChat(
-  chatId: string,
-  backend: Backend | null,
-  backendId: string | null,
-  config: TalonConfig,
-): Promise<string | null> {
-  const { model } = await resolveActiveModelForChat(
-    chatId,
-    backend,
-    backendId,
-    config,
-  );
-  return model;
-}
-
 // ── ref enrichment ──────────────────────────────────────────────────────────
 
 /**
@@ -412,34 +390,3 @@ function mapCacheSupport(backend: Backend | null): CacheSupport {
       return "none";
   }
 }
-
-/**
- * Human-readable label for the source — used in toast wording so the
- * user sees *why* the resolved model is what it is. Keeps the wording
- * centralised so the UI stays consistent across frontends.
- */
-export function describeActiveModelSource(source: ActiveModelSource): string {
-  switch (source) {
-    case "override-valid":
-      return "your pick";
-    case "override-invalid-fallback":
-      return "previous pick invalid — falling back to default";
-    case "backend-canonical":
-      return "backend default";
-    case "config-backend-defaults":
-      return "configured default";
-    case "config-legacy-global":
-      return "global default";
-    case "none":
-      return "no model selected";
-  }
-}
-
-/** Read-only helper to surface the `modelByBackend` map for a chat
- *  (e.g. for /status rendering). Returns a shallow copy. */
-export function getModelByBackendSnapshot(
-  chatId: string,
-): Record<string, string> {
-  const settings = getChatSettings(chatId);
-  return { ...settings.modelByBackend };
-}

package/src/core/plugin/actions.ts

@@ -14,6 +14,22 @@
 import { logError } from "../../util/log.js";
 import type { ActionResult } from "../types.js";
 import { registry } from "./registry.js";
+import type { TalonPlugin } from "./types.js";
+
+/** Run a plugin that has `handleAction`; a throw becomes an error result. */
+async function runAction(
+  plugin: TalonPlugin,
+  body: Record<string, unknown>,
+  chatId: string,
+): Promise<ActionResult | null> {
+  try {
+    return await plugin.handleAction!(body, chatId);
+  } catch (err) {
+    const detail = err instanceof Error ? err.message : String(err);
+    logError("plugin", `${plugin.name} action error: ${detail}`);
+    return { ok: false, error: `Plugin ${plugin.name}: ${detail}` };
+  }
+}
 
 export async function handlePluginAction(
   body: Record<string, unknown>,
@@ -21,19 +37,8 @@ export async function handlePluginAction(
 ): Promise<ActionResult | null> {
   for (const { plugin } of registry.all) {
     if (!plugin.handleAction) continue;
-    try {
-      const result = await plugin.handleAction(body, chatId);
-      if (result) return result;
-    } catch (err) {
-      logError(
-        "plugin",
-        `${plugin.name} action error: ${err instanceof Error ? err.message : err}`,
-      );
-      return {
-        ok: false,
-        error: `Plugin ${plugin.name}: ${err instanceof Error ? err.message : err}`,
-      };
-    }
+    const result = await runAction(plugin, body, chatId);
+    if (result) return result;
   }
   return null;
 }
@@ -56,11 +61,5 @@ export async function handlePluginActionIn(
 ): Promise<ActionResult | null> {
   const entry = registry.all.find(({ plugin }) => plugin.name === name);
   if (!entry?.plugin.handleAction) return null;
-  try {
-    return await entry.plugin.handleAction(body, chatId);
-  } catch (err) {
-    const detail = err instanceof Error ? err.message : String(err);
-    logError("plugin", `${name} action error: ${detail}`);
-    return { ok: false, error: `Plugin ${name}: ${detail}` };
-  }
+  return runAction(entry.plugin, body, chatId);
 }

package/src/core/plugin/builtins.ts

@@ -4,7 +4,10 @@
  */
 
 import { log, logError, logWarn } from "../../util/log.js";
+import { raiseAlert, resolveAlert } from "../frontend-runtime/alerts.js";
+import { faultText } from "../engine/fault-text.js";
 import type { TalonConfig } from "../config/index.js";
+import type { TalonPlugin } from "./types.js";
 import { registry, reloadState } from "./registry.js";
 import type { ProvisionOutcome } from "./provision.js";
 import { NATIVE_RUNTIMES, type NativePluginId } from "./native-runtimes.js";
@@ -37,6 +40,7 @@ function reportProvision(
   if (outcome.status === "failed" && outcome.error) {
     logError(pluginName, `provision failed: ${outcome.error}`);
   }
+  alertOnProvision(pluginName, outcome.status, outcome.error);
   const background = outcome.background;
   if (background) {
     // Tracked so the post-update report waits for it to settle (its
@@ -56,6 +60,27 @@ function reportProvision(
   }
 }
 
+/**
+ * A native runtime that could not be provisioned leaves its plugin down
+ * until a human looks (disk, network, a broken toolchain) — alert on the
+ * failed pass, clear once a later pass leaves it usable.
+ */
+function alertOnProvision(
+  pluginName: NativePluginId,
+  status: ProvisionOutcome["status"] | "threw",
+  error: unknown,
+): void {
+  const key = `provision.${pluginName}`;
+  if (status === "failed" || status === "threw") {
+    raiseAlert(
+      key,
+      `Installing the ${pluginName} runtime failed: ${faultText(error ?? "no detail")}. The ${pluginName} plugin will not work until it is fixed (see \`talon doctor\`).`,
+    );
+  } else if (status === "ready" || status === "degraded") {
+    resolveAlert(key, `The ${pluginName} runtime is installed and usable.`);
+  }
+}
+
 /**
  * Provision every enabled native runtime (see native-runtimes.ts) and
  * return the outcomes so plugin construction can read what it got
@@ -77,136 +102,109 @@ async function provisionNativeRuntimes(
         runtime.id,
         `provision: ${err instanceof Error ? err.message : err}`,
       );
+      alertOnProvision(runtime.id, "threw", err);
     }
   }
   return outcomes;
 }
 
+/**
+ * Register one built-in plugin from its config section and run its init.
+ * A plugin that fails to build or init is logged, never fatal.
+ */
+async function loadBuiltin(
+  label: string,
+  section: object,
+  initTimeoutMs: number,
+  build: () => Promise<TalonPlugin>,
+): Promise<void> {
+  try {
+    const loaded = registerPlugin(
+      await build(),
+      section as Record<string, unknown>,
+    );
+    if (loaded) {
+      await initPluginWithTimeout(
+        loaded.plugin,
+        loaded.config,
+        initTimeoutMs,
+        `${label} init`,
+        `${label} init`,
+      );
+    }
+  } catch (err) {
+    logError(
+      "plugin",
+      `${label} init: ${err instanceof Error ? err.message : err}`,
+    );
+    raiseAlert(
+      `plugin.${label.toLowerCase()}`,
+      `Built-in plugin ${label} failed to load: ${faultText(err)}. Its tools are unavailable until the next reload or restart.`,
+    );
+  }
+}
+
 /**
  * Load built-in plugins (GitHub, MemPalace, mem0, Playwright) based on config flags.
- * Shared by both bootstrap and hot-reload to avoid duplication.
+ * Shared by both bootstrap and hot-reload.
  */
 export async function loadBuiltinPlugins(config: TalonConfig): Promise<void> {
   const provisioned = await provisionNativeRuntimes(config);
 
   const github = config.github;
   if (github?.enabled) {
-    try {
+    await loadBuiltin("GitHub", github, 15_000, async () => {
       const { createGitHubPlugin } =
         await import("../../plugins/github/index.js");
-      const gh = createGitHubPlugin({
+      return createGitHubPlugin({
         token: github.token,
         imageTag: github.imageTag,
       });
-      const ghConfig = github as unknown as Record<string, unknown>;
-      const loaded = registerPlugin(gh, ghConfig);
-      if (loaded) {
-        await initPluginWithTimeout(
-          loaded.plugin,
-          loaded.config,
-          15_000,
-          "GitHub init",
-          "GitHub init",
-        );
-      }
-    } catch (err) {
-      logError(
-        "plugin",
-        `GitHub init: ${err instanceof Error ? err.message : err}`,
-      );
-    }
+    });
   }
 
   const mempalace = config.mempalace;
   if (mempalace?.enabled) {
-    try {
+    await loadBuiltin("MemPalace", mempalace, 30_000, async () => {
       const { createMempalacePlugin } =
         await import("../../plugins/mempalace/index.js");
       const { resolveMempalacePaths } =
         await import("../../plugins/mempalace/provision.js");
       const { pythonPath, palacePath } = resolveMempalacePaths(mempalace);
-      const mp = createMempalacePlugin({
+      return createMempalacePlugin({
         pythonPath,
         palacePath,
         entityLanguages: mempalace.entityLanguages,
         verbose: mempalace.verbose,
         installedVersion: provisioned.get("mempalace")?.version,
       });
-      const mpConfig = mempalace as unknown as Record<string, unknown>;
-      const loaded = registerPlugin(mp, mpConfig);
-      if (loaded) {
-        await initPluginWithTimeout(
-          loaded.plugin,
-          loaded.config,
-          30_000,
-          "MemPalace init",
-          "MemPalace init",
-        );
-      }
-    } catch (err) {
-      logError(
-        "plugin",
-        `MemPalace init: ${err instanceof Error ? err.message : err}`,
-      );
-    }
+    });
   }
 
   const mem0 = config.mem0;
   if (mem0?.enabled) {
-    try {
+    await loadBuiltin("mem0", mem0, 15_000, async () => {
       const { createMem0Plugin } = await import("../../plugins/mem0/index.js");
-      const m0 = createMem0Plugin({
+      return createMem0Plugin({
         apiKey: mem0.apiKey,
         host: mem0.host,
         userId: mem0.userId,
       });
-      const m0Config = mem0 as unknown as Record<string, unknown>;
-      const loaded = registerPlugin(m0, m0Config);
-      if (loaded) {
-        await initPluginWithTimeout(
-          loaded.plugin,
-          loaded.config,
-          15_000,
-          "mem0 init",
-          "mem0 init",
-        );
-      }
-    } catch (err) {
-      logError(
-        "plugin",
-        `mem0 init: ${err instanceof Error ? err.message : err}`,
-      );
-    }
+    });
   }
 
   const playwright = config.playwright;
   if (playwright?.enabled) {
-    try {
+    await loadBuiltin("Playwright", playwright, 15_000, async () => {
       const { createPlaywrightPlugin } =
         await import("../../plugins/playwright/index.js");
-      const pwConfig = playwright as unknown as Record<string, unknown>;
-      const pw = createPlaywrightPlugin({
+      return createPlaywrightPlugin({
         browser: playwright.browser,
         headless: playwright.headless,
         endpoint: playwright.endpoint,
         endpointFile: playwright.endpointFile,
       });
-      const loaded = registerPlugin(pw, pwConfig);
-      if (loaded) {
-        await initPluginWithTimeout(
-          loaded.plugin,
-          loaded.config,
-          15_000,
-          "Playwright init",
-          "Playwright init",
-        );
-      }
-    } catch (err) {
-      logError(
-        "plugin",
-        `Playwright init: ${err instanceof Error ? err.message : err}`,
-      );
-    }
+    });
   }
 }
 
@@ -217,9 +215,9 @@ export async function loadBuiltinPlugins(config: TalonConfig): Promise<void> {
  *
  * Throws on config parse/validation failure so the gateway can report an error.
  *
- * Does NOT restart the main process, Claude session, or bot connection. Active
- * conversations continue uninterrupted — new MCP servers spawn automatically
- * on the next tool call.
+ * Does NOT restart the main process, backend session, or bot connection.
+ * Active conversations continue uninterrupted — new MCP servers spawn
+ * automatically on the next tool call.
  */
 export async function reloadPlugins(
   activeFrontends?: string[],
@@ -229,30 +227,22 @@ export async function reloadPlugins(
   const { loadConfig, getFrontends } = await import("../config/index.js");
   const config = loadConfig();
 
-  // Derive frontends from config if not explicitly provided
   const frontends = activeFrontends ?? getFrontends(config);
 
-  // Bump reload timestamp so every MCP subprocess env differs from the previous
-  // load — the Claude SDK will see a changed env and spawn fresh subprocesses,
-  // picking up any source-file changes without a full Talon restart.
+  // New cache-bust key: the re-import below must load edited plugin source.
   reloadState.lastReloadAt = new Date().toISOString();
 
-  // Config is valid — safe to destroy current plugins now
   log("plugin", "Hot-reload: destroying current plugins...");
   await registry.destroyAndClear();
 
-  // Re-load external plugins
   if (config.plugins.length > 0) {
     await loadPlugins(config.plugins, frontends);
   }
-
-  // Re-load built-in plugins using shared helper
   await loadBuiltinPlugins(config);
 
   // Retire the hub's MCP children: the next tool call (any chat) spawns
   // fresh processes from the reloaded registry, while in-flight calls
-  // drain on the old ones (stdio-era behaviour was per-turn respawn via
-  // the TALON_RELOAD_AT env bump; the hub owns lifecycles directly).
+  // drain on the old ones.
   const { reloadHubChildren } = await import("../mcp-hub/index.js");
   reloadHubChildren();
 

package/src/core/plugin/index.ts

@@ -7,10 +7,7 @@
  *   - `loader`   — load/validate/register plugins, init hooks, query helpers
  *   - `builtins` — built-in plugin loading + hot-reload
  *   - `actions`  — gateway-action routing through plugins
- *   - `mcp`      — MCP server config assembly for the Claude Agent SDK
- *
- * Re-exports the same public surface the old single-file module exposed,
- * including the `_deps` test seam.
+ *   - `mcp`      — MCP server spec assembly for the hub
  */
 
 export { _deps } from "./registry.js";

package/src/core/plugin/loader.ts

@@ -16,6 +16,8 @@ import type {
 import { isMcpPlugin } from "./types.js";
 import { registry, _deps } from "./registry.js";
 import { GATEWAY_TOKEN_ENV } from "../engine/gateway-auth.js";
+import { faultText } from "../engine/fault-text.js";
+import { raiseAlert, resolveAlert } from "../frontend-runtime/alerts.js";
 
 /**
  * Candidate entry point paths, checked in order. Exported for
@@ -48,7 +50,6 @@ export async function loadPlugins(
       );
       continue;
     }
-    // Standalone MCP servers are registered for getPluginMcpServers, not loaded as modules
     if (isMcpPlugin(entry)) {
       if (registry.registerMcpEntry(entry)) {
         log("plugin", `Registered standalone MCP server: ${entry.name}`);
@@ -108,6 +109,7 @@ export async function initPluginWithTimeout(
 
   let timer: ReturnType<typeof setTimeout> | undefined;
 
+  const alertKey = `plugin.${plugin.name}`;
   try {
     await Promise.race([
       Promise.resolve(plugin.init(config)),
@@ -120,11 +122,18 @@ export async function initPluginWithTimeout(
         timer.unref?.();
       }),
     ]);
+    resolveAlert(alertKey, `Plugin "${plugin.name}" initialised normally.`);
   } catch (err) {
     logError(
       "plugin",
       `${errorPrefix}: ${err instanceof Error ? err.message : err}`,
     );
+    // Init runs once per boot or reload: a plugin that failed it stays
+    // half-loaded until someone fixes it, so this needs no threshold.
+    raiseAlert(
+      alertKey,
+      `Plugin "${plugin.name}" failed to initialise: ${faultText(err)}. Its tools may not work until the next reload or restart.`,
+    );
   } finally {
     if (timer) clearTimeout(timer);
   }
@@ -136,7 +145,6 @@ async function loadSinglePlugin(
 ): Promise<void> {
   const pluginDir = resolve(entry.path);
 
-  // Resolve entry point
   const entryPoint = resolveEntryPoint(pluginDir);
   if (!entryPoint) {
     logError(
@@ -146,7 +154,6 @@ async function loadSinglePlugin(
     return;
   }
 
-  // Import and extract plugin module
   const mod = await _deps.importModule(entryPoint);
   const plugin = extractPlugin(mod);
   if (!plugin) {
@@ -157,7 +164,6 @@ async function loadSinglePlugin(
     return;
   }
 
-  // Check frontend whitelist — skip if plugin specifies frontends and none match
   if (plugin.frontends && plugin.frontends.length > 0 && activeFrontends) {
     const match = activeFrontends.some((fe) => plugin.frontends!.includes(fe));
     if (!match) {
@@ -173,7 +179,6 @@ async function loadSinglePlugin(
   const loaded = registerPluginInstance(plugin, config, pluginDir);
   if (!loaded) return;
 
-  // Run init hook
   await initPluginWithTimeout(
     loaded.plugin,
     loaded.config,
@@ -182,11 +187,14 @@ async function loadSinglePlugin(
     `Plugin "${loaded.plugin.name}" init failed`,
   );
 
-  const version = loaded.plugin.version ? ` v${loaded.plugin.version}` : "";
-  const desc = loaded.plugin.description
-    ? ` — ${loaded.plugin.description}`
-    : "";
-  log("plugin", `Loaded: ${loaded.plugin.name}${version}${desc}`);
+  log("plugin", `Loaded: ${describePlugin(loaded.plugin)}`);
+}
+
+/** `name v1.0 — description`, for load/register log lines. */
+function describePlugin(plugin: TalonPlugin): string {
+  const version = plugin.version ? ` v${plugin.version}` : "";
+  const desc = plugin.description ? ` — ${plugin.description}` : "";
+  return `${plugin.name}${version}${desc}`;
 }
 
 function resolveEntryPoint(pluginDir: string): string | null {
@@ -198,13 +206,11 @@ function resolveEntryPoint(pluginDir: string): string | null {
 }
 
 function extractPlugin(mod: Record<string, unknown>): TalonPlugin | null {
-  // Support: export default { ... } or module.exports = { ... }
+  // `export default { … }` or `module.exports = { … }`
   const candidate = mod.default ?? mod;
   if (!candidate || typeof candidate !== "object") return null;
   const plugin = candidate as Record<string, unknown>;
-  // Validate required field types
   if (typeof plugin.name !== "string" || !plugin.name) return null;
-  // Validate optional fields are the right types if present
   if (
     plugin.handleAction !== undefined &&
     typeof plugin.handleAction !== "function"
@@ -241,33 +247,27 @@ function extractPlugin(mod: Record<string, unknown>): TalonPlugin | null {
 
 // ── Public API ─────────────────────────────────────────────────────────────
 
-/** Get all loaded plugins. */
 export function getLoadedPlugins(): readonly LoadedPlugin[] {
   return registry.all;
 }
 
-/** Get a plugin by name. */
 export function getPlugin(name: string): LoadedPlugin | undefined {
   return registry.getByName(name);
 }
 
-/** Number of loaded plugins. */
 export function getPluginCount(): number {
   return registry.count;
 }
 
-/** Destroy all plugins (called during shutdown). */
+/** Shutdown path. */
 export async function destroyPlugins(): Promise<void> {
   await registry.destroyAll();
 }
 
 /**
- * Register a built-in plugin directly (bypasses filesystem loader).
- * Used for tightly-integrated plugins like mempalace that are configured via
- * dedicated config fields rather than the plugins[] array.
- *
- * NOTE: This only registers the plugin — it does NOT call `init()`. The caller
- * is responsible for calling `plugin.init()` separately after registration.
+ * Register a built-in plugin (configured by its own config section, not a
+ * `plugins[]` entry) without the filesystem loader. Does NOT call `init()`;
+ * the caller does.
  */
 export function registerPlugin(
   plugin: TalonPlugin,
@@ -275,19 +275,11 @@ export function registerPlugin(
 ): LoadedPlugin | null {
   const loaded = registerPluginInstance(plugin, config, "(built-in)");
   if (!loaded) return null;
-
-  const version = loaded.plugin.version ? ` v${loaded.plugin.version}` : "";
-  const desc = loaded.plugin.description
-    ? ` — ${loaded.plugin.description}`
-    : "";
-  log("plugin", `Registered built-in: ${loaded.plugin.name}${version}${desc}`);
+  log("plugin", `Registered built-in: ${describePlugin(loaded.plugin)}`);
   return loaded;
 }
 
-/**
- * Collect system prompt additions from all plugins.
- * Called during config/prompt assembly.
- */
+/** Every plugin's trimmed system-prompt addition, load order. */
 export function getPluginPromptAdditions(): string[] {
   const additions: string[] = [];
   for (const { plugin, config } of registry.all) {

package/src/core/plugin/mcp.ts

@@ -1,7 +1,7 @@
 /**
- * MCP server config — build the Claude Agent SDK MCP server map for plugins
- * that expose an MCP server (via `mcpServer` command/args or `mcpServerPath`),
- * plus the standalone MCP entries from config.
+ * MCP server specs — the stdio command for every plugin that exposes an MCP
+ * server (via `mcpServer` command/args or `mcpServerPath`), plus the
+ * standalone MCP entries from config. The hub spawns its children from these.
  */
 
 import { resolve } from "node:path";
@@ -54,7 +54,6 @@ export function getPluginMcpServers(
   );
 
   for (const { plugin, envVars } of registry.all) {
-    // Skip plugins not in the allow-list when filtering
     if (only !== undefined && !only.includes(plugin.name)) continue;
 
     // Let the plugin re-materialize on-disk state the child will read. Runs
@@ -95,7 +94,6 @@ export function getPluginMcpServers(
     }
   }
 
-  // Include standalone MCP server entries from config
   for (const entry of registry.mcpEntries) {
     if (only !== undefined && !only.includes(entry.name)) continue;
     servers[`${entry.name}-tools`] = wrapMcpServer({