@zeroroot-ai/zerocool-claude 0.5.2 → 0.6.0

package/.claude-plugin/plugin.json

@@ -2,7 +2,7 @@
   "$schema": "https://json.schemastore.org/claude-code-plugin-manifest.json",
   "name": "zerocool",
   "displayName": "Zerocool (Gibson)",
-  "description": "Gibson platform integration for Claude Code. The session is a live mission. Memory and knowledge in the tenant graph, findings, Gibson tools, delegation. The model stays on your Claude subscription.",
+  "description": "Gibson for Claude Code. The model stays on your Claude login.",
   "author": {
     "name": "ZeroRoot",
     "url": "https://zeroroot.ai"

package/.mcp.json

@@ -2,7 +2,7 @@
   "mcpServers": {
     "gibson": {
       "command": "npx",
-      "args": ["--yes", "--package", "@zeroroot-ai/zerocool-claude@latest", "zerocool-claude-mcp"]
+      "args": ["--yes", "--package", "@zeroroot-ai/gibson-mcp@latest", "gibson-mcp", "--transport", "stdio"]
     }
   }
 }

package/dist/index.d.ts

@@ -1,8 +1,2 @@
-export * from "./mode.js";
-export * from "./session.js";
 export * from "./state.js";
-export * from "./ambient.js";
-export * from "./config.js";
-export * from "./cli.js";
-export { buildServer } from "./build.js";
-export { runHook } from "./hook-run.js";
+export { runHook, type HookInput } from "./hook-run.js";

package/dist/index.js

@@ -1,10 +1,8 @@
-// @zeroroot-ai/zerocool-claude: library surface, for tests and for anyone who
-// embeds the server. The bins are server.ts and hook.ts.
-export * from "./mode.js";
-export * from "./session.js";
+// @zeroroot-ai/zerocool-claude: the Claude Code host adapter (ADR-0008).
+//
+// The tools are not here. They come from the Gibson MCP server, which the
+// bundle's `.mcp.json` names. This package is the bundle around it: the
+// plugin manifest, the marketplace entry, and two hooks. The only bin is
+// the hook.
 export * from "./state.js";
-export * from "./ambient.js";
-export * from "./config.js";
-export * from "./cli.js";
-export { buildServer } from "./build.js";
 export { runHook } from "./hook-run.js";

package/dist/state.d.ts

