zidane 1.2.0 → 1.4.0

package/dist/{chunk-27EP7HB3.js → chunk-YCH7G7YC.js}

@@ -2,11 +2,108 @@ import {
   connectMcpServers,
   init_mcp
 } from "./chunk-26LIQARN.js";
+import {
+  buildCatalog,
+  init_catalog,
+  init_interpolate,
+  init_resolve,
+  interpolateShellCommands,
+  mergeSkillsConfig,
+  resolveSkills
+} from "./chunk-PRNQ7DXE.js";
 import {
   __esm,
-  __export
+  __export,
+  __toCommonJS
 } from "./chunk-PNKVD2UK.js";
 
+// src/tools/list-files.ts
+var listFiles;
+var init_list_files = __esm({
+  "src/tools/list-files.ts"() {
+    "use strict";
+    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) {
+        try {
+          const entries = await ctx.execution.listFiles(ctx.handle, path || ".");
+          return entries.join("\n") || "(empty directory)";
+        } catch {
+          return `Directory not found: ${path}`;
+        }
+      }
+    };
+  }
+});
+
+// src/tools/read-file.ts
+var readFile;
+var init_read_file = __esm({
+  "src/tools/read-file.ts"() {
+    "use strict";
+    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) {
+        try {
+          return await ctx.execution.readFile(ctx.handle, path);
+        } catch {
+          return `File not found: ${path}`;
+        }
+      }
+    };
+  }
+});
+
+// src/tools/shell.ts
+var shell;
+var init_shell = __esm({
+  "src/tools/shell.ts"() {
+    "use strict";
+    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) {
+        const result = await ctx.execution.exec(ctx.handle, command);
+        if (result.exitCode === 0) {
+          return result.stdout || "(no output)";
+        }
+        return `Exit code ${result.exitCode}
+${result.stdout}
+${result.stderr}`.trim();
+      }
+    };
+  }
+});
+
 // src/contexts/docker.ts
 function createDockerContext(config) {
   let counter = 0;
@@ -35,16 +132,16 @@ function createDockerContext(config) {
       const docker = await getDockerode();
       const id = `docker-${++counter}`;
       const image = overrides?.image ?? defaultImage;
-      const cwd5 = overrides?.cwd ?? defaultCwd;
+      const cwd = overrides?.cwd ?? defaultCwd;
       try {
         await docker.getImage(image).inspect();
       } catch {
-        await new Promise((resolve5, reject) => {
+        await new Promise((resolve2, reject) => {
           docker.pull(image, (err, stream) => {
             if (err)
               return reject(err);
             docker.modem.followProgress(stream, (err2) => {
-              err2 ? reject(err2) : resolve5();
+              err2 ? reject(err2) : resolve2();
             });
           });
         });
@@ -61,12 +158,12 @@ function createDockerContext(config) {
       const container = await docker.createContainer({
         Image: image,
         Cmd: ["sleep", "infinity"],
-        WorkingDir: cwd5,
+        WorkingDir: cwd,
         Env: Object.entries(env).map(([k, v]) => `${k}=${v}`),
         HostConfig: hostConfig
       });
       await container.start();
-      const handle = { id, type: "docker", cwd: cwd5 };
+      const handle = { id, type: "docker", cwd };
       containers.set(id, { handle, container, docker });
       return handle;
     },
@@ -84,12 +181,12 @@ function createDockerContext(config) {
         AttachStderr: true
       });
       const stream = await exec.start({ Detach: false });
-      return new Promise((resolve5) => {
+      return new Promise((resolve2) => {
         let stdout = "";
         const stderr = "";
         const timeout = options?.timeout ?? defaultLimits?.timeout ?? 30;
         const timer = setTimeout(() => {
-          resolve5({ stdout, stderr: `${stderr}
+          resolve2({ stdout, stderr: `${stderr}
 [timeout]`, exitCode: 124 });
         }, timeout * 1e3);
         stream.on("data", (chunk) => {
@@ -98,7 +195,7 @@ function createDockerContext(config) {
         stream.on("end", async () => {
           clearTimeout(timer);
           const inspect = await exec.inspect();
-          resolve5({ stdout, stderr, exitCode: inspect.ExitCode ?? 0 });
+          resolve2({ stdout, stderr, exitCode: inspect.ExitCode ?? 0 });
         });
       });
     },
@@ -145,7 +242,7 @@ var init_docker = __esm({
 // 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 { dirname, resolve } from "path";
 import { promisify } from "util";
 function createProcessContext(config) {
   let counter = 0;
@@ -162,17 +259,17 @@ function createProcessContext(config) {
     },
     async spawn(overrides) {
       const id = `process-${++counter}`;
-      const cwd5 = overrides?.cwd ?? defaultCwd;
-      await mkdir(cwd5, { recursive: true });
-      const handle = { id, type: "process", cwd: cwd5 };
+      const cwd = overrides?.cwd ?? defaultCwd;
+      await mkdir(cwd, { recursive: true });
+      const handle = { id, type: "process", cwd };
       handles.set(id, handle);
       return handle;
     },
     async exec(handle, command, options) {
-      const cwd5 = options?.cwd ? resolve3(handle.cwd, options.cwd) : handle.cwd;
+      const cwd = options?.cwd ? resolve(handle.cwd, options.cwd) : handle.cwd;
       try {
         const { stdout, stderr } = await execAsync(command, {
-          cwd: cwd5,
+          cwd,
           env: { ...process.env, ...defaultEnv, ...options?.env },
           timeout: (options?.timeout ?? config?.limits?.timeout ?? 30) * 1e3,
           maxBuffer: 10 * 1024 * 1024
@@ -187,15 +284,15 @@ function createProcessContext(config) {
       }
     },
     async readFile(handle, path) {
-      return readFile2(resolve3(handle.cwd, path), "utf-8");
+      return readFile2(resolve(handle.cwd, path), "utf-8");
     },
     async writeFile(handle, path, content) {
-      const fullPath = resolve3(handle.cwd, path);
+      const fullPath = resolve(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));
+      return readdir(resolve(handle.cwd, path));
     },
     async destroy(handle) {
       handles.delete(handle.id);
@@ -270,6 +367,52 @@ var init_contexts = __esm({
   }
 });
 
+// src/harnesses/basic.ts
+function getSpawn() {
+  if (!_spawn) {
+    _spawn = (init_spawn(), __toCommonJS(spawn_exports)).spawn;
+  }
+  return _spawn;
+}
+var basicTools, _spawn, spawnProxy, basic_default;
+var init_basic = __esm({
+  "src/harnesses/basic.ts"() {
+    "use strict";
+    init_harnesses();
+    init_tools();
+    basicTools = { shell, readFile, writeFile: writeFile2, listFiles };
+    spawnProxy = {
+      get spec() {
+        return getSpawn().spec;
+      },
+      execute(input, ctx) {
+        return getSpawn().execute(input, ctx);
+      }
+    };
+    basic_default = defineHarness({
+      name: "basic",
+      system: "You are a helpful assistant with access to shell, file reading, file writing, directory listing, and sub-agent spawning tools. Use them to accomplish tasks in the project directory.",
+      tools: { ...basicTools, spawn: spawnProxy }
+    });
+  }
+});
+
+// src/harnesses/index.ts
+function defineHarness(config) {
+  return config;
+}
+var noTools;
+var init_harnesses = __esm({
+  "src/harnesses/index.ts"() {
+    init_basic();
+    noTools = defineHarness({
+      name: "none",
+      system: "You are a helpful assistant.",
+      tools: {}
+    });
+  }
+});
+
 // src/tools/validation.ts
 function validateToolArgs(input, schema) {
   const required = schema.required ?? [];
@@ -287,6 +430,9 @@ var init_validation = __esm({
 });
 
 // src/loop.ts
+function turnsToMessages(turns) {
+  return turns.filter((t) => t.role !== "system").map((t) => ({ role: t.role, content: t.content }));
+}
 async function runLoop(ctx) {
   let totalIn = 0;
   let totalOut = 0;
@@ -309,14 +455,26 @@ async function runLoop(ctx) {
     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));
+      const steerUserMsg = ctx.provider.userMessage(steerMsg);
+      ctx.turns.push({
+        id: await ctx.generateTurnId(),
+        role: steerUserMsg.role,
+        content: steerUserMsg.content,
+        createdAt: Date.now()
+      });
       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));
+        const followUpMsg = ctx.provider.userMessage(followUp);
+        ctx.turns.push({
+          id: await ctx.generateTurnId(),
+          role: followUpMsg.role,
+          content: followUpMsg.content,
+          createdAt: Date.now()
+        });
         continue;
       }
       return { totalIn, totalOut, turns: turn + 1, elapsed: Date.now() - startTime, turnUsage: turnUsages };
@@ -327,37 +485,60 @@ async function runLoop(ctx) {
   return stats;
 }
 async function executeTurn(ctx, turn) {
+  const turnId = await ctx.generateTurnId();
+  const messages = turnsToMessages(ctx.turns);
   const streamOptions = {
     model: ctx.model,
     system: ctx.system,
     tools: ctx.formattedTools,
-    messages: ctx.messages,
+    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 });
+  await ctx.hooks.callHook("context:transform", { messages });
+  await ctx.hooks.callHook("turn:before", { turn, turnId, options: streamOptions });
   let currentText = "";
+  let blockIndex = 0;
   const result = await ctx.provider.stream(
     streamOptions,
     {
       onText(delta) {
         currentText += delta;
-        ctx.hooks.callHook("stream:text", { delta, text: currentText });
+        ctx.hooks.callHook("stream:text", { delta, text: currentText, turnId, blockIndex });
       }
     }
   );
   if (currentText) {
-    await ctx.hooks.callHook("stream:end", { text: currentText });
+    await ctx.hooks.callHook("stream:end", { text: currentText, turnId, blockIndex });
+    blockIndex++;
   }
-  await ctx.hooks.callHook("turn:after", { turn, usage: result.usage });
+  await ctx.hooks.callHook("turn:after", { turn, turnId, usage: result.usage });
   if (result.done) {
+    ctx.turns.push({
+      id: turnId,
+      role: "assistant",
+      content: result.assistantMessage?.content ?? [{ type: "text", text: currentText }],
+      usage: result.usage,
+      createdAt: Date.now()
+    });
     return { ended: true, usage: result.usage };
   }
-  ctx.messages.push(result.assistantMessage);
+  ctx.turns.push({
+    id: turnId,
+    role: "assistant",
+    content: result.assistantMessage.content,
+    usage: result.usage,
+    createdAt: Date.now()
+  });
   const toolResults = ctx.toolExecution === "parallel" ? await executeToolsParallel(ctx, result.toolCalls) : await executeToolsSequential(ctx, result.toolCalls);
-  ctx.messages.push(ctx.provider.toolResultsMessage(toolResults));
+  const toolResultMsg = ctx.provider.toolResultsMessage(toolResults);
+  ctx.turns.push({
+    id: await ctx.generateTurnId(),
+    role: toolResultMsg.role,
+    content: toolResultMsg.content,
+    createdAt: Date.now()
+  });
   return { ended: false, usage: result.usage };
 }
 async function executeSingleTool(ctx, call) {
@@ -412,8 +593,20 @@ async function executeToolsSequential(ctx, toolCalls) {
       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));
+      const toolResultMsg = ctx.provider.toolResultsMessage(results);
+      ctx.turns.push({
+        id: await ctx.generateTurnId(),
+        role: toolResultMsg.role,
+        content: toolResultMsg.content,
+        createdAt: Date.now()
+      });
+      const steerUserMsg = ctx.provider.userMessage(steerMsg);
+      ctx.turns.push({
+        id: await ctx.generateTurnId(),
+        role: steerUserMsg.role,
+        content: steerUserMsg.content,
+        createdAt: Date.now()
+      });
       return [];
     }
     const { result } = await executeSingleTool(ctx, call);
@@ -435,8 +628,9 @@ var init_loop = __esm({
 
 // src/agent.ts
 import { createHooks } from "hookable";
-function createAgent({ harness, provider, toolExecution = "sequential", execution, mcpServers, session, _mcpConnector }) {
+function createAgent({ harness: harnessOption, provider, toolExecution = "sequential", enableTools = true, execution, mcpServers, session, skills: agentSkills, _mcpConnector }) {
   const hooks = createHooks();
+  const harness = harnessOption ?? noTools;
   const executionContext = execution ?? createProcessContext();
   let abortController;
   let running = false;
@@ -447,8 +641,13 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
   const allMcpServers = [...harness.mcpServers ?? [], ...mcpServers ?? []];
   const steeringQueue = [];
   const followUpQueue = [];
-  let conversationMessages = session?.messages ?? [];
-  let runCounter = 0;
+  let conversationTurns = session?.turns.slice() ?? [];
+  let runCounter = session?.runs.length ?? 0;
+  const mergedSkillsConfig = mergeSkillsConfig(harness.skills, agentSkills);
+  const skillsEnabledValue = mergedSkillsConfig?.enabled;
+  const skillsDisabled = skillsEnabledValue === false || Array.isArray(skillsEnabledValue) && skillsEnabledValue.length === 0;
+  let resolvedSkills = null;
+  let skillsCatalog = null;
   async function run(options) {
     if (running) {
       throw new Error("Agent is already running. Use steer() or followUp() to queue messages, or waitForIdle().");
@@ -457,8 +656,10 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
     abortController = new AbortController();
     const runId = `run_${++runCounter}`;
     session?.startRun(runId, options.prompt);
-    if (session)
+    if (session) {
+      await session.updateStatus("running");
       await hooks.callHook("session:start", { sessionId: session.id, runId, prompt: options.prompt });
+    }
     if (options.signal) {
       if (options.signal.aborted) {
         abortController.abort();
@@ -467,8 +668,8 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
         options.signal.addEventListener("abort", onExternalAbort, { once: true });
       }
     }
-    idlePromise = new Promise((resolve5) => {
-      idleResolve = resolve5;
+    idlePromise = new Promise((resolve2) => {
+      idleResolve = resolve2;
     });
     const childrenStats = [];
     const unregisterSpawnHook = hooks.hook("spawn:complete", (ctx) => {
@@ -484,10 +685,52 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
         mcpConnection = await connectMcpServers(allMcpServers, void 0, hooks);
       }
     }
+    if (!skillsDisabled && mergedSkillsConfig && !resolvedSkills) {
+      resolvedSkills = await resolveSkills(mergedSkillsConfig);
+      await hooks.callHook("skills:resolve", { skills: resolvedSkills });
+      if (executionHandle) {
+        for (const skill of resolvedSkills) {
+          if (skill.instructions.includes("!`")) {
+            skill.instructions = await interpolateShellCommands(
+              skill.instructions,
+              executionContext,
+              executionHandle
+            );
+          }
+        }
+      }
+      const readToolName = mergedSkillsConfig.readToolName ?? "read_file";
+      const catalogCtx = { catalog: buildCatalog(resolvedSkills, readToolName), skills: resolvedSkills };
+      await hooks.callHook("skills:catalog", catalogCtx);
+      skillsCatalog = catalogCtx.catalog;
+      const fsSkills = resolvedSkills.filter((s) => s.location);
+      if (fsSkills.length > 0) {
+        const skillByLocation = new Map(fsSkills.map((s) => [s.location, s]));
+        hooks.hook("tool:after", (ctx) => {
+          if (ctx.name !== readToolName)
+            return;
+          const path = ctx.input.path;
+          if (!path)
+            return;
+          const matched = skillByLocation.get(path) ?? fsSkills.find((s) => s.location.endsWith(path));
+          if (matched)
+            hooks.callHook("skills:activate", { skill: matched });
+        });
+      }
+    }
     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;
+    let system = options.system || harness.system || "You are a helpful assistant.";
+    if (skillsCatalog) {
+      system = `${system}
+
+${skillsCatalog}`;
+    }
+    const harnessTools = enableTools ? mcpConnection ? { ...harness.tools, ...mcpConnection.tools } : harness.tools : {};
+    const tools = {};
+    for (const tool of Object.values(harnessTools)) {
+      tools[tool.spec.name] = tool;
+    }
     const toolSpecs = Object.values(tools).map(
       (t) => ({
         name: t.spec.name,
@@ -495,19 +738,45 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
         input_schema: t.spec.input_schema
       })
     );
-    const formattedTools = provider.formatTools(toolSpecs);
-    const messages = [];
+    const formattedTools = enableTools ? provider.formatTools(toolSpecs) : [];
+    const turns = [];
+    const isResume = session && session.turns.length > 0 && session.runs.length > 0;
+    if (isResume) {
+      turns.push(...session.turns);
+    }
     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."));
+      const systemUserMsg = provider.userMessage(options.system);
+      turns.push({
+        id: crypto.randomUUID(),
+        role: systemUserMsg.role,
+        content: systemUserMsg.content,
+        createdAt: Date.now()
+      });
+      const systemAckMsg = provider.assistantMessage("Understood. I will proceed with these instructions above the rest of my system prompt.");
+      turns.push({
+        id: crypto.randomUUID(),
+        role: systemAckMsg.role,
+        content: systemAckMsg.content,
+        createdAt: Date.now()
+      });
     }
-    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 });
+    const promptMsg = provider.userMessage(options.prompt, options.images);
+    turns.push({
+      id: crypto.randomUUID(),
+      role: promptMsg.role,
+      content: promptMsg.content,
+      createdAt: Date.now()
+    });
+    conversationTurns = turns;
+    let lastPersistedTurnCount = isResume ? session.turns.length : 0;
+    const unregisterSessionSync = session ? hooks.hook("turn:after", async () => {
+      const newTurns = turns.slice(lastPersistedTurnCount);
+      if (newTurns.length > 0) {
+        await session.appendTurns(newTurns);
+        lastPersistedTurnCount = turns.length;
+        hooks.callHook("session:turns", { sessionId: session.id, count: turns.length });
+      }
     }) : void 0;
     try {
       const stats = await runLoop({
@@ -526,7 +795,8 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
         handle: executionHandle,
         steeringQueue,
         followUpQueue,
-        messages
+        turns,
+        generateTurnId: () => session?.generateTurnId() ?? crypto.randomUUID()
       });
       const finalStats = {
         ...stats,
@@ -534,15 +804,24 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
       };
       if (abortController.signal.aborted) {
         session?.abortRun(runId);
-        if (session)
+        if (session) {
+          const run2 = session.runs.find((r) => r.id === runId);
+          if (run2)
+            await session.updateRun(run2);
+          await session.updateStatus("idle");
           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);
+      const finalNewTurns = turns.slice(lastPersistedTurnCount);
+      if (session && finalNewTurns.length > 0) {
+        await session.appendTurns(finalNewTurns);
+        lastPersistedTurnCount = turns.length;
+      }
       session?.completeRun(runId, {
         turns: finalStats.turns,
         tokensIn: finalStats.totalIn,
@@ -550,22 +829,37 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
         turnUsage: finalStats.turnUsage,
         cost: totalCost
       });
-      if (session)
+      if (session) {
+        const run2 = session.runs.find((r) => r.id === runId);
+        if (run2)
+          await session.updateRun(run2);
+        await session.updateStatus("completed");
         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)
+        if (session) {
+          const run2 = session.runs.find((r) => r.id === runId);
+          if (run2)
+            await session.updateRun(run2);
+          await session.updateStatus("idle");
           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)
+      if (session) {
+        const run2 = session.runs.find((r) => r.id === runId);
+        if (run2)
+          await session.updateRun(run2);
+        await session.updateStatus("error");
         await hooks.callHook("session:end", { sessionId: session.id, runId, status: "error" });
+      }
       throw err;
     } finally {
       unregisterSpawnHook();
@@ -592,7 +886,7 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
     return idlePromise ?? Promise.resolve();
   }
   function reset() {
-    conversationMessages = [];
+    conversationTurns = [];
     steeringQueue.length = 0;
     followUpQueue.length = 0;
   }
@@ -630,8 +924,8 @@ function createAgent({ harness, provider, toolExecution = "sequential", executio
     get isRunning() {
       return running;
     },
-    get messages() {
-      return conversationMessages;
+    get turns() {
+      return conversationTurns;
     },
     get execution() {
       return executionContext;
@@ -649,8 +943,12 @@ var init_agent = __esm({
   "src/agent.ts"() {
     "use strict";
     init_contexts();
+    init_harnesses();
     init_loop();
     init_mcp();
+    init_catalog();
+    init_interpolate();
+    init_resolve();
   }
 });
 
@@ -660,6 +958,17 @@ __export(spawn_exports, {
   createSpawnTool: () => createSpawnTool,
   spawn: () => spawn
 });
+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 "";
+}
 function createSpawnTool(options = {}) {
   const localChildren = /* @__PURE__ */ new Map();
   let localCounter = 0;
@@ -731,7 +1040,7 @@ function createSpawnTool(options = {}) {
           task,
           stats
         });
-        const response = extractText(agent.messages.at(-1));
+        const response = extractText(agent.turns.at(-1));
         return [
           `[sub-agent ${id}] Completed in ${stats.turns} turns (${stats.elapsed}ms)`,
           `Tokens: ${stats.totalIn} in / ${stats.totalOut} out`,
@@ -749,257 +1058,71 @@ function createSpawnTool(options = {}) {
     }
   };
 }
-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 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 };
-      },
+    spawn = createSpawnTool();
+  }
+});
+
+// src/tools/write-file.ts
+var writeFile2;
+var init_write_file = __esm({
+  "src/tools/write-file.ts"() {
+    "use strict";
+    writeFile2 = {
       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.",
+        name: "write_file",
+        description: "Write content to a file. Creates parent directories if needed.",
         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."
-            }
+            path: { type: "string", description: "Relative file path" },
+            content: { type: "string", description: "File content to write" }
           },
-          required: ["task"]
+          required: ["path", "content"]
         }
       },
-      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);
-        }
+      async execute({ path, content }, ctx) {
+        await ctx.execution.writeFile(ctx.handle, path, content);
+        return `Wrote ${content.length} bytes to ${path}`;
       }
     };
   }
 });
 
-// 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}`;
+var init_tools = __esm({
+  "src/tools/index.ts"() {
+    init_list_files();
+    init_read_file();
+    init_shell();
+    init_spawn();
+    init_validation();
+    init_write_file();
   }
-};
+});
 
 export {
   createDockerContext,
   createProcessContext,
   createSandboxContext,
   init_contexts,
-  validateToolArgs,
-  createAgent,
-  init_agent,
   listFiles,
   readFile,
   shell,
-  spawn,
   createSpawnTool,
-  spawn_exports,
-  init_spawn,
-  writeFile2 as writeFile
+  spawn,
+  validateToolArgs,
+  writeFile2 as writeFile,
+  init_tools,
+  basicTools,
+  basic_default,
+  defineHarness,
+  noTools,
+  init_harnesses,
+  createAgent,
+  init_agent
 };