cool-workflow 0.1.98 → 0.2.0

package/dist/mcp/dispatch.js

@@ -0,0 +1,104 @@
+"use strict";
+// mcp/dispatch.ts — the generic MCP tool-call reader over
+// core/capability-table.ts.
+//
+// MILESTONE 2 (v2/PLAN.md build order, step 2). Replaces the old build's
+// 196-arm `callTool` switch (src/mcp/tool-call.ts) with a data-driven
+// lookup: resolve the row by tool name, check its declared required-arg
+// groups (SPEC/mcp.md's `McpBinding.requiredArgs`), re-base `cwd` if
+// given, then call the row's `mcp.handler`. Every future milestone adds
+// capabilities as capability-table ROWS; this file is not touched again.
+//
+// `cwd` handling here (resolve, must be a directory, inject the resolved
+// path back into a COPY of args) matches SPEC/mcp.md invariant 7. This
+// milestone's own real handlers (`list`, `sandbox.list`, `status`) do not
+// themselves need cwd, but the re-base is still performed uniformly so a
+// later milestone's handler can rely on it without dispatch.ts changing.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toolDefinitions = toolDefinitions;
+exports.requiredToolArguments = requiredToolArguments;
+exports.callTool = callTool;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const capability_table_1 = require("../core/capability-table");
+/** `toolDefinitions()` — the full, ordered `tools/list` array. */
+function toolDefinitions() {
+    return (0, capability_table_1.mcpToolDefinitions)();
+}
+/** SPEC/mcp.md invariant 6 / src/mcp-surface.ts:7-25 — required-argument
+ *  groups are declared data, not code. `undefined`/`null` become `{}`; a
+ *  non-object throws; a group "keyA|keyB" passes when at least one named
+ *  key is not `undefined`, not `null`, and not `""`. */
+function requiredToolArguments(name, value) {
+    const args = value === undefined || value === null ? {} : value;
+    if (typeof args !== "object" || Array.isArray(args)) {
+        throw new Error(`MCP tool ${name} arguments must be an object.`);
+    }
+    const row = (0, capability_table_1.findCapabilityByMcpTool)(name);
+    const requiredArgs = row?.mcp?.requiredArgs ?? [];
+    for (const group of requiredArgs) {
+        const keys = group.split("|");
+        const satisfied = keys.some((key) => {
+            const v = args[key];
+            return v !== undefined && v !== null && v !== "";
+        });
+        if (!satisfied) {
+            throw new Error(`MCP tool ${name} missing required argument: ${keys.join(" or ")}`);
+        }
+    }
+    return args;
+}
+/** `callTool(name, args)` — resolves `cwd` (SPEC/mcp.md invariant 7),
+ *  checks required args, then calls the row's `mcp.handler`. Throws
+ *  `Unknown tool: <name>` for a name with no row (src/mcp/tool-call.ts:513
+ *  parity). */
+function callTool(name, rawArgs) {
+    const row = (0, capability_table_1.findCapabilityByMcpTool)(name);
+    if (!row || !row.mcp) {
+        throw new Error(`Unknown tool: ${name}`);
+    }
+    const args = requiredToolArguments(name, rawArgs);
+    const resolvedArgs = { ...args };
+    const cwdInput = args.cwd;
+    if (typeof cwdInput === "string" && cwdInput.length > 0) {
+        const resolved = path.resolve(cwdInput);
+        if (!fs.statSync(resolved).isDirectory()) {
+            throw new Error(`MCP cwd is not a directory: ${resolved}`);
+        }
+        resolvedArgs.cwd = resolved;
+    }
+    return row.mcp.handler(resolvedArgs);
+}

package/dist/mcp/server.js

