talon-agent 5.0.0 → 5.0.1

package/package.json

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

package/src/app.ts

@@ -7,7 +7,7 @@
  */
 
 import { getFrontends } from "./core/config/index.js";
-import { startUploadCleanup, stopUploadCleanup } from "./util/workspace.js";
+import { startUploadCleanup, stopUploadCleanup } from "./core/vfs/workspace.js";
 import { flushDatabase } from "./storage/db.js";
 import { getActiveCount, stopAllTurns } from "./core/engine/dispatcher.js";
 import {
@@ -28,9 +28,9 @@ import {
 import { shutdownTriggers } from "./core/background/triggers/index.js";
 import { pruneSettledTriggers } from "./storage/triggers.js";
 import { startWatchdog, stopWatchdog } from "./util/watchdog.js";
-import { spawnSuccessor } from "./util/respawn.js";
+import { spawnSuccessor } from "./core/daemon/respawn.js";
 import { log, logError, logWarn } from "./util/log.js";
-import { bootPhase, bootReport } from "./util/boot-timer.js";
+import { bootPhase, bootReport } from "./core/daemon/boot-timer.js";
 import {
   getVfs,
   mountNamespaceFs,

package/src/backend/claude-sdk/factory.ts

@@ -24,23 +24,12 @@ import {
   type ToolRuntime,
   type UsageTelemetry,
 } from "../../core/agent-runtime/capabilities.js";
-import { getPlanUsage } from "./plan-usage.js";
 
 import {
-  initAgent as initClaudeAgent,
   updateSystemPrompt as claudeUpdateSystemPrompt,
-  warmSession as claudeWarmSession,
-  getActiveQuery,
-  buildMcpServers,
-  buildPluginMcpServers,
-  runOneShotAgent as claudeRunOneShotAgent,
   evictOrphanSubprocesses as claudeEvictOrphanSubprocesses,
 } from "./index.js";
-import {
-  runChatTurn as claudeRunChatTurn,
-  interruptChatTurn as claudeInterruptChatTurn,
-} from "./handler.js";
-import { waitForMcpServersReady } from "./mcp-ready.js";
+import { createInProcessAgentHost } from "./host/in-process.js";
 
 import * as modelProvider from "./model-provider.js";
 import { claudeDoctorChecks } from "./doctor.js";
@@ -54,16 +43,25 @@ const claudeSdkFactory: BackendFactory = {
   doctor: (config, isActive) => claudeDoctorChecks(config, isActive),
 
   async init(config, ctx) {
-    await initClaudeAgent(config, ctx.getBridgePort);
+    // Everything SDK-side goes through the agent-host seam
+    // (docs/agent-host-sidecar.md). Phase 1 binds the in-process client,
+    // which calls the same functions this factory used to call inline;
+    // Phase 2 swaps in a process-backed client behind the same interface.
+    const host = createInProcessAgentHost(config, ctx.getBridgePort);
+    await host.hello();
     log("bot", "Backend: Claude SDK (@anthropic-ai/claude-agent-sdk)");
 
     const chat: ChatBackend = {
-      runChatTurn: (params) => claudeRunChatTurn(params),
-      interruptChatTurn: (chatId) => claudeInterruptChatTurn(chatId),
+      runChatTurn: (params) => host.runTurn(params),
+      interruptChatTurn: (chatId) => host.interrupt(chatId),
     };
 
     const background: BackgroundRunner = {
-      runOneShotAgent: (p) => claudeRunOneShotAgent(p),
+      runOneShotAgent: (p) => host.runOneShot(p),
+      // Not a protocol-table row yet: subprocess eviction reaches into
+      // the SDK's own children, so it belongs to the host — but the
+      // design's message table has no request for it. Tracked as an open
+      // question against Phase 2; bound directly until it gains one.
       evictOrphanSubprocesses: (label) => claudeEvictOrphanSubprocesses(label),
     };
 
@@ -81,7 +79,10 @@ const claudeSdkFactory: BackendFactory = {
       getProviderModels: (p, pg, ps) =>
         modelProvider.getProviderModels(p, pg, ps),
       formatModelError: (q, r) => modelProvider.formatModelError(q, r),
-      listModels: (f) => modelProvider.listModels(f),
+      // The one catalog member that asks the host: `list_models` is the
+      // protocol's model row. The seven above are daemon-side formatting
+      // over `core/models/catalog.ts`, which `hello` populates.
+      listModels: (f) => host.listModels(f),
     };
 
     // Claude SDK's per-turn subprocess model has no shared session
@@ -89,32 +90,11 @@ const claudeSdkFactory: BackendFactory = {
     // dispatcher's `/reset` clears Talon's stored session id via
     // `storage/sessions.ts:resetSession` regardless.
     const sessions: SessionBackend = {
-      warmSession: (chatId) => claudeWarmSession(chatId),
+      warmSession: (chatId) => host.warmSession(chatId),
     };
 
     const tools: ToolRuntime = {
-      refreshTools: async (chatId) => {
-        const qi = getActiveQuery(chatId);
-        if (!qi) return null;
-        // Two-phase teardown: remove all MCP servers first so each
-        // subprocess receives an OS-agnostic shutdown via stdio, then
-        // install the fresh set.
-        await qi.setMcpServers({});
-        const freshServers = {
-          ...buildMcpServers(chatId),
-          ...buildPluginMcpServers(chatId),
-        };
-        const result = await qi.setMcpServers(freshServers);
-        // setMcpServers resolves on REGISTER, not CONNECT — MCP startup is
-        // non-blocking. A stdio server that dials a slow remote (e.g. the
-        // playwright plugin connecting to the Camoufox websocket) is still
-        // 'pending' at this point and its tools are absent from the live
-        // registry, so the turn would proceed with mcp__playwright-tools__*
-        // stuck "connecting" until the next refresh. Wait (bounded) for the
-        // newly-added servers to finish connecting before returning.
-        await waitForMcpServersReady(qi, result.added);
-        return result;
-      },
+      refreshTools: (chatId) => host.refreshTools(chatId),
     };
 
     const control: SystemControl = {
@@ -124,7 +104,7 @@ const claudeSdkFactory: BackendFactory = {
     // No per-session snapshot to offer (each turn is a fresh subprocess),
     // but the subscription's rate-limit windows are readable.
     const usage: UsageTelemetry = {
-      getPlanUsage: () => getPlanUsage(),
+      getPlanUsage: () => host.planUsage(),
     };
 
     const backend = composeBackend({

package/src/backend/claude-sdk/host/in-process.ts

@@ -0,0 +1,147 @@
+/**
+ * The in-process agent host — `AgentHostClient` implemented as direct
+ * calls into `backend/claude-sdk/`.
+ *
+ * `docs/agent-host-sidecar.md` Phase 1. This is the implementation that
+ * keeps today's behaviour exactly: every method is a call-through to the
+ * function the claude-sdk `BackendFactory` used to call itself. There is
+ * no process, no framing and no logic of its own — the only code that
+ * moved here is `refreshTools`' two-phase MCP teardown, which had to,
+ * because it drives a `Query` handle and handles do not cross a process
+ * boundary.
+ *
+ * Phase 2 adds a sibling that speaks the same interface over a child
+ * process's stdio. Nothing above this file changes when it does.
+ */
+
+import type {
+  AgentHostClient,
+  HostReadyInfo,
+  HostSessionInfo,
+  HostToolRefresh,
+} from "../../../core/agent-runtime/agent-host.js";
+import { AGENT_HOST_PROTOCOL_VERSION } from "../../../core/agent-runtime/agent-host.js";
+import type { TalonConfig } from "../../../core/config/index.js";
+import { getSession } from "../../../storage/sessions.js";
+import { talonVersion } from "../../../util/version.js";
+
+import {
+  initAgent as claudeInitAgent,
+  warmSession as claudeWarmSession,
+  getActiveQuery,
+  buildMcpServers,
+  buildPluginMcpServers,
+  runOneShotAgent as claudeRunOneShotAgent,
+} from "../index.js";
+import {
+  runChatTurn as claudeRunChatTurn,
+  interruptChatTurn as claudeInterruptChatTurn,
+} from "../handler.js";
+import { waitForMcpServersReady } from "../mcp-ready.js";
+import { listModels as claudeListModels } from "../model-provider.js";
+import { getPlanUsage } from "../plan-usage.js";
+
+/**
+ * Install an MCP server set on the chat's live query. `null` when the
+ * chat has no query in flight — the same "nothing to refresh" answer
+ * `ToolRuntime.refreshTools` has always given.
+ */
+async function setMcpServers(
+  chatId: string,
+  servers: Record<string, unknown>,
+): Promise<HostToolRefresh | null> {
+  const qi = getActiveQuery(chatId);
+  if (!qi) return null;
+  return qi.setMcpServers(servers as Parameters<typeof qi.setMcpServers>[0]);
+}
+
+/**
+ * Re-derive the chat's MCP config from the live plugin registry. Body
+ * lifted verbatim from the claude-sdk factory's `tools.refreshTools`,
+ * comments included — the ordering is load-bearing.
+ */
+async function refreshTools(chatId: string): Promise<HostToolRefresh | null> {
+  const qi = getActiveQuery(chatId);
+  if (!qi) return null;
+  // Two-phase teardown: remove all MCP servers first so each
+  // subprocess receives an OS-agnostic shutdown via stdio, then
+  // install the fresh set.
+  await qi.setMcpServers({});
+  const freshServers = {
+    ...buildMcpServers(chatId),
+    ...buildPluginMcpServers(chatId),
+  };
+  const result = await qi.setMcpServers(freshServers);
+  // setMcpServers resolves on REGISTER, not CONNECT — MCP startup is
+  // non-blocking. A stdio server that dials a slow remote (e.g. the
+  // playwright plugin connecting to the Camoufox websocket) is still
+  // 'pending' at this point and its tools are absent from the live
+  // registry, so the turn would proceed with mcp__playwright-tools__*
+  // stuck "connecting" until the next refresh. Wait (bounded) for the
+  // newly-added servers to finish connecting before returning.
+  await waitForMcpServersReady(qi, result.added);
+  return result;
+}
+
+/**
+ * The context figures `warm_session` populates, read back out of the
+ * daemon's session store. In-process the host and the store share a
+ * process, so this is a lookup; in Phase 2 it is the reply that carries
+ * those numbers home.
+ */
+async function sessionInfo(chatId: string): Promise<HostSessionInfo> {
+  const session = getSession(chatId);
+  return {
+    chatId,
+    sessionId: session.sessionId,
+    turns: session.turns,
+    contextTokens: session.usage.contextTokens,
+    contextWindow: session.usage.contextWindow,
+  };
+}
+
+/**
+ * The Claude SDK backend keeps no conversation memory of its own — each
+ * turn is a fresh subprocess — so the only per-chat state the host holds
+ * is the in-flight query handle. Dropping it is interrupting it.
+ *
+ * Not bound into the `Backend` object: claude-sdk has no `resetChat`
+ * slot today and Phase 1 does not add one. `/reset` still clears the
+ * stored session id through `storage/sessions.ts`, as it always has.
+ */
+async function resetSession(chatId: string): Promise<boolean> {
+  return claudeInterruptChatTurn(chatId);
+}
+
+/**
+ * Build the in-process host. `config` and `getBridgePort` are held only
+ * for `hello()`, which performs the same `initAgent(config,
+ * getBridgePort)` the factory used to call inline.
+ */
+export function createInProcessAgentHost(
+  config: TalonConfig,
+  getBridgePort?: () => number,
+): AgentHostClient {
+  return {
+    async hello(): Promise<HostReadyInfo> {
+      await claudeInitAgent(config, getBridgePort);
+      // `sdk` is omitted: in-process there is no separately-pinned SDK
+      // build to name — the daemon's own lockfile is the answer, and
+      // Phase 4 gives the host a `package.json` of its own to report.
+      return { protocol: AGENT_HOST_PROTOCOL_VERSION, host: talonVersion() };
+    },
+    runTurn: (params) => claudeRunChatTurn(params),
+    interrupt: (chatId) => claudeInterruptChatTurn(chatId),
+    runOneShot: (params) => claudeRunOneShotAgent(params),
+    warmSession: (chatId) => claudeWarmSession(chatId),
+    setMcpServers,
+    refreshTools,
+    listModels: (filter) => claudeListModels(filter),
+    planUsage: () => getPlanUsage(),
+    sessionInfo,
+    resetSession,
+    // Nothing to drain while the host is this process: the daemon's own
+    // shutdown path already aborts in-flight turns.
+    shutdown: async () => undefined,
+  };
+}

package/src/backend/codex/mcp-config.ts

@@ -29,7 +29,7 @@ import {
   pluginHubUrl,
   hubPluginServerNames,
 } from "../../core/mcp-hub/index.js";
-import type { ToolExclusionConfig } from "../../core/tools/mcp-env.js";
+import type { ToolExclusionConfig } from "../../core/tools/ops/mcp-env.js";
 import { frontendsForChat } from "../runtime/frontends.js";
 
 /**

package/src/backend/openai-agents/mcp-pool.ts

@@ -30,7 +30,7 @@ import {
   pluginHubUrl,
   hubPluginServerNames,
 } from "../../core/mcp-hub/index.js";
-import type { ToolExclusionConfig } from "../../core/tools/mcp-env.js";
+import type { ToolExclusionConfig } from "../../core/tools/ops/mcp-env.js";
 import { frontendsForChat } from "../runtime/frontends.js";
 import { log, logWarn } from "../../util/log.js";
 

package/src/backend/runtime/index.ts

@@ -20,7 +20,7 @@
  *   - `prompt/prompt-format` — user-prompt formatter
  *     ([time] [Name] [msg_id:N]).
  *   - `frontends` — config `frontend` → messaging-frontend list.
- *   - `extractSessionName` — re-exported from `util/session-name` so the
+ *   - `extractSessionName` — re-exported from `core/weaver/session-name` so the
  *     backends keep one import site; the helper itself is frontend-neutral.
  *   - `usage` — cache-hit % + log summarisers.
  *   - `prompt/system-prompt` — per-session prompt snapshots + backend
@@ -37,7 +37,7 @@
  *   - SDK-specific event types — those live in each backend.
  *   - Session storage — that's `src/storage/sessions.ts`.
  *   - MCP server registration — backend-specific transport details
- *     (the spawn/env contract they share is `core/tools/mcp-env.ts`).
+ *     (the spawn/env contract they share is `core/tools/ops/mcp-env.ts`).
  */
 
 export { captureDeliveredText } from "./turn/delivered-text.js";

package/src/backend/runtime/turn/delivery.ts

@@ -9,7 +9,7 @@
  * Routes:
  *
  *   - `tool` — a delivery tool (`end_turn` / `send` / `react`) already
- *     bridged the message to the platform via `core/tools/messaging.ts`.
+ *     bridged the message to the platform via `core/tools/chat/messaging.ts`.
  *     The message is already in the chat; we don't re-emit. We may
  *     have captured `deliveredTextNorms` for dedup, or just have
  *     `hadBridgeDelivery` set (e.g. `send(type="photo")` — non-text

package/src/backend/runtime/turn/turn-phases.ts

@@ -25,7 +25,7 @@ import {
   setSessionName,
 } from "../../../storage/sessions.js";
 import { log } from "../../../util/log.js";
-import { extractSessionName } from "../../../util/session-name.js";
+import { extractSessionName } from "../../../core/weaver/session-name.js";
 import { traceMessage } from "../../../util/trace.js";
 import {
   FLOW_VIOLATION_MAX_RETRIES,

package/src/bootstrap.ts

@@ -10,7 +10,7 @@
  */
 
 import { loadConfig, rebuildSystemPrompt } from "./core/config/index.js";
-import { initWorkspace } from "./util/workspace.js";
+import { initWorkspace } from "./core/vfs/workspace.js";
 import { loadSessions, resetSession } from "./storage/sessions.js";
 import { loadChatSettings } from "./storage/chat-settings.js";
 import { loadCronJobs } from "./storage/cron.js";
@@ -36,7 +36,7 @@ import {
 import { initDream, maybeStartDream } from "./core/background/dream/index.js";
 import { initHeartbeat } from "./core/background/heartbeat/index.js";
 import { log, logWarn, logDebug } from "./util/log.js";
-import { bootPhase } from "./util/boot-timer.js";
+import { bootPhase } from "./core/daemon/boot-timer.js";
 import { mapConcurrent } from "./util/concurrency.js";
 import type { TalonConfig } from "./core/config/index.js";
 import { resolveFrontendIdAmong } from "./core/frontend-runtime/routing.js";

package/src/cli.ts

@@ -16,13 +16,16 @@
  * `cli/index.ts`. Everything else lives under `cli/`.
  */
 
-import { MCP_LAUNCH_SUBCOMMAND, runSupervisor } from "./util/mcp-launcher.js";
+import {
+  MCP_LAUNCH_SUBCOMMAND,
+  runSupervisor,
+} from "./core/mcp-hub/launcher.js";
 import { LUA_RUN_SUBCOMMAND, runLuaMain } from "./core/scripts/lua.js";
 
 // Hidden subcommand dispatch — must run before anything else. Talon
 // supervises MCP stdio children (`_mcp-launch`) and runs WASM-sandboxed
 // Lua trigger scripts (`_lua-run`) by re-invoking its own entrypoint
-// (see util/mcp-launcher.ts). Neither call resolves; the helper process
+// (see core/mcp-hub/launcher.ts). Neither call resolves; the helper process
 // exits from its own handlers.
 if (process.argv[2] === MCP_LAUNCH_SUBCOMMAND) {
   await runSupervisor(process.argv.slice(3));

package/src/core/agent-runtime/README.md

@@ -69,6 +69,21 @@ onto the SQLite layer in `src/storage/` (typed tables or the `kv`
 singleton store). Legacy files import once at boot via
 `storage/legacy-import.ts` and are renamed `*.imported`.
 
+### `agent-host.ts`
+
+The seam the Claude Agent SDK moves out of the daemon across
+(`docs/agent-host-sidecar.md`). Two halves: the NDJSON wire vocabulary
+(`HostRequest` / `HostReply` / `HostEvent` / `HostNotice`, plus
+`parseHostMessage` / `serializeHostMessage` — unknown types parse to a
+typed `unknown` the reader logs and drops, never a throw), and
+`AgentHostClient`, the interface the daemon holds. Phase 1 ships one
+implementation, `backend/claude-sdk/host/in-process.ts`; Phase 2 adds a
+process-backed one behind the same interface. Fixtures:
+`protocol/fixtures/agent-host_v1.json`.
+
+The interface and codec live here, not in `backend/`, because `core/` may
+not import `backend/` — the implementations live under `backend/`.
+
 ### `contract-tests.ts`
 
 Backend contract assertions any conforming `Backend` must pass: