zidane 1.0.2 → 1.2.0

package/dist/chunk-27EP7HB3.js

@@ -0,0 +1,1005 @@
+import {
+  connectMcpServers,
+  init_mcp
+} from "./chunk-26LIQARN.js";
+import {
+  __esm,
+  __export
+} from "./chunk-PNKVD2UK.js";
+
+// src/contexts/docker.ts
+function createDockerContext(config) {
+  let counter = 0;
+  const containers = /* @__PURE__ */ new Map();
+  const defaultImage = config?.image ?? "oven/bun:latest";
+  const defaultCwd = config?.cwd ?? "/workspace";
+  const defaultEnv = config?.env;
+  const defaultLimits = config?.limits;
+  async function getDockerode() {
+    try {
+      const Dockerode = (await import("dockerode")).default;
+      return new Dockerode();
+    } catch {
+      throw new Error("dockerode is required for Docker execution context. Install it with: bun add dockerode");
+    }
+  }
+  const ctx = {
+    type: "docker",
+    capabilities: {
+      shell: true,
+      filesystem: true,
+      network: true,
+      gpu: false
+    },
+    async spawn(overrides) {
+      const docker = await getDockerode();
+      const id = `docker-${++counter}`;
+      const image = overrides?.image ?? defaultImage;
+      const cwd5 = overrides?.cwd ?? defaultCwd;
+      try {
+        await docker.getImage(image).inspect();
+      } catch {
+        await new Promise((resolve5, reject) => {
+          docker.pull(image, (err, stream) => {
+            if (err)
+              return reject(err);
+            docker.modem.followProgress(stream, (err2) => {
+              err2 ? reject(err2) : resolve5();
+            });
+          });
+        });
+      }
+      const limits = { ...defaultLimits, ...overrides?.limits };
+      const hostConfig = {};
+      if (limits?.memory) {
+        hostConfig.Memory = limits.memory * 1024 * 1024;
+      }
+      if (limits?.cpu) {
+        hostConfig.NanoCpus = Number.parseFloat(limits.cpu) * 1e9;
+      }
+      const env = { ...defaultEnv, ...overrides?.env };
+      const container = await docker.createContainer({
+        Image: image,
+        Cmd: ["sleep", "infinity"],
+        WorkingDir: cwd5,
+        Env: Object.entries(env).map(([k, v]) => `${k}=${v}`),
+        HostConfig: hostConfig
+      });
+      await container.start();
+      const handle = { id, type: "docker", cwd: cwd5 };
+      containers.set(id, { handle, container, docker });
+      return handle;
+    },
+    async exec(handle, command, options) {
+      const ref = containers.get(handle.id);
+      if (!ref)
+        throw new Error(`Container ${handle.id} not found`);
+      const execCwd = options?.cwd ?? handle.cwd;
+      const env = options?.env ? Object.entries(options.env).map(([k, v]) => `${k}=${v}`) : [];
+      const exec = await ref.container.exec({
+        Cmd: ["sh", "-c", command],
+        WorkingDir: execCwd,
+        Env: env,
+        AttachStdout: true,
+        AttachStderr: true
+      });
+      const stream = await exec.start({ Detach: false });
+      return new Promise((resolve5) => {
+        let stdout = "";
+        const stderr = "";
+        const timeout = options?.timeout ?? defaultLimits?.timeout ?? 30;
+        const timer = setTimeout(() => {
+          resolve5({ stdout, stderr: `${stderr}
+[timeout]`, exitCode: 124 });
+        }, timeout * 1e3);
+        stream.on("data", (chunk) => {
+          stdout += chunk.toString("utf-8");
+        });
+        stream.on("end", async () => {
+          clearTimeout(timer);
+          const inspect = await exec.inspect();
+          resolve5({ stdout, stderr, exitCode: inspect.ExitCode ?? 0 });
+        });
+      });
+    },
+    async readFile(handle, path) {
+      const result = await ctx.exec(handle, `cat ${JSON.stringify(path)}`);
+      if (result.exitCode !== 0)
+        throw new Error(`Failed to read file: ${result.stderr}`);
+      return result.stdout;
+    },
+    async writeFile(handle, path, content) {
+      const escaped = content.replace(SINGLE_QUOTE_RE, String.raw`'\''`);
+      const result = await ctx.exec(handle, `mkdir -p "$(dirname ${JSON.stringify(path)})" && printf '%s' '${escaped}' > ${JSON.stringify(path)}`);
+      if (result.exitCode !== 0)
+        throw new Error(`Failed to write file: ${result.stderr}`);
+    },
+    async listFiles(handle, path) {
+      const result = await ctx.exec(handle, `ls -1 ${JSON.stringify(path)}`);
+      if (result.exitCode !== 0)
+        return [];
+      return result.stdout.trim().split("\n").filter(Boolean);
+    },
+    async destroy(handle) {
+      const ref = containers.get(handle.id);
+      if (!ref)
+        return;
+      try {
+        await ref.container.stop({ t: 5 });
+        await ref.container.remove({ force: true });
+      } catch {
+      }
+      containers.delete(handle.id);
+    }
+  };
+  return ctx;
+}
+var SINGLE_QUOTE_RE;
+var init_docker = __esm({
+  "src/contexts/docker.ts"() {
+    "use strict";
+    SINGLE_QUOTE_RE = /'/g;
+  }
+});
+
+// src/contexts/process.ts
+import { exec as execCb } from "child_process";
+import { mkdir, readdir, readFile as readFile2, writeFile } from "fs/promises";
+import { dirname, resolve as resolve3 } from "path";
+import { promisify } from "util";
+function createProcessContext(config) {
+  let counter = 0;
+  const handles = /* @__PURE__ */ new Map();
+  const defaultCwd = config?.cwd ?? process.cwd();
+  const defaultEnv = config?.env;
+  return {
+    type: "process",
+    capabilities: {
+      shell: true,
+      filesystem: true,
+      network: true,
+      gpu: false
+    },
+    async spawn(overrides) {
+      const id = `process-${++counter}`;
+      const cwd5 = overrides?.cwd ?? defaultCwd;
+      await mkdir(cwd5, { recursive: true });
+      const handle = { id, type: "process", cwd: cwd5 };
+      handles.set(id, handle);
+      return handle;
+    },
+    async exec(handle, command, options) {
+      const cwd5 = options?.cwd ? resolve3(handle.cwd, options.cwd) : handle.cwd;
+      try {
+        const { stdout, stderr } = await execAsync(command, {
+          cwd: cwd5,
+          env: { ...process.env, ...defaultEnv, ...options?.env },
+          timeout: (options?.timeout ?? config?.limits?.timeout ?? 30) * 1e3,
+          maxBuffer: 10 * 1024 * 1024
+        });
+        return { stdout, stderr, exitCode: 0 };
+      } catch (err) {
+        return {
+          stdout: err.stdout ?? "",
+          stderr: err.stderr ?? err.message,
+          exitCode: err.code ?? 1
+        };
+      }
+    },
+    async readFile(handle, path) {
+      return readFile2(resolve3(handle.cwd, path), "utf-8");
+    },
+    async writeFile(handle, path, content) {
+      const fullPath = resolve3(handle.cwd, path);
+      await mkdir(dirname(fullPath), { recursive: true });
+      await writeFile(fullPath, content, "utf-8");
+    },
+    async listFiles(handle, path) {
+      return readdir(resolve3(handle.cwd, path));
+    },
+    async destroy(handle) {
+      handles.delete(handle.id);
+    }
+  };
+}
+var execAsync;
+var init_process = __esm({
+  "src/contexts/process.ts"() {
+    "use strict";
+    execAsync = promisify(execCb);
+  }
+});
+
+// src/contexts/sandbox.ts
+function createSandboxContext(provider) {
+  const sandboxes = /* @__PURE__ */ new Map();
+  function getSandboxId(handle) {
+    const id = sandboxes.get(handle.id);
+    if (!id)
+      throw new Error(`Sandbox ${handle.id} not found`);
+    return id;
+  }
+  return {
+    type: "sandbox",
+    capabilities: {
+      shell: true,
+      filesystem: true,
+      network: true,
+      gpu: false
+    },
+    async spawn(config) {
+      const result = await provider.spawn(config ?? {});
+      const handle = { id: result.id, type: "sandbox", cwd: result.cwd };
+      sandboxes.set(handle.id, result.id);
+      return handle;
+    },
+    async exec(handle, command, options) {
+      return provider.exec(getSandboxId(handle), command, options);
+    },
+    async readFile(handle, path) {
+      return provider.readFile(getSandboxId(handle), path);
+    },
+    async writeFile(handle, path, content) {
+      return provider.writeFile(getSandboxId(handle), path, content);
+    },
+    async listFiles(handle, path) {
+      return provider.listFiles(getSandboxId(handle), path);
+    },
+    async destroy(handle) {
+      const id = sandboxes.get(handle.id);
+      if (!id)
+        return;
+      await provider.destroy(id);
+      sandboxes.delete(handle.id);
+    }
+  };
+}
+var init_sandbox = __esm({
+  "src/contexts/sandbox.ts"() {
+    "use strict";
+  }
+});
+
+// src/contexts/index.ts
+var init_contexts = __esm({
+  "src/contexts/index.ts"() {
+    "use strict";
+    init_docker();
+    init_process();
+    init_sandbox();
+  }
+});
+
+// src/tools/validation.ts
+function validateToolArgs(input, schema) {
+  const required = schema.required ?? [];
+  for (const field of required) {
+    if (!(field in input) || input[field] === void 0 || input[field] === null) {
+      return { valid: false, error: `Missing required field: ${field}` };
+    }
+  }
+  return { valid: true };
+}
+var init_validation = __esm({
+  "src/tools/validation.ts"() {
+    "use strict";
+  }
+});
+
+// src/loop.ts
+async function runLoop(ctx) {
+  let totalIn = 0;
+  let totalOut = 0;
+  const turnUsages = [];
+  const startTime = Date.now();
+  const maxTurns = 50;
+  for (let turn = 0; turn < maxTurns; turn++) {
+    if (ctx.signal.aborted) {
+      await ctx.hooks.callHook("agent:abort", {});
+      break;
+    }
+    const result = await executeTurn(ctx, turn);
+    totalIn += result.usage.input;
+    totalOut += result.usage.output;
+    turnUsages.push(result.usage);
+    if (ctx.signal.aborted) {
+      await ctx.hooks.callHook("agent:abort", {});
+      break;
+    }
+    if (ctx.steeringQueue.length > 0) {
+      const steerMsg = ctx.steeringQueue.shift();
+      await ctx.hooks.callHook("steer:inject", { message: steerMsg });
+      ctx.messages.push(ctx.provider.userMessage(steerMsg));
+      continue;
+    }
+    if (result.ended) {
+      if (ctx.followUpQueue.length > 0) {
+        const followUp = ctx.followUpQueue.shift();
+        await ctx.hooks.callHook("steer:inject", { message: followUp });
+        ctx.messages.push(ctx.provider.userMessage(followUp));
+        continue;
+      }
+      return { totalIn, totalOut, turns: turn + 1, elapsed: Date.now() - startTime, turnUsage: turnUsages };
+    }
+  }
+  const stats = { totalIn, totalOut, turns: maxTurns, elapsed: Date.now() - startTime, turnUsage: turnUsages };
+  await ctx.hooks.callHook("agent:done", stats);
+  return stats;
+}
+async function executeTurn(ctx, turn) {
+  const streamOptions = {
+    model: ctx.model,
+    system: ctx.system,
+    tools: ctx.formattedTools,
+    messages: ctx.messages,
+    maxTokens: 16384,
+    thinking: ctx.thinking,
+    signal: ctx.signal
+  };
+  await ctx.hooks.callHook("context:transform", { messages: ctx.messages });
+  await ctx.hooks.callHook("turn:before", { turn, options: streamOptions });
+  let currentText = "";
+  const result = await ctx.provider.stream(
+    streamOptions,
+    {
+      onText(delta) {
+        currentText += delta;
+        ctx.hooks.callHook("stream:text", { delta, text: currentText });
+      }
+    }
+  );
+  if (currentText) {
+    await ctx.hooks.callHook("stream:end", { text: currentText });
+  }
+  await ctx.hooks.callHook("turn:after", { turn, usage: result.usage });
+  if (result.done) {
+    return { ended: true, usage: result.usage };
+  }
+  ctx.messages.push(result.assistantMessage);
+  const toolResults = ctx.toolExecution === "parallel" ? await executeToolsParallel(ctx, result.toolCalls) : await executeToolsSequential(ctx, result.toolCalls);
+  ctx.messages.push(ctx.provider.toolResultsMessage(toolResults));
+  return { ended: false, usage: result.usage };
+}
+async function executeSingleTool(ctx, call) {
+  const toolDef = ctx.tools[call.name];
+  const gateCtx = { name: call.name, input: call.input, block: false, reason: "Tool execution was blocked" };
+  await ctx.hooks.callHook("tool:gate", gateCtx);
+  if (gateCtx.block) {
+    return { result: { id: call.id, content: `Blocked: ${gateCtx.reason}` }, steered: false };
+  }
+  if (!toolDef) {
+    const err = new Error(`Unknown tool: ${call.name}`);
+    await ctx.hooks.callHook("tool:error", { name: call.name, input: call.input, error: err });
+    return { result: { id: call.id, content: `Tool error: ${err.message}` }, steered: false };
+  }
+  const validation = validateToolArgs(call.input, toolDef.spec.input_schema);
+  if (!validation.valid) {
+    return { result: { id: call.id, content: `Validation error: ${validation.error}` }, steered: false };
+  }
+  await ctx.hooks.callHook("tool:before", { name: call.name, input: call.input });
+  let output;
+  let isError = false;
+  try {
+    const toolCtx = {
+      provider: ctx.provider,
+      signal: ctx.signal,
+      execution: ctx.execution,
+      handle: ctx.handle,
+      hooks: ctx.hooks,
+      harness: ctx.harness
+    };
+    output = await toolDef.execute(call.input, toolCtx);
+  } catch (err) {
+    await ctx.hooks.callHook("tool:error", { name: call.name, input: call.input, error: err });
+    output = `Tool error: ${err.message}`;
+    isError = true;
+  }
+  const transformCtx = { name: call.name, input: call.input, result: output, isError };
+  await ctx.hooks.callHook("tool:transform", transformCtx);
+  output = transformCtx.result;
+  isError = transformCtx.isError;
+  await ctx.hooks.callHook("tool:after", { name: call.name, input: call.input, result: output });
+  return { result: { id: call.id, content: output }, steered: false };
+}
+async function executeToolsSequential(ctx, toolCalls) {
+  const results = [];
+  for (const call of toolCalls) {
+    if (ctx.signal.aborted)
+      break;
+    if (ctx.steeringQueue.length > 0) {
+      const steerMsg = ctx.steeringQueue.shift();
+      await ctx.hooks.callHook("steer:inject", { message: steerMsg });
+      for (const skipped of toolCalls.slice(toolCalls.indexOf(call))) {
+        results.push({ id: skipped.id, content: "Skipped: steering message received" });
+      }
+      ctx.messages.push(ctx.provider.toolResultsMessage(results));
+      ctx.messages.push(ctx.provider.userMessage(steerMsg));
+      return [];
+    }
+    const { result } = await executeSingleTool(ctx, call);
+    results.push(result);
+  }
+  return results;
+}
+async function executeToolsParallel(ctx, toolCalls) {
+  const executions = toolCalls.map((call) => executeSingleTool(ctx, call));
+  const settled = await Promise.all(executions);
+  return settled.map((s) => s.result);
+}
+var init_loop = __esm({
+  "src/loop.ts"() {
+    "use strict";
+    init_validation();
+  }
+});
+
+// src/agent.ts
+import { createHooks } from "hookable";
+function createAgent({ harness, provider, toolExecution = "sequential", execution, mcpServers, session, _mcpConnector }) {
+  const hooks = createHooks();
+  const executionContext = execution ?? createProcessContext();
+  let abortController;
+  let running = false;
+  let idleResolve;
+  let idlePromise;
+  let executionHandle = null;
+  let mcpConnection = null;
+  const allMcpServers = [...harness.mcpServers ?? [], ...mcpServers ?? []];
+  const steeringQueue = [];
+  const followUpQueue = [];
+  let conversationMessages = session?.messages ?? [];
+  let runCounter = 0;
+  async function run(options) {
+    if (running) {
+      throw new Error("Agent is already running. Use steer() or followUp() to queue messages, or waitForIdle().");
+    }
+    running = true;
+    abortController = new AbortController();
+    const runId = `run_${++runCounter}`;
+    session?.startRun(runId, options.prompt);
+    if (session)
+      await hooks.callHook("session:start", { sessionId: session.id, runId, prompt: options.prompt });
+    if (options.signal) {
+      if (options.signal.aborted) {
+        abortController.abort();
+      } else {
+        const onExternalAbort = () => abortController?.abort();
+        options.signal.addEventListener("abort", onExternalAbort, { once: true });
+      }
+    }
+    idlePromise = new Promise((resolve5) => {
+      idleResolve = resolve5;
+    });
+    const childrenStats = [];
+    const unregisterSpawnHook = hooks.hook("spawn:complete", (ctx) => {
+      childrenStats.push(ctx);
+    });
+    if (!executionHandle) {
+      executionHandle = await executionContext.spawn();
+    }
+    if (allMcpServers.length > 0 && !mcpConnection) {
+      if (_mcpConnector) {
+        mcpConnection = await _mcpConnector(allMcpServers);
+      } else {
+        mcpConnection = await connectMcpServers(allMcpServers, void 0, hooks);
+      }
+    }
+    const thinking = options.thinking ?? "off";
+    const model = options.model ?? provider.meta.defaultModel;
+    const system = options.system || harness.system || "You are a helpful assistant.";
+    const tools = mcpConnection ? { ...harness.tools, ...mcpConnection.tools } : harness.tools;
+    const toolSpecs = Object.values(tools).map(
+      (t) => ({
+        name: t.spec.name,
+        description: t.spec.description || "",
+        input_schema: t.spec.input_schema
+      })
+    );
+    const formattedTools = provider.formatTools(toolSpecs);
+    const messages = [];
+    if (options.system) {
+      await hooks.callHook("system:before", { system: options.system });
+      messages.push(provider.userMessage(options.system));
+      messages.push(provider.assistantMessage("Understood. I will proceed with these instructions above the rest of my system prompt."));
+    }
+    messages.push(provider.userMessage(options.prompt, options.images));
+    conversationMessages = messages;
+    session?.setMessages(messages);
+    const unregisterSessionSync = session ? hooks.hook("turn:after", () => {
+      session.setMessages(messages);
+      hooks.callHook("session:messages", { sessionId: session.id, count: messages.length });
+    }) : void 0;
+    try {
+      const stats = await runLoop({
+        provider,
+        hooks,
+        harness,
+        tools,
+        toolSpecs,
+        formattedTools,
+        model,
+        system,
+        thinking,
+        toolExecution,
+        signal: abortController.signal,
+        execution: executionContext,
+        handle: executionHandle,
+        steeringQueue,
+        followUpQueue,
+        messages
+      });
+      const finalStats = {
+        ...stats,
+        children: childrenStats.length > 0 ? childrenStats : void 0
+      };
+      if (abortController.signal.aborted) {
+        session?.abortRun(runId);
+        if (session)
+          await hooks.callHook("session:end", { sessionId: session.id, runId, status: "aborted" });
+        await hooks.callHook("agent:done", finalStats);
+        return finalStats;
+      }
+      const totalCost = finalStats.turnUsage?.reduce((sum, t) => sum + (t.cost ?? 0), 0) || void 0;
+      if (totalCost)
+        finalStats.cost = totalCost;
+      session?.setMessages(messages);
+      session?.completeRun(runId, {
+        turns: finalStats.turns,
+        tokensIn: finalStats.totalIn,
+        tokensOut: finalStats.totalOut,
+        turnUsage: finalStats.turnUsage,
+        cost: totalCost
+      });
+      if (session)
+        await hooks.callHook("session:end", { sessionId: session.id, runId, status: "completed" });
+      await hooks.callHook("agent:done", finalStats);
+      return finalStats;
+    } catch (err) {
+      if (abortController.signal.aborted) {
+        session?.abortRun(runId);
+        if (session)
+          await hooks.callHook("session:end", { sessionId: session.id, runId, status: "aborted" });
+        const stats = { totalIn: 0, totalOut: 0, turns: 0, elapsed: 0 };
+        await hooks.callHook("agent:done", stats);
+        return stats;
+      }
+      session?.errorRun(runId, err.message);
+      if (session)
+        await hooks.callHook("session:end", { sessionId: session.id, runId, status: "error" });
+      throw err;
+    } finally {
+      unregisterSpawnHook();
+      unregisterSessionSync?.();
+      running = false;
+      abortController = void 0;
+      steeringQueue.length = 0;
+      followUpQueue.length = 0;
+      idleResolve?.();
+      idlePromise = void 0;
+      idleResolve = void 0;
+    }
+  }
+  function abort() {
+    abortController?.abort();
+  }
+  function steer(message) {
+    steeringQueue.push(message);
+  }
+  function followUpFn(message) {
+    followUpQueue.push(message);
+  }
+  function waitForIdle() {
+    return idlePromise ?? Promise.resolve();
+  }
+  function reset() {
+    conversationMessages = [];
+    steeringQueue.length = 0;
+    followUpQueue.length = 0;
+  }
+  if (session) {
+    const originalSave = session.save.bind(session);
+    const originalSetMeta = session.setMeta.bind(session);
+    session.save = async () => {
+      await originalSave();
+      await hooks.callHook("session:save", { sessionId: session.id });
+    };
+    session.setMeta = (key, value) => {
+      originalSetMeta(key, value);
+      hooks.callHook("session:meta", { sessionId: session.id, key, value });
+    };
+  }
+  async function destroy() {
+    if (mcpConnection) {
+      await mcpConnection.close();
+      mcpConnection = null;
+    }
+    if (executionHandle) {
+      await executionContext.destroy(executionHandle);
+      executionHandle = null;
+    }
+  }
+  return {
+    hooks,
+    run,
+    abort,
+    steer,
+    followUp: followUpFn,
+    waitForIdle,
+    reset,
+    destroy,
+    get isRunning() {
+      return running;
+    },
+    get messages() {
+      return conversationMessages;
+    },
+    get execution() {
+      return executionContext;
+    },
+    get handle() {
+      return executionHandle;
+    },
+    get session() {
+      return session ?? null;
+    },
+    meta: provider.meta
+  };
+}
+var init_agent = __esm({
+  "src/agent.ts"() {
+    "use strict";
+    init_contexts();
+    init_loop();
+    init_mcp();
+  }
+});
+
+// src/tools/spawn.ts
+var spawn_exports = {};
+__export(spawn_exports, {
+  createSpawnTool: () => createSpawnTool,
+  spawn: () => spawn
+});
+function createSpawnTool(options = {}) {
+  const localChildren = /* @__PURE__ */ new Map();
+  let localCounter = 0;
+  let localActiveCount = 0;
+  const maxConcurrent = options.maxConcurrent ?? 3;
+  const localStats = {
+    totalIn: 0,
+    totalOut: 0,
+    turns: 0,
+    elapsed: 0
+  };
+  return {
+    get children() {
+      return localChildren;
+    },
+    get totalChildStats() {
+      return { ...localStats };
+    },
+    spec: {
+      name: "spawn",
+      description: "Spawn a sub-agent to work on a specific task. The sub-agent runs independently with its own tool access and returns its final response. Use this to delegate work, parallelize tasks, or isolate concerns.",
+      input_schema: {
+        type: "object",
+        properties: {
+          task: {
+            type: "string",
+            description: "The task prompt for the sub-agent. Be specific about what you want it to accomplish."
+          },
+          system: {
+            type: "string",
+            description: "Optional system prompt override for this specific sub-agent."
+          }
+        },
+        required: ["task"]
+      }
+    },
+    async execute(input, ctx) {
+      const task = input.task;
+      const systemOverride = input.system;
+      if (localActiveCount >= maxConcurrent) {
+        return `Cannot spawn: ${localActiveCount}/${maxConcurrent} sub-agents already running. Wait for one to complete.`;
+      }
+      const id = `child-${++localCounter}`;
+      const child = { id, task, startedAt: Date.now() };
+      const agent = createAgent({
+        harness: options.harness ?? ctx.harness,
+        provider: ctx.provider,
+        execution: ctx.execution
+      });
+      localChildren.set(id, child);
+      localActiveCount++;
+      options.onSpawn?.(child);
+      await ctx.hooks.callHook("spawn:before", { id, task });
+      try {
+        const stats = await agent.run({
+          prompt: task,
+          model: options.model,
+          system: systemOverride ?? options.system,
+          thinking: options.thinking,
+          signal: ctx.signal
+        });
+        localStats.totalIn += stats.totalIn;
+        localStats.totalOut += stats.totalOut;
+        localStats.turns += stats.turns;
+        localStats.elapsed += stats.elapsed;
+        options.onComplete?.(child, stats);
+        await ctx.hooks.callHook("spawn:complete", {
+          id,
+          task,
+          stats
+        });
+        const response = extractText(agent.messages.at(-1));
+        return [
+          `[sub-agent ${id}] Completed in ${stats.turns} turns (${stats.elapsed}ms)`,
+          `Tokens: ${stats.totalIn} in / ${stats.totalOut} out`,
+          "",
+          response || "(no text response)"
+        ].join("\n");
+      } catch (err) {
+        await ctx.hooks.callHook("spawn:error", { id, task, error: err });
+        return `[sub-agent ${id}] Error: ${err.message}`;
+      } finally {
+        localActiveCount--;
+        await agent.destroy();
+        localChildren.delete(id);
+      }
+    }
+  };
+}
+function extractText(message) {
+  if (!message || typeof message !== "object")
+    return "";
+  const msg = message;
+  if (typeof msg.content === "string")
+    return msg.content;
+  if (Array.isArray(msg.content)) {
+    return msg.content.filter((block) => block.type === "text").map((block) => block.text).join("\n");
+  }
+  return "";
+}
+var children, childCounter, activeCount, MAX_CONCURRENT, _totalChildStats, spawn;
+var init_spawn = __esm({
+  "src/tools/spawn.ts"() {
+    "use strict";
+    init_agent();
+    children = /* @__PURE__ */ new Map();
+    childCounter = 0;
+    activeCount = 0;
+    MAX_CONCURRENT = 3;
+    _totalChildStats = {
+      totalIn: 0,
+      totalOut: 0,
+      turns: 0,
+      elapsed: 0
+    };
+    spawn = {
+      get children() {
+        return children;
+      },
+      get totalChildStats() {
+        return { ..._totalChildStats };
+      },
+      spec: {
+        name: "spawn",
+        description: "Spawn a sub-agent to work on a specific task. The sub-agent runs independently with its own tool access and returns its final response. Use this to delegate work, parallelize tasks, or isolate concerns.",
+        input_schema: {
+          type: "object",
+          properties: {
+            task: {
+              type: "string",
+              description: "The task prompt for the sub-agent. Be specific about what you want it to accomplish."
+            },
+            system: {
+              type: "string",
+              description: "Optional system prompt override for this specific sub-agent."
+            }
+          },
+          required: ["task"]
+        }
+      },
+      async execute(input, ctx) {
+        const task = input.task;
+        const systemOverride = input.system;
+        if (activeCount >= MAX_CONCURRENT) {
+          return `Cannot spawn: ${activeCount}/${MAX_CONCURRENT} sub-agents already running. Wait for one to complete.`;
+        }
+        const id = `child-${++childCounter}`;
+        const child = { id, task, startedAt: Date.now() };
+        const agent = createAgent({
+          harness: ctx.harness,
+          provider: ctx.provider,
+          execution: ctx.execution
+        });
+        children.set(id, child);
+        activeCount++;
+        await ctx.hooks.callHook("spawn:before", { id, task });
+        try {
+          const stats = await agent.run({
+            prompt: task,
+            system: systemOverride,
+            signal: ctx.signal
+          });
+          _totalChildStats.totalIn += stats.totalIn;
+          _totalChildStats.totalOut += stats.totalOut;
+          _totalChildStats.turns += stats.turns;
+          _totalChildStats.elapsed += stats.elapsed;
+          await ctx.hooks.callHook("spawn:complete", {
+            id,
+            task,
+            stats
+          });
+          const response = extractText(agent.messages.at(-1));
+          return [
+            `[sub-agent ${id}] Completed in ${stats.turns} turns (${stats.elapsed}ms)`,
+            `Tokens: ${stats.totalIn} in / ${stats.totalOut} out`,
+            "",
+            response || "(no text response)"
+          ].join("\n");
+        } catch (err) {
+          await ctx.hooks.callHook("spawn:error", { id, task, error: err });
+          return `[sub-agent ${id}] Error: ${err.message}`;
+        } finally {
+          activeCount--;
+          await agent.destroy();
+          children.delete(id);
+        }
+      }
+    };
+  }
+});
+
+// src/tools/list-files.ts
+import { existsSync, readdirSync, statSync } from "fs";
+import { resolve } from "path";
+var cwd = process.cwd();
+function safePath(p) {
+  const resolved = resolve(cwd, p);
+  if (!resolved.startsWith(cwd))
+    throw new Error(`Path escapes working directory: ${p}`);
+  return resolved;
+}
+var listFiles = {
+  spec: {
+    name: "list_files",
+    description: "List files and directories at the given path (relative to project root).",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: 'Relative directory path (default: ".")' }
+      },
+      required: []
+    }
+  },
+  async execute({ path }, _ctx) {
+    const target = safePath(path || ".");
+    if (!existsSync(target))
+      return `Directory not found: ${path}`;
+    const entries = readdirSync(target);
+    return entries.map((name) => {
+      const full = resolve(target, name);
+      const isDir = statSync(full).isDirectory();
+      return `${isDir ? "\u{1F4C1}" : "\u{1F4C4}"} ${name}`;
+    }).join("\n");
+  }
+};
+
+// src/tools/read-file.ts
+import { existsSync as existsSync2, readFileSync } from "fs";
+import { resolve as resolve2 } from "path";
+var cwd2 = process.cwd();
+function safePath2(p) {
+  const resolved = resolve2(cwd2, p);
+  if (!resolved.startsWith(cwd2))
+    throw new Error(`Path escapes working directory: ${p}`);
+  return resolved;
+}
+var readFile = {
+  spec: {
+    name: "read_file",
+    description: "Read the contents of a file at the given path (relative to project root).",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative file path" }
+      },
+      required: ["path"]
+    }
+  },
+  async execute({ path }, _ctx) {
+    const target = safePath2(path);
+    if (!existsSync2(target))
+      return `File not found: ${path}`;
+    return readFileSync(target, "utf-8");
+  }
+};
+
+// src/tools/shell.ts
+import { execSync } from "child_process";
+var cwd3 = process.cwd();
+var shell = {
+  spec: {
+    name: "shell",
+    description: "Execute a shell command and return stdout+stderr. Runs in the project root.",
+    input_schema: {
+      type: "object",
+      properties: {
+        command: { type: "string", description: "The shell command to run" }
+      },
+      required: ["command"]
+    }
+  },
+  async execute({ command }, _ctx) {
+    try {
+      const out = execSync(command, {
+        cwd: cwd3,
+        encoding: "utf-8",
+        timeout: 3e4,
+        maxBuffer: 1024 * 1024,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return out || "(no output)";
+    } catch (err) {
+      const stderr = err.stderr?.toString() ?? "";
+      const stdout = err.stdout?.toString() ?? "";
+      return `Exit code ${err.status ?? 1}
+${stdout}
+${stderr}`.trim();
+    }
+  }
+};
+
+// src/tools/index.ts
+init_spawn();
+init_validation();
+
+// src/tools/write-file.ts
+import { mkdirSync, writeFileSync } from "fs";
+import { dirname as dirname2, resolve as resolve4 } from "path";
+var cwd4 = process.cwd();
+function safePath3(p) {
+  const resolved = resolve4(cwd4, p);
+  if (!resolved.startsWith(cwd4))
+    throw new Error(`Path escapes working directory: ${p}`);
+  return resolved;
+}
+var writeFile2 = {
+  spec: {
+    name: "write_file",
+    description: "Write content to a file. Creates parent directories if needed.",
+    input_schema: {
+      type: "object",
+      properties: {
+        path: { type: "string", description: "Relative file path" },
+        content: { type: "string", description: "File content to write" }
+      },
+      required: ["path", "content"]
+    }
+  },
+  async execute({ path, content }, _ctx) {
+    const target = safePath3(path);
+    mkdirSync(dirname2(target), { recursive: true });
+    writeFileSync(target, content);
+    return `Wrote ${content.length} bytes to ${path}`;
+  }
+};
+
+export {
+  createDockerContext,
+  createProcessContext,
+  createSandboxContext,
+  init_contexts,
+  validateToolArgs,
+  createAgent,
+  init_agent,
+  listFiles,
+  readFile,
+  shell,
+  spawn,
+  createSpawnTool,
+  spawn_exports,
+  init_spawn,
+  writeFile2 as writeFile
+};