@@ -0,0 +1,144 @@
+"use strict";
+// mcp/server.ts — the stdio JSON-RPC loop: initialize / tools/list /
+// tools/call.
+//
+// MILESTONE 2 (v2/PLAN.md build order, step 2). Byte-exact port of the
+// framing rules in SPEC/mcp.md's "JSON-RPC methods" / "Exact outputs" /
+// "Invariants and error behavior" #9 / "Edge cases" sections:
+//   - transport: stdin/stdout, ONE JSON object per line, no
+//     Content-Length headers (mcp.md:13);
+//   - `initialize` -> protocolVersion/capabilities/serverInfo, ignoring
+//     params (mcp.md:19,263-269);
+//   - `tools/list` -> { tools: [...] } from core/capability-table.ts via
+//     mcp/dispatch.ts, ignoring params (mcp.md:20,271-277);
+//   - `tools/call` -> { content: [{ type: "text", text: <2-space pretty
+//     JSON string> }] } (mcp.md:21,279-285);
+//   - any other method: error -32601 if the request has an `id` key,
+//     otherwise NO reply at all (mcp.md:22,427-428);
+//   - a request with `"id": null` DOES get an error answer for an unknown
+//     method (the guard is `id !== undefined`, and `null !== undefined`)
+//     (mcp.md:427);
+//   - `initialize`/`tools/list`/`tools/call` answer even with no `id` key
+//     at all — the reply then omits `id` (JSON.stringify drops
+//     `undefined`) (mcp.md:428);
+//   - parse errors always answer with `id: null`, even when the broken
+//     line contained one (mcp.md:429, 290-291);
+//   - a line that parses to non-object JSON (number/string/array/null)
+//     gets -32600 "Invalid Request: not a JSON-RPC object" (mcp.md:292,
+//     430);
+//   - many requests in one stdin chunk: split on every "\n", .trim() each
+//     line, skip empty lines (mcp.md:431);
+//   - `tools/call` with a missing/empty/whitespace-only `name` throws
+//     "MCP tools/call missing required field: name" as -32000 (mcp.md:432);
+//   - `arguments: null`/absent -> `{}` before the required-args check
+//     (mcp.md:433);
+//   - fail-closed input framing: MAX_LINE_BYTES = 16 * 1024 * 1024; when
+//     the unconsumed buffer exceeds this with no newline yet, the partial
+//     bytes are DROPPED and a -32700 "Parse error: request line exceeds
+//     16777216 bytes" is sent with id: null (mcp.md:291,418).
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.startServer = startServer;
+const version_1 = require("../core/version");
+const dispatch_1 = require("./dispatch");
+const MAX_LINE_BYTES = 16 * 1024 * 1024;
+function writeMessage(message) {
+    process.stdout.write(`${JSON.stringify(message)}\n`);
+}
+function errorMessage(id, code, message) {
+    return { jsonrpc: "2.0", id: id === undefined ? null : id, error: { code, message } };
+}
+function resultMessage(id, result) {
+    const message = { jsonrpc: "2.0", result };
+    if (id !== undefined)
+        message.id = id;
+    return message;
+}
+/** Handles one already-parsed JSON-RPC request object. May write zero or
+ *  one reply line to stdout. */
+function handleRequest(message) {
+    const hasId = Object.prototype.hasOwnProperty.call(message, "id");
+    const id = message.id;
+    if (typeof message.method !== "string") {
+        // Not really reachable from valid JSON-RPC callers, but stay
+        // fail-closed rather than throw synchronously out of the read loop.
+        if (hasId)
+            writeMessage(errorMessage(id, -32601, `Unknown method: ${String(message.method)}`));
+        return;
+    }
+    try {
+        switch (message.method) {
+            case "initialize": {
+                writeMessage(resultMessage(id, {
+                    protocolVersion: "2024-11-05",
+                    capabilities: { tools: {} },
+                    serverInfo: { name: "cool-workflow", version: version_1.CURRENT_COOL_WORKFLOW_VERSION },
+                }));
+                return;
+            }
+            case "tools/list": {
+                writeMessage(resultMessage(id, { tools: (0, dispatch_1.toolDefinitions)() }));
+                return;
+            }
+            case "tools/call": {
+                const params = message.params ?? {};
+                const name = params.name;
+                if (typeof name !== "string" || name.trim() === "") {
+                    throw new Error("MCP tools/call missing required field: name");
+                }
+                const args = params.arguments;
+                const coreResult = (0, dispatch_1.callTool)(name, args ?? {});
+                writeMessage(resultMessage(id, { content: [{ type: "text", text: JSON.stringify(coreResult, null, 2) }] }));
+                return;
+            }
+            default: {
+                if (hasId)
+                    writeMessage(errorMessage(id, -32601, `Unknown method: ${message.method}`));
+                return;
+            }
+        }
+    }
+    catch (error) {
+        const text = error instanceof Error ? error.message : String(error);
+        writeMessage(errorMessage(id, -32000, text));
+    }
+}
+/** Handles one raw (already-trimmed, non-empty) stdin line. */
+function handleLine(line) {
+    let parsed;
+    try {
+        parsed = JSON.parse(line);
+    }
+    catch (error) {
+        const detail = error instanceof Error ? error.message : String(error);
+        writeMessage(errorMessage(null, -32700, `Parse error: ${detail}`));
+        return;
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        writeMessage(errorMessage(null, -32600, "Invalid Request: not a JSON-RPC object"));
+        return;
+    }
+    handleRequest(parsed);
+}
+/** Starts the stdio read loop. Never resolves — the server is long-lived
+ *  and stops only when its stdin closes / the process exits. */
+function startServer() {
+    process.stdin.setEncoding("utf8");
+    let buffer = "";
+    process.stdin.on("data", (chunk) => {
+        buffer += chunk;
+        for (;;) {
+            const newlineIndex = buffer.indexOf("\n");
+            if (newlineIndex === -1)
+                break;
+            const line = buffer.slice(0, newlineIndex);
+            buffer = buffer.slice(newlineIndex + 1);
+            const trimmed = line.trim();
+            if (trimmed)
+                handleLine(trimmed);
+        }
+        if (buffer.length > MAX_LINE_BYTES) {
+            buffer = "";
+            writeMessage(errorMessage(null, -32700, `Parse error: request line exceeds ${MAX_LINE_BYTES} bytes`));
+        }
+    });
+}