@@ -1,12 +1,16 @@
 /**
- * The handoff between the MCP server and the hook processes.
+ * The handoff from the Gibson MCP server to this plugin's hooks.
  *
- * Hooks run as separate processes and cannot reach the MCP server's session.
- * The server writes one small file per working directory: the ambient
- * knowledge block for SessionStart, and the live-mission coordinates for
- * SessionEnd. The file is the server's and lives beside the host key. The task
- * grant in it is bounded (30 minutes, renewed by the server), and a hook that
- * finds a stale one fails open.
+ * A hook runs as its own process and cannot reach the server's session, so
+ * the server writes one small file per working directory in `~/.zerocool/`:
+ * the ambient knowledge block for SessionStart, and the live-mission
+ * coordinates for SessionEnd (ADR-0007's consequence, now served by the
+ * server, ADR-0008).
+ *
+ * This file is the read half of that format, kept here because a hook must
+ * not depend on the server package: the format is the contract, not the
+ * import. It matches `@zeroroot-ai/gibson-mcp`'s `state.ts` exactly, and the
+ * key is a hash of the working directory.
  */
 export interface LiveState {
     missionId: string;
@@ -19,8 +23,7 @@ export interface LiveState {
 }
 export declare function stateDir(env?: NodeJS.ProcessEnv): string;
 export declare function keyFor(cwd: string): string;
-export declare function writeAmbient(dir: string, cwd: string, block: string): Promise<void>;
+/** The block SessionStart injects. Empty when the server wrote none. */
 export declare function readAmbient(dir: string, cwd: string): Promise<string>;
-export declare function writeLive(dir: string, cwd: string, state: LiveState): Promise<void>;
+/** The live mission SessionEnd checkpoints under. Undefined when there is none. */
 export declare function readLive(dir: string, cwd: string): Promise<LiveState | undefined>;
-export declare function clearLive(dir: string, cwd: string): Promise<void>;

package/dist/state.js

@@ -1,17 +1,14 @@
-import { mkdir, readFile, writeFile, rm } from "node:fs/promises";
+import { readFile } from "node:fs/promises";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { createHash } from "node:crypto";
 export function stateDir(env = process.env) {
-    return env.ZEROCOOL_STATE_DIR ?? join(homedir(), ".zerocool", "claude");
+    return env.ZEROCOOL_STATE_DIR ?? join(homedir(), ".zerocool");
 }
 export function keyFor(cwd) {
     return createHash("sha256").update(cwd).digest("hex").slice(0, 16);
 }
-export async function writeAmbient(dir, cwd, block) {
-    await mkdir(dir, { recursive: true, mode: 0o700 });
-    await writeFile(join(dir, `ambient-${keyFor(cwd)}.md`), block, { encoding: "utf8", mode: 0o600 });
-}
+/** The block SessionStart injects. Empty when the server wrote none. */
 export async function readAmbient(dir, cwd) {
     try {
         return await readFile(join(dir, `ambient-${keyFor(cwd)}.md`), "utf8");
@@ -20,10 +17,7 @@ export async function readAmbient(dir, cwd) {
         return "";
     }
 }
-export async function writeLive(dir, cwd, state) {
-    await mkdir(dir, { recursive: true, mode: 0o700 });
-    await writeFile(join(dir, `live-${keyFor(cwd)}.json`), JSON.stringify(state), { encoding: "utf8", mode: 0o600 });
-}
+/** The live mission SessionEnd checkpoints under. Undefined when there is none. */
 export async function readLive(dir, cwd) {
     try {
         return JSON.parse(await readFile(join(dir, `live-${keyFor(cwd)}.json`), "utf8"));
@@ -32,6 +26,3 @@ export async function readLive(dir, cwd) {
         return undefined;
     }
 }
-export async function clearLive(dir, cwd) {
-    await rm(join(dir, `live-${keyFor(cwd)}.json`), { force: true });
-}

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@zeroroot-ai/zerocool-claude",
-  "version": "0.5.2",
-  "description": "Claude Code plugin: Gibson platform integration (zerocool). The session is a live mission. Memory, knowledge, findings, tools, delegation. The model stays on your Claude subscription.",
+  "version": "0.6.0",
+  "description": "Claude Code host adapter for Gibson (zerocool): the plugin bundle around the Gibson MCP server, plus SessionStart and SessionEnd hooks. The model stays on your Claude login.",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -25,14 +25,10 @@
     "test": "tsc -p tsconfig.test.json && node --test \"dist-test/**/*.test.js\""
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.30.0",
-    "@zeroroot-ai/sdk": "^0.9.0",
-    "zod": "^4.4.3"
+    "@zeroroot-ai/sdk": "^0.9.0"
   },
   "bin": {
-    "zerocool-claude-mcp": "dist/server.js",
-    "zerocool-claude-hook": "dist/hook.js",
-    "zerocool-claude-dispatch": "dist/sandbox.js"
+    "zerocool-claude-hook": "dist/hook.js"
   },
   "publishConfig": {
     "access": "public"

package/dist/ambient.d.ts

@@ -1,7 +0,0 @@
-import { type KnowledgeSource } from "@zeroroot-ai/sdk";
-/**
- * One GraphRAG lookup per session, injected by the SessionStart hook. A
- * knowledge failure never breaks a start: the agent works without prior
- * context, it just works less well.
- */
-export declare function ambientBlock(knowledge: KnowledgeSource, seedQuery: string): Promise<string>;

package/dist/ambient.js

@@ -1,18 +0,0 @@
-import { formatKnowledgeForPrompt } from "@zeroroot-ai/sdk";
-/** How many hits the ambient block carries. Small: it is prompt overhead on every session. */
-const AMBIENT_LIMIT = 5;
-/**
- * One GraphRAG lookup per session, injected by the SessionStart hook. A
- * knowledge failure never breaks a start: the agent works without prior
- * context, it just works less well.
- */
-export async function ambientBlock(knowledge, seedQuery) {
-    try {
-        const hits = await knowledge.query({ text: seedQuery, topK: AMBIENT_LIMIT });
-        const body = formatKnowledgeForPrompt(hits);
-        return body ? `Prior context from the Gibson knowledge graph (recall for more):\n${body}` : "";
-    }
-    catch {
-        return "";
-    }
-}

package/dist/build.d.ts

@@ -1,32 +0,0 @@
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { type CliOptions } from "./cli.js";
-import { type Gibson, type OpenGibsonOptions } from "./session.js";
-/**
- * @zeroroot-ai/zerocool-claude: the MCP server Claude Code starts for a session.
- *
- * The model stays on the user's Claude subscription. This server adds Gibson:
- * one live mission per session, memory and knowledge, findings, tools,
- * delegation. It never routes LLM traffic and never reads an Anthropic key
- * (ADR-0007).
- *
- * The connection is made in the session, not before it. `gibson_login` starts
- * the CLI device flow and returns the URL and code. `gibson_connect` enrolls
- * through the CLI session, trusts the private CA, checks in, picks the
- * target, starts the live mission and swaps the tool set live. The settings
- * it learns are persisted, so later sessions connect on their own.
- */
-export declare const log: (line: string) => void;
-export interface BuildDeps {
-    open?: Pick<OpenGibsonOptions, "connect" | "start" | "hostKeyExists" | "trust">;
-    cli?: CliOptions;
-}
-export interface Surface {
-    server: McpServer;
-    /** The current connection. Changes on gibson_connect. */
-    current(): Gibson;
-    /** Replace the connection and re-register the posture's tools. */
-    upgrade(next: Gibson): Promise<void>;
-}
-export declare function buildServer(env: NodeJS.ProcessEnv, cwd: string, deps?: BuildDeps): Promise<Surface>;
-/** What a coding workspace is, as a URL: its git origin, else the directory. */
-export declare function workspaceURL(cwd: string): Promise<string>;

package/dist/build.js

@@ -1,218 +0,0 @@
-import { execFile } from "node:child_process";
-import { existsSync } from "node:fs";
-import { promisify } from "node:util";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
-import { z } from "zod";
-import { ambientBlock } from "./ambient.js";
-import { createTarget, enrollIdentity, listTargets, startLogin } from "./cli.js";
-import { loadSettings, writeConfig } from "./config.js";
-import { openGibson } from "./session.js";
-import { stateDir, writeAmbient, writeLive } from "./state.js";
-import { registerComponentizeTool, registerEnrollTool } from "./tools/componentize.js";
-import { registerDelegationTools } from "./tools/delegate.js";
-import { gibsonFindingsBackend, localFindingsBackend, registerFindingTools, taskFindingsBackend } from "./tools/findings.js";
-import { registerGibsonTools } from "./tools/gibson-tools.js";
-import { registerMemoryTools } from "./tools/memory.js";
-import { failure, text } from "./tools/result.js";
-import { describeGibson, registerStatusTool } from "./tools/status.js";
-/**
- * @zeroroot-ai/zerocool-claude: the MCP server Claude Code starts for a session.
- *
- * The model stays on the user's Claude subscription. This server adds Gibson:
- * one live mission per session, memory and knowledge, findings, tools,
- * delegation. It never routes LLM traffic and never reads an Anthropic key
- * (ADR-0007).
- *
- * The connection is made in the session, not before it. `gibson_login` starts
- * the CLI device flow and returns the URL and code. `gibson_connect` enrolls
- * through the CLI session, trusts the private CA, checks in, picks the
- * target, starts the live mission and swaps the tool set live. The settings
- * it learns are persisted, so later sessions connect on their own.
- */
-export const log = (line) => {
-    process.stderr.write(`${line}\n`);
-};
-/** Snapshot of the tools a posture registered, so an upgrade can drop them. */
-function collect(server, register) {
-    const before = new Set(Object.keys(toolTable(server)));
-    return Promise.resolve(register()).then(() => {
-        const after = toolTable(server);
-        return Object.keys(after)
-            .filter((n) => !before.has(n))
-            .map((n) => after[n]);
-    });
-}
-function toolTable(server) {
-    return server._registeredTools;
-}
-export async function buildServer(env, cwd, deps = {}) {
-    const settings = await loadSettings(env);
-    let gibson = await openGibson({ settings, log, env, ...deps.open });
-    const server = new McpServer({ name: "zerocool", version: "0.0.0" });
-    let posture = [];
-    const surface = {
-        server,
-        current: () => gibson,
-        upgrade: async (next) => {
-            for (const t of posture)
-                t.remove();
-            posture = await collect(server, () => registerPosture(server, next, env, cwd));
-            gibson = next;
-        },
-    };
-    registerStatusTool(server, () => gibson);
-    registerComponentizeTool(server, cwd);
-    // A sandboxed dispatch is fully decided by its launch; there is nothing to
-    // log in to or connect, and no host key to write.
-    if (gibson.mode !== "task")
-        registerConnectTools(server, surface, env, cwd, deps);
-    posture = await collect(server, () => registerPosture(server, gibson, env, cwd));
-    return surface;
-}
-/** The tools a posture carries, plus the handoff files for the hooks. */
-async function registerPosture(server, gibson, env, cwd) {
-    if (gibson.mode === "task" && gibson.live) {
-        // A sandboxed dispatch holds one grant and nothing else: the tools that
-        // run under it, and no component-side surface (enroll, delegation,
-        // tool discovery) because there is no component client.
-        registerFindingTools(server, gibson, taskFindingsBackend(gibson.live.harness));
-        registerMemoryTools(server, gibson);
-        return;
-    }
-    if (!gibson.session) {
-        registerFindingTools(server, gibson, localFindingsBackend(env.ZEROCOOL_FINDINGS_LOG ?? join(homedir(), ".zerocool", "findings.jsonl")));
-        return;
-    }
-    registerFindingTools(server, gibson, gibsonFindingsBackend(gibson));
-    registerMemoryTools(server, gibson);
-    registerEnrollTool(server, gibson.session);
-    registerDelegationTools(server, gibson.session);
-    try {
-        const discovery = await registerGibsonTools(server, gibson.session);
-        log(discovery.note ? `[zerocool-claude] Gibson tool discovery: ${discovery.note}` : `[zerocool-claude] ${discovery.discovered} Gibson tool(s) registered`);
-    }
-    catch (e) {
-        // Discovery is a convenience. The generic gibson_call_tool is registered
-        // before discovery runs, so a failure here costs the per-tool wrappers only.
-        log(`[zerocool-claude] Gibson tool discovery failed: ${e.message}`);
-    }
-    const dir = stateDir(env);
-    if (gibson.knowledge) {
-        const block = await ambientBlock(gibson.knowledge, env.ZEROCOOL_AMBIENT_QUERY ?? "memories, prior findings and security facts for this codebase");
-        if (block)
-            await writeAmbient(dir, cwd, block).catch((e) => log(`[zerocool-claude] ambient handoff failed: ${e.message}`));
-    }
-    if (gibson.live) {
-        const live = gibson.live;
-        await writeLive(dir, cwd, {
-            missionId: live.missionId,
-            workId: live.workId,
-            endpoint: live.harness.endpoint,
-            token: live.harness.token(),
-            insecure: gibson.settings.callbackInsecure,
-            writtenAt: Date.now(),
-        }).catch((e) => log(`[zerocool-claude] live handoff failed: ${e.message}`));
-    }
-}
-/** gibson_login and gibson_connect: the in-session path to a platform. */
-function registerConnectTools(server, surface, env, cwd, deps) {
-    const cli = (s) => ({ ...deps.cli, env, gibsonURL: s.platformURL, tenant: s.tenant });
-    server.registerTool("gibson_login", {
-        description: "Sign in to a Gibson platform as the person running this session. Starts the gibson CLI device " +
-            "flow and returns a URL and a code. The person opens the URL, confirms the code, and then calls " +
-            "gibson_connect. Needed once per host, and again when the login session expires.",
-        inputSchema: {
-            platform_url: z.string().optional().describe("Platform URL, e.g. https://api.example.com. Defaults to the last one used."),
-        },
-    }, async (args) => {
-        const s = surface.current().settings;
-        try {
-            const p = await startLogin({ ...deps.cli, env, gibsonURL: args.platform_url ?? s.platformURL });
-            return text("sign in", `Open ${p.url} and confirm the code ${p.code}. The CLI waits for the approval. When it is approved, call gibson_connect.`);
-        }
-        catch (e) {
-            return failure("gibson_login failed", e.message);
-        }
-    });
-    server.registerTool("gibson_connect", {
-        description: "Connect this session to a Gibson platform without a restart: enroll this host through the gibson " +
-            "CLI login session if needed, check in, pick the target, start the live mission, and add the " +
-            "platform tools (remember, recall, world_view, Gibson tools, delegation). The settings are kept, " +
-            "so later sessions connect on their own. Call gibson_status afterwards.",
-        inputSchema: {
-            platform_url: z.string().optional().describe("Platform URL. Defaults to the gibson CLI login session or the saved config."),
-            target_id: z.string().optional().describe("Target id for the live mission. Defaults to the only target in the tenant."),
-            create_target: z.string().optional().describe("Create a target with this name when none exists, and use it."),
-            target_url: z.string().optional().describe("URL of the target to create. Defaults to the workspace's git origin, or file://<cwd>."),
-            bootstrap_token: z.string().optional().describe("One-time enrollment token. Only when the CLI cannot mint one."),
-            ca_cert_path: z.string().optional().describe("Path to a private CA to trust. Defaults to the CLI session's CA."),
-            callback_insecure: z.boolean().optional().describe("Dial the callback endpoint without TLS. Local daemons only."),
-        },
-    }, async (args) => {
-        const base = await loadSettings(env);
-        const s = {
-            ...base,
-            platformURL: args.platform_url ?? base.platformURL,
-            targetId: args.target_id ?? base.targetId,
-            caCertPath: args.ca_cert_path ?? base.caCertPath,
-            callbackInsecure: args.callback_insecure ?? base.callbackInsecure,
-            bootstrapToken: args.bootstrap_token ?? base.bootstrapToken,
-        };
-        if (!s.platformURL) {
-            return failure("no platform", "Pass platform_url, or call gibson_login first so the CLI session names the platform.");
-        }
-        const hostKeyExists = (deps.open?.hostKeyExists ?? existsSync)(s.hostKeyPath);
-        try {
-            if (!hostKeyExists && !s.bootstrapToken) {
-                s.bootstrapToken = await enrollIdentity(s.agentName, cli(s));
-            }
-            if (!s.targetId) {
-                if (args.create_target) {
-                    s.targetId = await createTarget(args.create_target, args.target_url ?? (await workspaceURL(cwd)), cli(s));
-                }
-                else {
-                    const targets = await listTargets(cli(s));
-                    if (targets.length === 1)
-                        s.targetId = targets[0].id;
-                    else if (targets.length === 0) {
-                        return failure("no target", "The tenant has no target. Call gibson_connect again with create_target set to a name for this workspace.");
-                    }
-                    else {
-                        return failure("choose a target", `The tenant has ${targets.length} targets. Call gibson_connect again with target_id:\n${targets.map((t) => `- ${t.id}  ${t.name} (${t.type}, ${t.status})`).join("\n")}`);
-                    }
-                }
-            }
-        }
-        catch (e) {
-            return failure("gibson_connect failed", e.message);
-        }
-        await writeConfig(env, {
-            platformURL: s.platformURL,
-            targetId: s.targetId,
-            ...(s.caCertPath ? { caCertPath: s.caCertPath } : {}),
-            ...(s.daemonURL ? { daemonURL: s.daemonURL } : {}),
-            callbackInsecure: s.callbackInsecure,
-        });
-        const previous = surface.current();
-        await previous.close().catch(() => { });
-        const next = await openGibson({ settings: s, log, env, ...deps.open });
-        await surface.upgrade(next);
-        const body = describeGibson(next);
-        return next.mode === "live" ? text("connected", body) : failure("connected, but not live", body);
-    });
-}
-/** What a coding workspace is, as a URL: its git origin, else the directory. */
-export async function workspaceURL(cwd) {
-    try {
-        const { stdout } = await promisify(execFile)("git", ["-C", cwd, "remote", "get-url", "origin"]);
-        const remote = stdout.trim();
-        if (remote)
-            return remote;
-    }
-    catch {
-        // not a git checkout, or no origin
-    }
-    return `file://${cwd}`;
-}

package/dist/claude-run.d.ts

@@ -1,46 +0,0 @@
-/**
- * Run Claude Code headless and read what it reports.
- *
- * `claude -p --output-format stream-json --verbose` writes one JSON event per
- * line: a `system/init` first (tools, MCP servers, plugin errors), then
- * `assistant` and `user` messages, and a final `result` with the text, the
- * cost estimate, the turn count and the session id. The API key comes from
- * `ANTHROPIC_API_KEY` in the environment: headless mode never reads a
- * subscription login (code.claude.com/docs/en/headless).
- */
-export interface ClaudeRunOptions {
-    goal: string;
-    cwd: string;
-    model?: string;
-    maxTurns?: number;
-    maxBudgetUsd?: number;
-    appendSystemPrompt?: string;
-    /** MCP servers as `--mcp-config` JSON. */
-    mcpServers?: Record<string, {
-        command: string;
-        args?: string[];
-        env?: Record<string, string>;
-    }>;
-    /** Tool patterns that run without a prompt, e.g. "mcp__gibson__*". */
-    allowedTools?: string[];
-    timeoutMs?: number;
-    env?: NodeJS.ProcessEnv;
-    bin?: string;
-    onEvent?: (line: string) => void;
-}
-export interface ClaudeRunResult {
-    text: string;
-    sessionId: string;
-    isError: boolean;
-    numTurns: number;
-    costUsd: number;
-    /** MCP servers the session refused or failed to start, from system/init. */
-    mcpServerErrors: string[];
-    events: number;
-}
-/** Build the argv for one headless run. */
-export declare function claudeArgs(opts: ClaudeRunOptions): string[];
-/** Parse the NDJSON stream into the run result. */
-export declare function parseClaudeEvents(stdout: string): ClaudeRunResult;
-/** Spawn claude and collect its stream. Rejects on a non-zero exit or timeout. */
-export declare function runClaude(opts: ClaudeRunOptions): Promise<ClaudeRunResult>;

package/dist/claude-run.js

@@ -1,118 +0,0 @@
-import { spawn } from "node:child_process";
-/** Build the argv for one headless run. */
-export function claudeArgs(opts) {
-    const args = ["-p", opts.goal, "--output-format", "stream-json", "--verbose", "--no-session-persistence"];
-    // The sandbox is the permission boundary (gibson ADR-0016). Claude Code
-    // refuses this mode as root, so the image runs as an unprivileged user.
-    args.push("--permission-mode", "bypassPermissions");
-    if (opts.model)
-        args.push("--model", opts.model);
-    if (opts.maxTurns)
-        args.push("--max-turns", String(opts.maxTurns));
-    if (opts.maxBudgetUsd)
-        args.push("--max-budget-usd", String(opts.maxBudgetUsd));
-    if (opts.appendSystemPrompt)
-        args.push("--append-system-prompt", opts.appendSystemPrompt);
-    if (opts.mcpServers && Object.keys(opts.mcpServers).length > 0) {
-        args.push("--mcp-config", JSON.stringify({ mcpServers: opts.mcpServers }), "--strict-mcp-config");
-    }
-    if (opts.allowedTools && opts.allowedTools.length > 0)
-        args.push("--allowedTools", opts.allowedTools.join(","));
-    return args;
-}
-/** Parse the NDJSON stream into the run result. */
-export function parseClaudeEvents(stdout) {
-    const out = { text: "", sessionId: "", isError: false, numTurns: 0, costUsd: 0, mcpServerErrors: [], events: 0 };
-    const chunks = [];
-    let sawResult = false;
-    for (const line of stdout.split("\n")) {
-        const trimmed = line.trim();
-        if (!trimmed)
-            continue;
-        let ev;
-        try {
-            ev = JSON.parse(trimmed);
-        }
-        catch {
-            continue; // a stray log line, not an event
-        }
-        out.events += 1;
-        if (ev.session_id)
-            out.sessionId = ev.session_id;
-        if (ev.type === "system" && ev.subtype === "init") {
-            for (const e of ev.mcp_server_errors ?? [])
-                out.mcpServerErrors.push(`${e.name ?? "?"}: ${e.type ?? ""} ${e.message ?? ""}`.trim());
-            for (const s of ev.mcp_servers ?? [])
-                if (s.status && s.status !== "connected")
-                    out.mcpServerErrors.push(`${s.name ?? "?"}: ${s.status}`);
-        }
-        else if (ev.type === "assistant") {
-            for (const c of ev.message?.content ?? [])
-                if (c.type === "text" && c.text)
-                    chunks.push(c.text);
-        }
-        else if (ev.type === "result") {
-            sawResult = true;
-            out.isError = !!ev.is_error;
-            out.numTurns = ev.num_turns ?? 0;
-            out.costUsd = ev.total_cost_usd ?? 0;
-            if (typeof ev.result === "string" && ev.result)
-                out.text = ev.result;
-        }
-    }
-    if (!out.text)
-        out.text = chunks.join("");
-    if (!sawResult && out.events > 0)
-        out.isError = true;
-    return out;
-}
-/** Spawn claude and collect its stream. Rejects on a non-zero exit or timeout. */
-export async function runClaude(opts) {
-    const bin = opts.bin ?? opts.env?.ZEROCOOL_CLAUDE_BIN ?? process.env.ZEROCOOL_CLAUDE_BIN ?? "claude";
-    const args = claudeArgs(opts);
-    return await new Promise((resolve, reject) => {
-        const child = spawn(bin, args, { cwd: opts.cwd, env: { ...process.env, ...opts.env }, stdio: ["ignore", "pipe", "pipe"] });
-        const out = [];
-        const err = [];
-        let buf = "";
-        let timer;
-        if (opts.timeoutMs && opts.timeoutMs > 0) {
-            timer = setTimeout(() => {
-                child.kill("SIGTERM");
-                reject(new Error(`claude run timed out after ${opts.timeoutMs}ms`));
-            }, opts.timeoutMs);
-        }
-        child.stdout.on("data", (d) => {
-            const s = d.toString();
-            out.push(s);
-            if (opts.onEvent) {
-                buf += s;
-                let i;
-                while ((i = buf.indexOf("\n")) >= 0) {
-                    const line = buf.slice(0, i);
-                    buf = buf.slice(i + 1);
-                    if (line.trim())
-                        opts.onEvent(line);
-                }
-            }
-        });
-        child.stderr.on("data", (d) => err.push(d.toString()));
-        child.on("error", (e) => {
-            if (timer)
-                clearTimeout(timer);
-            reject(new Error(`cannot run ${bin}: ${e.message}`));
-        });
-        child.on("exit", (code) => {
-            if (timer)
-                clearTimeout(timer);
-            if (buf.trim() && opts.onEvent)
-                opts.onEvent(buf);
-            const result = parseClaudeEvents(out.join(""));
-            if (code !== 0) {
-                reject(new Error(`claude exited ${code}: ${(err.join("").trim() || result.text || "no output").slice(0, 2000)}`));
-                return;
-            }
-            resolve(result);
-        });
-    });
-}