talon-agent 1.51.0 → 1.52.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "talon-agent",
-  "version": "1.51.0",
+  "version": "1.52.0",
   "description": "Multi-frontend AI agent with full tool access, streaming, cron jobs, and plugin system",
   "author": "Dylan Neve",
   "license": "MIT",

package/src/backend/claude-sdk/one-shot.ts

@@ -14,7 +14,7 @@
 import { readdir, readFile } from "node:fs/promises";
 import { query } from "@anthropic-ai/claude-agent-sdk";
 import type { SDKMessage } from "@anthropic-ai/claude-agent-sdk";
-import type { OneShotAgentParams } from "../../core/types.js";
+import type { OneShotAgentParams, OneShotUsage } from "../../core/types.js";
 import { log } from "../../util/log.js";
 import { ALLOWED_TOOLS_BACKGROUND } from "../../core/constants.js";
 import { buildMcpServers, buildPluginMcpServers } from "./options.js";
@@ -53,7 +53,7 @@ export function initClaudeOneShot(cfg: OneShotConfig): void {
 
 export async function runOneShotAgent(
   params: OneShotAgentParams,
-): Promise<void> {
+): Promise<OneShotUsage | void> {
   const {
     prompt,
     systemPrompt,
@@ -86,9 +86,22 @@ export async function runOneShotAgent(
     options: options as Parameters<typeof query>[0]["options"],
   });
 
+  // The final `result` message carries the run's total token usage — the
+  // settlement figure the task table records.
+  let usage: OneShotUsage | undefined;
   for await (const msg of qi) {
     await formatAndAppendMessage(appendLog, msg);
+    if (msg.type === "result") {
+      const u = msg.usage;
+      usage = {
+        inputTokens: u.input_tokens ?? 0,
+        outputTokens: u.output_tokens ?? 0,
+        cacheRead: u.cache_read_input_tokens ?? 0,
+        cacheWrite: u.cache_creation_input_tokens ?? 0,
+      };
+    }
   }
+  return usage;
 }
 
 /**

package/src/backend/codex/one-shot.ts

@@ -17,7 +17,7 @@
  * fires — no orphan process handling needed.
  */
 
-import type { OneShotAgentParams } from "../../core/types.js";
+import type { OneShotAgentParams, OneShotUsage } from "../../core/types.js";
 import { log, logWarn } from "../../util/log.js";
 import { appendBackendSuffix } from "../shared/index.js";
 import { ensureCodex, getCodexAuthInfo } from "./init.js";
@@ -69,7 +69,7 @@ function resolveOneShotModel(requested: string): {
 
 export async function runOneShotAgent(
   params: OneShotAgentParams,
-): Promise<void> {
+): Promise<OneShotUsage | void> {
   const {
     prompt,
     systemPrompt,
@@ -118,10 +118,25 @@ export async function runOneShotAgent(
       signal: abortController.signal,
     });
 
+    // `turn.completed.usage` is cumulative across the run — the last one
+    // seen is the settlement figure the task table records.
+    let usage: OneShotUsage | undefined;
     for await (const event of events) {
       if (abortController.signal.aborted) break;
       await appendCodexEvent(appendLog, event);
+      if (event.type === "turn.completed") {
+        const u = (event as { usage?: Record<string, number> }).usage;
+        if (u) {
+          usage = {
+            inputTokens: u.input_tokens ?? 0,
+            outputTokens: u.output_tokens ?? 0,
+            cacheRead: u.cached_input_tokens ?? 0,
+            cacheWrite: 0, // Codex doesn't report cache writes
+          };
+        }
+      }
     }
+    return usage;
   } catch (err) {
     if (
       abortController.signal.aborted ||

package/src/backend/kilo/one-shot.ts

@@ -7,7 +7,7 @@
  * suffix; everything else is the shared lifecycle.
  */
 
-import type { OneShotAgentParams } from "../../core/types.js";
+import type { OneShotAgentParams, OneShotUsage } from "../../core/types.js";
 import { runRemoteOneShotAgent } from "../remote-server/one-shot.js";
 import {
   ensureServer,
@@ -21,7 +21,9 @@ import {
   errMsg,
 } from "./server.js";
 
-export function runOneShotAgent(params: OneShotAgentParams): Promise<void> {
+export function runOneShotAgent(
+  params: OneShotAgentParams,
+): Promise<OneShotUsage | void> {
   return runRemoteOneShotAgent(
     {
       label: "Kilo",

package/src/backend/opencode/one-shot.ts

@@ -7,7 +7,7 @@
  * suffix; everything else is the shared lifecycle.
  */
 
-import type { OneShotAgentParams } from "../../core/types.js";
+import type { OneShotAgentParams, OneShotUsage } from "../../core/types.js";
 import { runRemoteOneShotAgent } from "../remote-server/one-shot.js";
 import {
   ensureServer,
@@ -21,7 +21,9 @@ import {
   errMsg,
 } from "./server.js";
 
-export function runOneShotAgent(params: OneShotAgentParams): Promise<void> {
+export function runOneShotAgent(
+  params: OneShotAgentParams,
+): Promise<OneShotUsage | void> {
   return runRemoteOneShotAgent(
     {
       label: "OpenCode",

package/src/backend/remote-server/one-shot.ts

@@ -26,8 +26,12 @@
  * model stops spending tokens once the timeout fires.
  */
 
-import type { OneShotAgentParams } from "../../core/types.js";
+import type { OneShotAgentParams, OneShotUsage } from "../../core/types.js";
 import { logWarn } from "../../util/log.js";
+import {
+  extractAssistantUsage,
+  type RemoteAssistantInfo,
+} from "./session-helpers.js";
 import { appendBackendSuffix } from "../shared/index.js";
 
 // ── Client surface ──────────────────────────────────────────────────────────
@@ -86,7 +90,7 @@ export async function runRemoteOneShotAgent<
 >(
   bindings: RemoteOneShotBindings<TClient>,
   params: OneShotAgentParams,
-): Promise<void> {
+): Promise<OneShotUsage | void> {
   const {
     prompt,
     systemPrompt,
@@ -162,6 +166,21 @@ export async function runRemoteOneShotAgent<
     for (const part of parts) {
       await appendResponsePart(appendLog, part);
     }
+
+    // The prompt response's assistant info carries the run's token usage —
+    // the settlement figure the task table records.
+    const info = data?.info as RemoteAssistantInfo | undefined;
+    if (info) {
+      const u = extractAssistantUsage(info);
+      if (u.inputTokens > 0 || u.outputTokens > 0) {
+        return {
+          inputTokens: u.inputTokens,
+          outputTokens: u.outputTokens,
+          cacheRead: u.cacheRead,
+          cacheWrite: u.cacheWrite,
+        };
+      }
+    }
   } finally {
     abortController.signal.removeEventListener("abort", onAbort);
     await bindings.disconnectChatMcpServer(oc, chatMcpServerName);

package/src/cli/plugin.ts

@@ -38,7 +38,7 @@ import {
   npmSpecName,
   withEnabled,
   type PluginEntryJson,
-} from "./plugin-entries.js";
+} from "../core/plugin/entries.js";
 
 /** Plugin init can legitimately take ~30s (MemPalace) — outlive it. */
 const RELOAD_TIMEOUT_MS = 60_000;

package/src/core/agent-runtime/capabilities.ts

@@ -27,6 +27,7 @@ import type {
   ModelPickerOptions,
   ModelPickerResult,
   OneShotAgentParams,
+  OneShotUsage,
   UnifiedModelInfo,
   UnifiedModelResolution,
   UnifiedProviderInfo,
@@ -131,12 +132,14 @@ export interface ChatBackend {
  *   - `runOneShotAgent(params)` — accepts `OneShotAgentParams`
  *     (with its `appendLog` callback) so the heartbeat / dream /
  *     trigger log-file producers keep their direct write path.
+ *     Resolves with the run's token usage when the SDK reports it
+ *     (the task table records it at settlement); void otherwise.
  *   - `evictOrphanSubprocesses(label)` — backends that spawn
  *     per-run subprocesses (Claude SDK) implement this so a hung
  *     run can be force-cleaned after the abort grace window.
  */
 export interface BackgroundRunner {
-  runOneShotAgent(params: OneShotAgentParams): Promise<void>;
+  runOneShotAgent(params: OneShotAgentParams): Promise<OneShotUsage | void>;
   evictOrphanSubprocesses?(contextLabel: string): Promise<{
     found: number;
     termed: number;

package/src/core/background/dream.ts

@@ -296,15 +296,17 @@ If commands fail, log the error and continue — this stage is optional.`
   });
 
   const agentPromise = (async () => {
-    await background.runOneShotAgent(oneShotParams);
+    const usage = await background.runOneShotAgent(oneShotParams);
     appendDreamLog(
       dreamLogFile,
       `\n---\n**Dream completed at ${new Date().toISOString()}**\n`,
     );
+    return usage;
   })();
 
+  let usage: Awaited<typeof agentPromise>;
   try {
-    await Promise.race([agentPromise, timeoutPromise]);
+    usage = await Promise.race([agentPromise, timeoutPromise]);
   } catch (err) {
     task.fail(err);
     appendDreamLog(
@@ -332,7 +334,7 @@ If commands fail, log the error and continue — this stage is optional.`
     if (timeoutHandle) clearTimeout(timeoutHandle);
   }
 
-  task.succeed();
+  task.succeed(usage ?? undefined);
   return dreamLogFile;
 }
 

package/src/core/background/heartbeat/agent.ts

@@ -220,15 +220,17 @@ export async function runHeartbeatAgent(
   });
 
   const agentPromise = (async () => {
-    await background.runOneShotAgent(oneShotParams);
+    const usage = await background.runOneShotAgent(oneShotParams);
     await appendHeartbeatLog(
       heartbeatLogFile,
       `\n---\n**Heartbeat #${runCount} completed at ${new Date().toISOString()}**\n`,
     );
+    return usage;
   })();
 
+  let usage: Awaited<typeof agentPromise>;
   try {
-    await Promise.race([agentPromise, timeoutPromise]);
+    usage = await Promise.race([agentPromise, timeoutPromise]);
   } catch (err) {
     // Snapshot timeout state and clear the timer immediately, BEFORE any awaits
     // in the error-handling path. Otherwise the timer can fire during the async
@@ -278,7 +280,7 @@ export async function runHeartbeatAgent(
     if (timeoutHandle) clearTimeout(timeoutHandle);
   }
 
-  task.succeed();
+  task.succeed(usage ?? undefined);
   return heartbeatLogFile;
 }
 

package/src/core/background/isolated-agent.ts

@@ -15,7 +15,7 @@
  */
 
 import type { BackgroundRunner } from "../agent-runtime/capabilities.js";
-import type { OneShotAgentParams } from "../types.js";
+import type { OneShotAgentParams, OneShotUsage } from "../types.js";
 import { logWarn, logError } from "../../util/log.js";
 
 /** Default bounded grace after an abort before giving up on the backend. */
@@ -55,11 +55,12 @@ async function raceWithTimeout<T>(
 
 /**
  * Run the one-shot under a hard timeout. Throws on timeout (after the grace
- * window) and re-throws any agent error.
+ * window) and re-throws any agent error. Resolves with the run's token
+ * usage when the backend reports it.
  */
 export async function runIsolatedAgent(
   opts: IsolatedRunOptions,
-): Promise<void> {
+): Promise<OneShotUsage | void> {
   const { background, params, timeoutMs } = opts;
   const graceMs = opts.abortGraceMs ?? DEFAULT_ABORT_GRACE_MS;
 
@@ -81,7 +82,7 @@ export async function runIsolatedAgent(
   });
 
   try {
-    await Promise.race([agentPromise, timeoutPromise]);
+    return await Promise.race([agentPromise, timeoutPromise]);
   } catch (err) {
     // Snapshot + clear before any await so a late timer can't reclassify a
     // non-timeout failure as a timeout (heartbeat learned this the hard way).

package/src/core/background/job-oneshot.ts

@@ -157,7 +157,7 @@ export async function runJobOneShot(
     };
 
     try {
-      await runIsolatedAgent({
+      const usage = await runIsolatedAgent({
         background,
         params: oneShot,
         timeoutMs: params.timeoutMs ?? DEFAULT_JOB_TIMEOUT_MS,
@@ -165,7 +165,7 @@ export async function runJobOneShot(
         // sweep here could kill a concurrent heartbeat's subprocess. Bounded
         // abort-grace is enough.
       });
-      task.succeed();
+      task.succeed(usage ?? undefined);
     } catch (err) {
       task.fail(err);
       throw err;

package/src/core/plugin/entries.ts

@@ -0,0 +1,105 @@
+/**
+ * Pure helpers over the config `plugins` array, shared by every surface
+ * that lists or toggles plugins (the `talon plugin` command group, the
+ * client bridge's plugin endpoints). Entries here are the on-disk shape
+ * (`core/plugin/types.ts` PluginEntry), not loaded plugins. No filesystem
+ * or process access — everything is testable data-in/data-out.
+ */
+
+/** On-disk plugin entry — path-based module or standalone MCP server. */
+export type PluginEntryJson = {
+  path?: string;
+  config?: Record<string, unknown>;
+  name?: string;
+  command?: string;
+  args?: string[];
+  env?: Record<string, string>;
+  enabled?: boolean;
+};
+
+/**
+ * Built-in plugins toggled by their own config sections (`github.enabled`,
+ * …) rather than `plugins[]` entries — see core/plugin/builtins.ts.
+ */
+export const BUILTIN_PLUGINS = [
+  "github",
+  "mempalace",
+  "mem0",
+  "playwright",
+] as const;
+
+export function isBuiltinPlugin(name: string): boolean {
+  return (BUILTIN_PLUGINS as readonly string[]).includes(name);
+}
+
+/** Split a config path on either separator — Windows configs carry `\`. */
+function pathSegments(path: string): string[] {
+  return path.split(/[\\/]+/).filter(Boolean);
+}
+
+/**
+ * Display name for an entry: the MCP name, or for path entries the package
+ * name — segments after the last `node_modules` (preserving `@scope/pkg`),
+ * else the folder basename.
+ */
+export function entryDisplayName(entry: PluginEntryJson): string {
+  if (entry.name) return entry.name;
+  if (!entry.path) return "(invalid entry)";
+  const segments = pathSegments(entry.path);
+  const nm = segments.lastIndexOf("node_modules");
+  if (nm >= 0 && nm < segments.length - 1) {
+    return segments.slice(nm + 1).join("/");
+  }
+  return segments[segments.length - 1] ?? entry.path;
+}
+
+/** Does `token` identify this entry? Display name, basename, or full path. */
+export function entryMatches(entry: PluginEntryJson, token: string): boolean {
+  if (entryDisplayName(entry) === token) return true;
+  if (!entry.path) return false;
+  const segments = pathSegments(entry.path);
+  return entry.path === token || segments[segments.length - 1] === token;
+}
+
+export function findEntryIndex(
+  entries: readonly PluginEntryJson[],
+  token: string,
+): number {
+  return entries.findIndex((entry) => entryMatches(entry, token));
+}
+
+/**
+ * Index of an entry with the same identity as `candidate` (same module
+ * path or same MCP name) — the duplicate an install must replace.
+ */
+export function findConflictIndex(
+  entries: PluginEntryJson[],
+  candidate: PluginEntryJson,
+): number {
+  return entries.findIndex((entry) =>
+    candidate.path !== undefined
+      ? entry.path === candidate.path
+      : entry.name !== undefined && entry.name === candidate.name,
+  );
+}
+
+/**
+ * Copy of `entry` with the enabled state applied. Enabled is the default,
+ * so enabling removes the key rather than writing `enabled: true`.
+ */
+export function withEnabled(
+  entry: PluginEntryJson,
+  enabled: boolean,
+): PluginEntryJson {
+  const { enabled: _drop, ...rest } = entry;
+  return enabled ? rest : { ...rest, enabled: false };
+}
+
+/**
+ * Package name of an npm spec, version stripped: `pkg@1.2` → `pkg`,
+ * `@scope/pkg@^1` → `@scope/pkg`. A leading `@` is the scope, not a version.
+ */
+export function npmSpecName(spec: string): string {
+  const at = spec.lastIndexOf("@");
+  return at > 0 ? spec.slice(0, at) : spec;
+}

package/src/core/plugin/manage.ts

@@ -0,0 +1,99 @@
+/**
+ * Plugin management over the live config — list and toggle, outcomes as
+ * data. The client bridge's plugin endpoints run through here in-process;
+ * the CLI edits config.json out-of-process with the same `entries.ts`
+ * helpers and converges through `POST /plugins/reload`. Rendering (and
+ * persisting/hot-applying, which are surface concerns) stay with the
+ * caller: a toggle returns the exact partial document to merge into
+ * talon.json so the surface owns its own write path.
+ */
+
+import type { TalonConfig } from "../../util/config.js";
+import { isPathPlugin, type PluginEntry } from "./types.js";
+import {
+  BUILTIN_PLUGINS,
+  entryDisplayName,
+  findEntryIndex,
+  isBuiltinPlugin,
+  withEnabled,
+} from "./entries.js";
+
+/** One plugin as every management surface lists it. */
+export type PluginItem = {
+  readonly name: string;
+  readonly kind: "builtin" | "module" | "mcp";
+  readonly enabled: boolean;
+  /** Where it comes from: a config section, module path, or MCP command. */
+  readonly source: string;
+};
+
+export type PluginToggleOutcome =
+  | {
+      readonly ok: true;
+      readonly name: string;
+      /** Partial talon.json document the surface must persist. */
+      readonly persist: Record<string, unknown>;
+    }
+  | { readonly ok: false; readonly error: string };
+
+function builtinSection(
+  config: TalonConfig,
+  name: string,
+): { enabled?: boolean } | undefined {
+  return (config as unknown as Record<string, { enabled?: boolean }>)[name];
+}
+
+/** Every plugin: built-ins first, then configured entries, config order. */
+export function listPluginItems(config: TalonConfig): PluginItem[] {
+  const builtins: PluginItem[] = BUILTIN_PLUGINS.map((name) => ({
+    name,
+    kind: "builtin" as const,
+    enabled: builtinSection(config, name)?.enabled === true,
+    source: `config.${name}`,
+  }));
+  const configured: PluginItem[] = (config.plugins ?? []).map((entry) => ({
+    name: entryDisplayName(entry),
+    kind: isPathPlugin(entry) ? ("module" as const) : ("mcp" as const),
+    enabled: entry.enabled !== false,
+    source: isPathPlugin(entry)
+      ? entry.path
+      : `${entry.command}${entry.args ? ` ${entry.args.join(" ")}` : ""}`,
+  }));
+  return [...builtins, ...configured];
+}
+
+/**
+ * Toggle a plugin on the LIVE config object (so in-process readers see the
+ * change immediately) and report what to persist. Hot-applying (plugin
+ * reload, prompt rebuild) is the caller's follow-up — this function only
+ * decides and mutates state.
+ */
+export function setPluginEnabled(
+  config: TalonConfig,
+  rawName: string,
+  enabled: boolean,
+): PluginToggleOutcome {
+  const name = rawName.trim();
+  if (!name) return { ok: false, error: "A plugin name is required." };
+
+  if (isBuiltinPlugin(name)) {
+    const section = { ...(builtinSection(config, name) ?? {}), enabled };
+    (config as unknown as Record<string, unknown>)[name] = section;
+    return { ok: true, name, persist: { [name]: section } };
+  }
+
+  const list: PluginEntry[] = config.plugins ?? [];
+  const index = findEntryIndex(list, name);
+  if (index < 0) {
+    return { ok: false, error: `No plugin named "${name}".` };
+  }
+  // withEnabled only adds/drops the `enabled` key, so the entry keeps its
+  // (validated) format — safe to narrow back from the JSON helper shape.
+  list[index] = withEnabled(list[index]!, enabled) as PluginEntry;
+  config.plugins = list;
+  return {
+    ok: true,
+    name: entryDisplayName(list[index]!),
+    persist: { plugins: list },
+  };
+}

package/src/core/types.ts

@@ -120,6 +120,18 @@ export interface ModelPickerResult {
  * fire-and-forget agent invocation: spawn an agent with a prompt, let it run
  * tools, log everything to a file, return when it finishes (or when aborted).
  */
+/**
+ * Token usage a one-shot run reports at settlement, when the backend's SDK
+ * surfaces it. Shape-compatible with the task table's `TaskUsage`, so the
+ * background callers can hand it straight to `TaskHandle.succeed`.
+ */
+export type OneShotUsage = {
+  inputTokens: number;
+  outputTokens: number;
+  cacheRead: number;
+  cacheWrite: number;
+};
+
 export type OneShotAgentParams = {
   /** The user prompt the agent should execute. */
   prompt: string;

package/src/frontend/native/extensions.ts

@@ -0,0 +1,93 @@
+/**
+ * Extensions over the bridge — plugins and skills, list + toggle.
+ *
+ * This is what backs the companion app's Plugins and Skills settings
+ * sub-menus. Listing is a pure read (core/plugin/manage.ts for plugins,
+ * the skill store for skills); a toggle mutates the live state, persists
+ * it, and hot-applies so the change is real on the very next turn:
+ *
+ *   - plugin toggle → merge into talon.json + full plugin reload (same
+ *     path as `POST /plugins/reload`), so tools appear/disappear live;
+ *   - skill toggle → `.disabled` marker via the skill store + system
+ *     prompt rebuild (skills render into the prompt; no plugin reload
+ *     needed).
+ *
+ * Toggles hide capability from the model's default view — they never
+ * restrict it. That contract lives in the stores; nothing here adds
+ * gating on top.
+ */
+
+import type { Backend } from "../../core/agent-runtime/capabilities.js";
+import { performPluginReload } from "../../core/engine/gateway-actions/plugins.js";
+import { getPluginPromptAdditions } from "../../core/plugin/index.js";
+import { listPluginItems, setPluginEnabled } from "../../core/plugin/manage.js";
+import { clearSystemPromptSnapshots } from "../../backend/shared/system-prompt.js";
+import { listSkills, setSkillEnabled } from "../../storage/skill-store.js";
+import { rebuildSystemPrompt, type TalonConfig } from "../../util/config.js";
+import { log } from "../../util/log.js";
+import type { PluginItem, SkillItem, ToggleResult } from "./protocol.js";
+import { persistConfigPatch } from "./settings.js";
+
+export function pluginItems(config: TalonConfig): PluginItem[] {
+  return listPluginItems(config);
+}
+
+export function skillItems(): SkillItem[] {
+  return listSkills().map(({ name, description, enabled }) => ({
+    name,
+    description,
+    enabled,
+  }));
+}
+
+/**
+ * Toggle a plugin: mutate the live config, persist the change, then
+ * hot-reload plugins (rebuilds the system prompt and drops per-session
+ * prompt snapshots on the way). A reload failure after a successful save
+ * is reported as an error — the state is on disk, but the caller must
+ * know the daemon hasn't applied it.
+ */
+export async function togglePlugin(
+  config: TalonConfig,
+  backend: Backend | null,
+  name: string,
+  enabled: boolean,
+): Promise<ToggleResult> {
+  const outcome = setPluginEnabled(config, name, enabled);
+  if (!outcome.ok) return { ok: false, error: outcome.error };
+  persistConfigPatch(outcome.persist);
+  log(
+    "native",
+    `Plugin ${outcome.name} ${enabled ? "enabled" : "disabled"} via bridge`,
+  );
+  try {
+    await performPluginReload(backend);
+  } catch (err) {
+    return {
+      ok: false,
+      error: `Saved, but the hot reload failed: ${err instanceof Error ? err.message : String(err)} — restart Talon to apply.`,
+    };
+  }
+  return { ok: true };
+}
+
+/**
+ * Toggle a skill: the store drops/creates the `.disabled` marker, then the
+ * system prompt is rebuilt so the skill index reflects the change on every
+ * chat's next turn. No plugin reload — skills don't carry tools.
+ */
+export function toggleSkill(
+  config: TalonConfig,
+  backend: Backend | null,
+  name: string,
+  enabled: boolean,
+): ToggleResult {
+  if (!setSkillEnabled(name, enabled)) {
+    return { ok: false, error: `No skill named "${name}".` };
+  }
+  log("native", `Skill ${name} ${enabled ? "enabled" : "disabled"} via bridge`);
+  rebuildSystemPrompt(config, getPluginPromptAdditions());
+  backend?.control?.updateSystemPrompt?.(config.systemPrompt);
+  clearSystemPromptSnapshots();
+  return { ok: true };
+}

package/src/frontend/native/index.ts

@@ -52,6 +52,12 @@ import {
 import { resetSession } from "../../storage/sessions.js";
 import { resetPulseCheckpoint } from "../../core/background/pulse.js";
 import { configSnapshot, applyConfigUpdate } from "./settings.js";
+import {
+  pluginItems,
+  skillItems,
+  togglePlugin,
+  toggleSkill,
+} from "./extensions.js";
 import { resolveModel } from "../../core/models/catalog.js";
 import {
   getBackendForChat,
@@ -743,7 +749,7 @@ export function createNativeFrontend(
     return {
       app: "talon-bridge",
       protocol: BRIDGE_PROTOCOL_VERSION,
-      capabilities: ["mesh", "mesh-commands"],
+      capabilities: ["mesh", "mesh-commands", "plugins-skills"],
       botName,
       backend: config.backend,
       model: resolveModel(config.model)?.displayName ?? config.model,
@@ -1168,6 +1174,12 @@ export function createNativeFrontend(
       broadcast({ kind: "status", status: status() });
       return snap;
     },
+    listPlugins: () => pluginItems(config),
+    setPluginEnabled: (name, enabled) =>
+      togglePlugin(config, getPooledBackend(config.backend), name, enabled),
+    listSkills: () => skillItems(),
+    setSkillEnabled: (name, enabled) =>
+      toggleSkill(config, getPooledBackend(config.backend), name, enabled),
     control,
     logs: ({ lines, minLevel, component }) =>
       readLogEntries(files.log, { limit: lines, minLevel, component }),

package/src/frontend/native/protocol.ts

@@ -197,6 +197,39 @@ export type BackendOption = {
   label: string;
 };
 
+/**
+ * One installed plugin, as `GET /plugins` lists it. Toggled via
+ * `POST /plugins/toggle` (`{ name, enabled }` → `ToggleResult`). Additive
+ * in v1 behind the `plugins-skills` capability — older clients never call
+ * these endpoints.
+ */
+export type PluginItem = {
+  name: string;
+  /** Built-in (config-section) plugin, module plugin, or MCP server. */
+  kind: "builtin" | "module" | "mcp";
+  enabled: boolean;
+  /** Where it comes from: a config section, module path, or MCP command. */
+  source: string;
+};
+
+/**
+ * One installed skill, as `GET /skills` lists it. Toggled via
+ * `POST /skills/toggle` — a disabled skill drops out of the model's
+ * prompt index but stays installed.
+ */
+export type SkillItem = {
+  name: string;
+  description: string;
+  enabled: boolean;
+};
+
+/**
+ * Application-level outcome of a toggle, always carried in an HTTP 200
+ * body (mirrors `/backend`: the client renders ok/error, HTTP-level
+ * failures stay transport errors).
+ */
+export type ToggleResult = { ok: boolean; error?: string };
+
 // Mesh device shapes are canonical in core (the mesh is daemon-wide state,
 // readable from every frontend); re-exported here so bridge clients keep
 // depending on the protocol module alone.

package/src/frontend/native/server.ts

@@ -40,7 +40,10 @@ import {
   type LogEntry,
   type LogLevel,
   type ModelOption,
+  type PluginItem,
   type SearchResult,
+  type SkillItem,
+  type ToggleResult,
 } from "./protocol.js";
 import type { ConfigSnapshot } from "./settings.js";
 
@@ -100,6 +103,14 @@ export type BridgeServerHandlers = {
   getConfig(): ConfigSnapshot;
   /** Change daemon settings; returns the fresh snapshot. */
   setConfig(update: Record<string, unknown>): ConfigSnapshot;
+  /** Installed plugins (built-ins + configured entries) with state. */
+  listPlugins(): PluginItem[];
+  /** Enable/disable a plugin; persists + hot-reloads. */
+  setPluginEnabled(name: string, enabled: boolean): Promise<ToggleResult>;
+  /** Installed skills with state. */
+  listSkills(): SkillItem[];
+  /** Enable/disable a skill; rebuilds the prompt index. */
+  setSkillEnabled(name: string, enabled: boolean): ToggleResult;
   /** Fire a daemon-level control action (e.g. "restart", "dream"). */
   control(action: string): Promise<{ ok: boolean; message: string }>;
   /** Newest daemon log entries (for the client's log viewer). */
@@ -552,6 +563,32 @@ export class BridgeServer {
         });
       }
 
+      if (method === "GET" && path === "/plugins")
+        return this.json(res, 200, { plugins: this.handlers.listPlugins() });
+
+      if (method === "POST" && path === "/plugins/toggle") {
+        const body = await this.readJson(req);
+        // Always 200: ok/error is an application result the client renders,
+        // not an HTTP-level failure (mirrors /backend).
+        const result = await this.handlers.setPluginEnabled(
+          asString(body.name) ?? "",
+          body.enabled === true,
+        );
+        return this.json(res, 200, result);
+      }
+
+      if (method === "GET" && path === "/skills")
+        return this.json(res, 200, { skills: this.handlers.listSkills() });
+
+      if (method === "POST" && path === "/skills/toggle") {
+        const body = await this.readJson(req);
+        const result = this.handlers.setSkillEnabled(
+          asString(body.name) ?? "",
+          body.enabled === true,
+        );
+        return this.json(res, 200, result);
+      }
+
       if (method === "GET" && path === "/config")
         return this.json(res, 200, this.handlers.getConfig());
 

package/src/frontend/native/settings.ts

@@ -175,15 +175,19 @@ export function applyConfigUpdate(
   }
 
   if (Object.keys(persist).length > 0) {
-    persistToFile(persist);
+    persistConfigPatch(persist);
     log("native", `Config updated: ${Object.keys(persist).join(", ")}`);
   }
 
   return configSnapshot(config);
 }
 
-/** Merge a partial update into talon.json on disk, preserving everything else. */
-function persistToFile(update: Record<string, unknown>): void {
+/**
+ * Merge a partial update into talon.json on disk, preserving everything
+ * else. Shared by every bridge surface that persists config changes
+ * (settings sync here, plugin toggles in extensions.ts).
+ */
+export function persistConfigPatch(update: Record<string, unknown>): void {
   const file = pathFiles.config;
   let current: Record<string, unknown> = {};
   try {