package/dist/mcp-server.js

@@ -1,87 +1,9 @@
 #!/usr/bin/env node
 "use strict";
+// src/mcp-server.ts — the real MCP server binary entry point. Compiles to
+// dist/mcp-server.js, a sibling of dist/cli.js. Byte-exact shape of the
+// old build's src/mcp-server.ts (scripts/mcp-server.js requires it; a
+// real MCP client launches it directly with `node`).
 Object.defineProperty(exports, "__esModule", { value: true });
-const mcp_surface_1 = require("./mcp-surface");
-const version_1 = require("./version");
-process.stdin.setEncoding("utf8");
-let buffer = "";
-// A single line-delimited JSON-RPC request is bounded; an un-terminated stream
-// (a peer that never sends a newline, or a slow byte dribble) must not grow the
-// long-lived server's buffer without limit until it OOMs. Cap the unconsumed
-// buffer and fail closed on a frame that exceeds it.
-const MAX_LINE_BYTES = 16 * 1024 * 1024;
-process.stdin.on("data", (chunk) => {
-    buffer += chunk;
-    let newlineIndex;
-    while ((newlineIndex = buffer.indexOf("\n")) >= 0) {
-        const line = buffer.slice(0, newlineIndex).trim();
-        buffer = buffer.slice(newlineIndex + 1);
-        if (line)
-            handleLine(line);
-    }
-    if (buffer.length > MAX_LINE_BYTES) {
-        // No newline in an over-cap buffer => a malformed or hostile frame. Reject it
-        // and drop the partial bytes rather than accumulate toward OOM.
-        buffer = "";
-        sendError(null, -32700, `Parse error: request line exceeds ${MAX_LINE_BYTES} bytes`);
-    }
-});
-function handleLine(line) {
-    let message;
-    try {
-        message = JSON.parse(line);
-    }
-    catch (error) {
-        sendError(null, -32700, `Parse error: ${messageOf(error)}`);
-        return;
-    }
-    if (message === null || typeof message !== "object" || Array.isArray(message)) {
-        sendError(null, -32600, "Invalid Request: not a JSON-RPC object");
-        return;
-    }
-    try {
-        if (message.method === "initialize") {
-            sendResult(message.id, {
-                protocolVersion: "2024-11-05",
-                capabilities: { tools: {} },
-                serverInfo: { name: "cool-workflow", version: version_1.CURRENT_COOL_WORKFLOW_VERSION }
-            });
-            return;
-        }
-        if (message.method === "tools/list") {
-            sendResult(message.id, { tools: (0, mcp_surface_1.toolDefinitions)() });
-            return;
-        }
-        if (message.method === "tools/call") {
-            const toolName = requiredToolName(message.params?.name);
-            const toolArgs = (0, mcp_surface_1.requiredToolArguments)(toolName, message.params?.arguments);
-            const result = (0, mcp_surface_1.callTool)(toolName, toolArgs);
-            sendResult(message.id, {
-                content: [{ type: "text", text: JSON.stringify(result, null, 2) }]
-            });
-            return;
-        }
-        if (message.id !== undefined)
-            sendError(message.id, -32601, `Unknown method: ${message.method}`);
-    }
-    catch (error) {
-        sendError(message.id, -32000, messageOf(error));
-    }
-}
-function requiredToolName(value) {
-    if (typeof value !== "string" || !value.trim())
-        throw new Error("MCP tools/call missing required field: name");
-    return value;
-}
-function sendResult(id, result) {
-    send({ jsonrpc: "2.0", id, result });
-}
-function sendError(id, code, message) {
-    send({ jsonrpc: "2.0", id, error: { code, message } });
-}
-function send(message) {
-    process.stdout.write(`${JSON.stringify(message)}\n`);
-}
-function messageOf(error) {
-    return error instanceof Error ? error.message : String(error);
-}
+const server_1 = require("./mcp/server");
+(0, server_1.startServer)();

package/dist/{agent-config.js → shell/agent-config.js}

@@ -1,40 +1,78 @@
 "use strict";
-// Agent Delegation Config (v0.1.38) — POLICY expressed as DATA. WHICH agent
-// (claude / codex / ollama / an HTTP endpoint) fulfills each worker is a plain,
-// diffable config record, NEVER a CW dependency. Resolution order is
-// flags > env > a durable $CW_HOME/agent-config.json > fail-closed.
+// shell/agent-config.ts — agent delegation config: env/file/flag resolution
+// order, CW_HOME resolution, builtin:<name> expansion, PATH auto-detect.
 //
-// BSD discipline:
-//  - MECHANISM vs POLICY: the `agent` backend is mechanism; this file is the
-//    policy data it reads. The kernel never learns which vendor was chosen.
-//  - NO SECRETS IN COMMITTED STATE [load-bearing]: the durable config holds a
-//    command-TEMPLATE + endpoint + operator-chosen model only. API keys come from
-//    the AGENT's own inherited env, never written into .cw/ or the config file.
-//    Any secret-looking arg is stripped before it is persisted OR shown.
-//  - DETERMINISTIC SHOW: `agentConfigShow` is a pure projection of env + file —
-//    no now-derived field — so `cw backend agent config show --json` is
-//    byte-identical to the MCP tool (CLI<->MCP parity).
+// MILESTONE 5 (v2/PLAN.md build order, step 5). Byte-exact port of
+// plugins/cool-workflow/src/agent-config.ts.
 //
-// See docs/agent-delegation-drive.7.md.
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
+// Resolution order per field: flags > env > a durable
+// $CW_HOME/agent-config.json > auto-detect > none. NO SECRETS IN COMMITTED
+// STATE: the durable config holds a command-TEMPLATE + endpoint + operator-
+// chosen model only; a secret-looking arg is stripped before persisting or
+// showing.
+//
+// Evidence: SPEC/execution-backend.md "Agent delegation config".
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.AGENT_CONFIG_SCHEMA_VERSION = void 0;
+exports.resolveCwHome = resolveCwHome;
 exports.agentConfigPath = agentConfigPath;
 exports.loadAgentConfigFile = loadAgentConfigFile;
 exports.resolveAgentConfig = resolveAgentConfig;
 exports.agentConfigured = agentConfigured;
 exports.setAgentConfigFile = setAgentConfigFile;
 exports.agentConfigShow = agentConfigShow;
-const node_fs_1 = __importDefault(require("node:fs"));
-const node_path_1 = __importDefault(require("node:path"));
-const run_registry_1 = require("./run-registry");
-const execution_backend_1 = require("./execution-backend");
-const state_1 = require("./state");
+exports.backendAgentConfigSet = backendAgentConfigSet;
+exports.backendAgentConfigShow = backendAgentConfigShow;
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const fs_atomic_1 = require("./fs-atomic");
+const agent_1 = require("./execution-backend/agent");
 exports.AGENT_CONFIG_SCHEMA_VERSION = 1;
+/** CW_HOME resolution: CW_HOME > XDG_STATE_HOME/cool-workflow > ~/.local/state/cool-workflow. */
+function resolveCwHome(env = process.env) {
+    if (env.CW_HOME && String(env.CW_HOME).trim())
+        return path.resolve(String(env.CW_HOME));
+    if (env.XDG_STATE_HOME && String(env.XDG_STATE_HOME).trim()) {
+        return path.join(path.resolve(String(env.XDG_STATE_HOME)), "cool-workflow");
+    }
+    return path.join(os.homedir(), ".local", "state", "cool-workflow");
+}
 function agentConfigPath(env = process.env) {
-    return node_path_1.default.join((0, run_registry_1.resolveCwHome)(env), "agent-config.json");
+    return path.join(resolveCwHome(env), "agent-config.json");
 }
 function trimmed(value) {
     if (typeof value !== "string")
@@ -42,8 +80,6 @@ function trimmed(value) {
     const out = value.trim();
     return out ? out : undefined;
 }
-/** Parse a boolean from a flag (boolean) or an env/file string. Returns undefined
- *  for unset/unrecognized so `firstDefined` falls through to the next layer. */
 function boolish(value) {
     if (typeof value === "boolean")
         return value;
@@ -68,8 +104,9 @@ function firstDefined(...values) {
             return value;
     return undefined;
 }
-/** Split a single command string ("claude -p {{manifest}}") into binary + argv
- *  template — NEVER shell-interpreted. An explicit args array always wins. */
+/** Split a single command string ("claude -p {{manifest}}") into binary +
+ *  argv template — NEVER shell-interpreted. An explicit args array always
+ *  wins. */
 function splitCommand(command, args) {
     if (!command)
         return { command: undefined, args };
@@ -85,10 +122,10 @@ function splitCommand(command, args) {
  *  treated as absent (fail closed). */
 function loadAgentConfigFile(env = process.env) {
     const file = agentConfigPath(env);
-    if (!node_fs_1.default.existsSync(file))
+    if (!fs.existsSync(file))
         return undefined;
     try {
-        const parsed = JSON.parse(node_fs_1.default.readFileSync(file, "utf8"));
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
         return {
             schemaVersion: 1,
             command: trimmed(parsed.command),
@@ -98,7 +135,7 @@ function loadAgentConfigFile(env = process.env) {
             timeoutMs: typeof parsed.timeoutMs === "number" ? parsed.timeoutMs : undefined,
             attestPublicKey: trimmed(parsed.attestPublicKey),
             requireAttestedTelemetry: boolish(parsed.requireAttestedTelemetry),
-            source: "file"
+            source: "file",
         };
     }
     catch {
@@ -116,7 +153,7 @@ function agentConfigFromEnv(env) {
         timeoutMs: trimmed(env.CW_AGENT_TIMEOUT_MS) ? Number(env.CW_AGENT_TIMEOUT_MS) : undefined,
         attestPublicKey: trimmed(env.CW_AGENT_ATTEST_PUBKEY),
         requireAttestedTelemetry: boolish(env.CW_REQUIRE_ATTESTED_TELEMETRY),
-        source: "env"
+        source: "env",
     };
 }
 function agentConfigFromArgs(args) {
@@ -133,51 +170,41 @@ function agentConfigFromArgs(args) {
         timeoutMs: rawTimeout !== undefined ? Number(rawTimeout) : undefined,
         attestPublicKey: trimmed(args.agentAttestPublicKey ?? args["agent-attest-public-key"]),
         requireAttestedTelemetry: boolish(args.requireAttestedTelemetry ?? args["require-attested-telemetry"]),
-        source: "flag"
+        source: "flag",
     };
 }
-// Bundled agent templates, addressable by a stable name so an operator (or an
-// npx/global install, where $(pwd)-relative paths don't exist) can configure a
-// WORKING agent without knowing where the package landed on disk:
-//   --agent-command builtin:claude   (or CW_AGENT_COMMAND=builtin:claude)
-// resolves to the packaged wrapper invocation. Still pure config — the template
-// is an out-of-process delegation script; CW never calls a model API.
-//
-// The builtin set is DATA, not a kernel TS literal (FreeBSD-audit L15): it lives
-// in scripts/agents/builtin-templates.json (vendor name -> wrapper script name).
-// Adding a vendor is a content/distribution step (drop a wrapper + a JSON line),
-// not a kernel edit — keeping CW vendor-agnostic at the source level.
-/** Detect which known agent CLIs are on PATH. Returns the first found, or undefined.
- *  Skipped when CW_NO_AUTO_AGENT=1 (test sandboxes, CI without real agents). */
+/** Detect which known agent CLIs are on PATH. Returns the first found, or
+ *  undefined. Skipped when CW_NO_AUTO_AGENT=1. */
 function detectAgentFromPath(env = process.env) {
     if (env.CW_NO_AUTO_AGENT === "1")
         return undefined;
     const known = ["claude", "codex", "gemini", "opencode"];
-    const dirs = (env.PATH || "").split(node_path_1.default.delimiter).filter(Boolean);
+    const dirs = (env.PATH || "").split(path.delimiter).filter(Boolean);
     const exts = process.platform === "win32" ? (env.PATHEXT || ".EXE;.CMD;.BAT").split(";") : [""];
+    const templates = builtinAgentTemplates();
     for (const name of known) {
-        // Also check if the builtin template exists (so we don't suggest an unsupported agent).
-        const templates = builtinAgentTemplates();
         if (!templates[name])
             continue;
         for (const dir of dirs) {
             for (const ext of exts) {
                 try {
-                    if (node_fs_1.default.statSync(node_path_1.default.join(dir, name + ext)).isFile())
+                    if (fs.statSync(path.join(dir, name + ext)).isFile())
                         return name;
                 }
-                catch { /* keep looking */ }
+                catch {
+                    /* keep looking */
+                }
             }
         }
     }
     return undefined;
 }
 function builtinAgentTemplates() {
-    const agentsDir = node_path_1.default.join(__dirname, "..", "scripts", "agents");
-    const manifest = JSON.parse(node_fs_1.default.readFileSync(node_path_1.default.join(agentsDir, "builtin-templates.json"), "utf8"));
+    const agentsDir = path.join(__dirname, "..", "..", "scripts", "agents");
+    const manifest = JSON.parse(fs.readFileSync(path.join(agentsDir, "builtin-templates.json"), "utf8"));
     const out = {};
     for (const [name, script] of Object.entries(manifest.templates || {})) {
-        out[name] = `node ${node_path_1.default.join(agentsDir, script)} {{input}} {{result}}`;
+        out[name] = `node ${path.join(agentsDir, script)} {{input}} {{result}}`;
     }
     return out;
 }
@@ -192,8 +219,9 @@ function expandBuiltinAgentCommand(command) {
     }
     return template;
 }
-/** Resolve the EFFECTIVE agent config: flags > env > file > none. The returned
- *  `source` names the layer the command/endpoint came from. */
+/** Resolve the EFFECTIVE agent config: flags > env > file > auto-detect >
+ *  none. The returned `source` names the layer the command/endpoint came
+ *  from. */
 function resolveAgentConfig(args = {}, env = process.env) {
     const flagCfg = agentConfigFromArgs(args);
     const envCfg = agentConfigFromEnv(env);
@@ -212,9 +240,6 @@ function resolveAgentConfig(args = {}, env = process.env) {
             : fileCfg && (fileCfg.command || fileCfg.endpoint)
                 ? "file"
                 : "none";
-    // Auto-detect: if no agent is configured, check PATH for known agent CLIs and
-    // resolve via builtin:<name>. This makes `cw quickstart` work without
-    // --agent-command on machines where claude/codex/gemini/opencode are installed.
     let finalCommand = command;
     let finalSource = source;
     let finalModel = model;
@@ -223,27 +248,38 @@ function resolveAgentConfig(args = {}, env = process.env) {
         if (detected) {
             finalCommand = expandBuiltinAgentCommand(`builtin:${detected}`);
             finalSource = "auto";
-            // Store the detected vendor name as the model hint so doctor can show it.
             if (!finalModel)
                 finalModel = `builtin:${detected}`;
         }
     }
-    return { schemaVersion: 1, command: finalCommand, args: cfgArgs, endpoint, model: finalModel, timeoutMs, attestPublicKey, requireAttestedTelemetry, source: finalSource };
+    return {
+        schemaVersion: 1,
+        command: finalCommand,
+        args: cfgArgs,
+        endpoint,
+        model: finalModel,
+        timeoutMs,
+        attestPublicKey,
+        requireAttestedTelemetry,
+        source: finalSource,
+    };
 }
 /** True iff a command-template OR endpoint is configured (after resolution). */
 function agentConfigured(args = {}, env = process.env) {
     const resolved = resolveAgentConfig(args, env);
     return Boolean(resolved.command || resolved.endpoint);
 }
-/** Secret-stripped copy safe to persist or show — never carries raw credentials. */
+/** Secret-stripped copy safe to persist or show — never carries raw
+ *  credentials. */
 function redacted(config) {
     return {
         ...config,
-        args: config.args ? (0, execution_backend_1.stripSecretArgs)(config.args) : undefined
+        args: config.args ? (0, agent_1.stripSecretArgs)(config.args) : undefined,
     };
 }
-/** Persist the durable config (secret-stripped). Returns the stored, redacted
- *  config. API keys are NEVER written — they come from the agent's own env. */
+/** Persist the durable config (secret-stripped). Returns the stored,
+ *  redacted config. API keys are NEVER written — they come from the
+ *  agent's own env. */
 function setAgentConfigFile(patch, env = process.env) {
     const current = loadAgentConfigFile(env) || { schemaVersion: 1 };
     const incoming = agentConfigFromArgs(patch);
@@ -256,16 +292,16 @@ function setAgentConfigFile(patch, env = process.env) {
         timeoutMs: firstDefined(incoming.timeoutMs, current.timeoutMs),
         attestPublicKey: firstDefined(incoming.attestPublicKey, current.attestPublicKey),
         requireAttestedTelemetry: firstDefined(incoming.requireAttestedTelemetry, current.requireAttestedTelemetry),
-        source: "file"
+        source: "file",
     };
     const stored = redacted(merged);
     const file = agentConfigPath(env);
-    node_fs_1.default.mkdirSync(node_path_1.default.dirname(file), { recursive: true });
-    (0, state_1.writeJson)(file, stored);
+    (0, fs_atomic_1.writeJson)(file, stored);
     return stored;
 }
-/** Read-only, deterministic projection of the effective config (secret-stripped).
- *  No now-derived field — safe for CLI<->MCP payload parity. */
+/** Read-only, deterministic projection of the effective config
+ *  (secret-stripped). No now-derived field — safe for CLI<->MCP payload
+ *  parity. */
 function agentConfigShow(args = {}, env = process.env) {
     const resolved = resolveAgentConfig(args, env);
     return {
@@ -274,6 +310,17 @@ function agentConfigShow(args = {}, env = process.env) {
         source: resolved.source,
         config: redacted(resolved),
         path: agentConfigPath(env),
-        fileExists: node_fs_1.default.existsSync(agentConfigPath(env))
+        fileExists: fs.existsSync(agentConfigPath(env)),
     };
 }
+/** Persist the durable agent config (secret-stripped) and return the new
+ *  state. */
+function backendAgentConfigSet(args, env = process.env) {
+    setAgentConfigFile(args, env);
+    return agentConfigShow(args, env);
+}
+/** Read-only, deterministic projection of the effective agent config
+ *  (secret-stripped). */
+function backendAgentConfigShow(args, env = process.env) {
+    return agentConfigShow(args, env);
+}