zidane 2.0.1 → 2.2.0

package/dist/{chunk-PASFWG7S.js → chunk-F5UBXERT.js}

@@ -3,21 +3,20 @@ import {
   createSkillActivationState,
   installAllowedToolsGate,
   interpolateShellCommands,
-  mergeSkillsConfig,
   resolveSkills,
   validateResourcePath
-} from "./chunk-BCXXXJ3G.js";
+} from "./chunk-TPXPVEH6.js";
 import {
   createProcessContext
-} from "./chunk-SZA4FKW5.js";
+} from "./chunk-2EQT4EHD.js";
 import {
   connectMcpServers
-} from "./chunk-PJUUYBKF.js";
+} from "./chunk-37GD7NL3.js";
 import {
   AgentAbortedError,
   AgentProviderError,
   toTypedError
-} from "./chunk-7JTBBZ2U.js";
+} from "./chunk-LNN5UTS2.js";
 
 // src/tools/glob.ts
 var DEFAULT_LIMIT = 1e3;
@@ -69,7 +68,8 @@ var glob = {
       const entries = ctx.execution.type === "process" ? await globInProcess(pat, ctx.handle.cwd, max) : await globViaShell(pat, ctx, max);
       return entries.length > 0 ? entries.join("\n") : "(no matches)";
     } catch (err) {
-      return `Glob error: ${err.message}`;
+      const message = err instanceof Error ? err.message : String(err);
+      return `Glob error: ${message}`;
     }
   }
 };
@@ -211,7 +211,8 @@ function createSkillsReadTool(options) {
       try {
         content = await ctx.execution.readFile(ctx.handle, validated.absolutePath);
       } catch (err) {
-        return `Error reading "${relPath}" in skill "${skillName}": ${err.message}`;
+        const message = err instanceof Error ? err.message : String(err);
+        return `Error reading "${relPath}" in skill "${skillName}": ${message}`;
       }
       if (looksBinary(content)) {
         return JSON.stringify({
@@ -289,7 +290,8 @@ function createSkillsRunScriptTool(options) {
           stderr: result.stderr
         });
       } catch (err) {
-        return `Error running script "${scriptRel}" for skill "${skillName}": ${err.message}`;
+        const message = err instanceof Error ? err.message : String(err);
+        return `Error running script "${scriptRel}" for skill "${skillName}": ${message}`;
       }
     }
   };
@@ -772,21 +774,31 @@ async function executeSingleTool(ctx, call, turnId) {
       execution: ctx.execution,
       handle: ctx.handle,
       hooks: ctx.hooks,
-      harness: ctx.harness,
+      tools: ctx.agentTools,
+      ...ctx.agentName !== void 0 ? { name: ctx.agentName } : {},
+      ...ctx.agentSystem !== void 0 ? { system: ctx.agentSystem } : {},
+      ...ctx.agentToolAliases !== void 0 ? { toolAliases: ctx.agentToolAliases } : {},
+      ...ctx.agentMcpServers !== void 0 ? { mcpServers: ctx.agentMcpServers } : {},
+      ...ctx.agentSkills !== void 0 ? { skills: ctx.agentSkills } : {},
+      ...ctx.agentBehavior !== void 0 ? { behavior: ctx.agentBehavior } : {},
       turnId,
-      callId
+      callId,
+      runId: ctx.runId,
+      ...ctx.session ? { session: ctx.session } : {},
+      ...typeof ctx.depth === "number" ? { depth: ctx.depth } : {}
     };
     output = await toolDef.execute(effectiveInput, toolCtx);
   } catch (err) {
+    const error = err instanceof Error ? err : new Error(String(err));
     await ctx.hooks.callHook("tool:error", {
       turnId,
       callId,
       name: call.name,
       displayName,
       input: effectiveInput,
-      error: err
+      error
     });
-    output = `Tool error: ${err.message}`;
+    output = `Tool error: ${error.message}`;
     isError = true;
   }
   const transformCtx = {
@@ -920,38 +932,88 @@ function buildPromptMessage(provider, parts) {
 }
 
 // src/agent.ts
-var noTools = { name: "none", system: "You are a helpful assistant.", tools: {} };
-function resolveBehavior(harnessBehavior, agentBehavior, runBehavior) {
+var HOOK_EVENT_NAMES = [
+  "system:before",
+  "turn:before",
+  "turn:after",
+  "stream:text",
+  "stream:end",
+  "stream:thinking",
+  "oauth:refresh",
+  "tool:gate",
+  "tool:before",
+  "tool:after",
+  "tool:error",
+  "tool:transform",
+  "context:transform",
+  "steer:inject",
+  "spawn:before",
+  "spawn:complete",
+  "spawn:error",
+  "child:stream:text",
+  "child:stream:thinking",
+  "child:stream:end",
+  "child:tool:before",
+  "child:tool:after",
+  "child:tool:error",
+  "child:turn:after",
+  "mcp:connect",
+  "mcp:error",
+  "mcp:close",
+  "mcp:tool:gate",
+  "mcp:tool:before",
+  "mcp:tool:after",
+  "mcp:tool:transform",
+  "mcp:tool:error",
+  "skills:resolve",
+  "skills:catalog",
+  "skills:activate",
+  "skills:deactivate",
+  "usage",
+  "output",
+  "agent:abort",
+  "agent:done",
+  "session:start",
+  "session:end",
+  "session:turns",
+  "session:meta",
+  "session:save"
+];
+var HOOK_EVENT_SET = new Set(HOOK_EVENT_NAMES);
+function isKnownHookEvent(event) {
+  return HOOK_EVENT_SET.has(event);
+}
+function resolveBehavior(agentBehavior, runBehavior) {
   return {
-    toolExecution: runBehavior?.toolExecution ?? agentBehavior?.toolExecution ?? harnessBehavior?.toolExecution ?? "parallel",
-    maxTurns: runBehavior?.maxTurns ?? agentBehavior?.maxTurns ?? harnessBehavior?.maxTurns,
-    maxTokens: runBehavior?.maxTokens ?? agentBehavior?.maxTokens ?? harnessBehavior?.maxTokens,
-    thinkingBudget: runBehavior?.thinkingBudget ?? agentBehavior?.thinkingBudget ?? harnessBehavior?.thinkingBudget,
-    schema: runBehavior?.schema ?? agentBehavior?.schema ?? harnessBehavior?.schema
+    toolExecution: runBehavior?.toolExecution ?? agentBehavior?.toolExecution ?? "parallel",
+    maxTurns: runBehavior?.maxTurns ?? agentBehavior?.maxTurns,
+    maxTokens: runBehavior?.maxTokens ?? agentBehavior?.maxTokens,
+    thinkingBudget: runBehavior?.thinkingBudget ?? agentBehavior?.thinkingBudget,
+    schema: runBehavior?.schema ?? agentBehavior?.schema
   };
 }
-function createAgent({ harness: harnessOption, provider, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, _mcpConnector }) {
+function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, _mcpConnector }) {
   const hooks = createHooks();
-  const harness = harnessOption ?? noTools;
   const executionContext = execution ?? createProcessContext();
+  const sourceTools = agentTools ?? {};
   let abortController;
   let running = false;
   let idleResolve;
   let idlePromise;
   let executionHandle = null;
   let mcpConnection = null;
-  const allMcpServers = [...harness.mcpServers ?? [], ...mcpServers ?? []];
+  const allMcpServers = mcpServers ?? [];
   const steeringQueue = [];
   const followUpQueue = [];
   let conversationTurns = session?.turns.slice() ?? [];
   let runCounter = session?.runs.length ?? 0;
-  const mergedSkillsConfig = mergeSkillsConfig(harness.skills, agentSkills);
-  const skillsEnabledValue = mergedSkillsConfig?.enabled;
+  const skillsConfig = agentSkills;
+  const skillsEnabledValue = skillsConfig?.enabled;
   const skillsDisabled = skillsEnabledValue === false || Array.isArray(skillsEnabledValue) && skillsEnabledValue.length === 0;
   let resolvedSkills = null;
   let skillsCatalog = null;
   const skillActivationState = createSkillActivationState({
-    maxActive: mergedSkillsConfig?.maxActive
+    maxActive: skillsConfig?.maxActive
   });
   async function run(options) {
     if (running) {
@@ -971,7 +1033,10 @@ function createAgent({ harness: harnessOption, provider, behavior: agentBehavior
     abortController = new AbortController();
     const runId = `run_${++runCounter}`;
     const promptLabel = typeof options.prompt === "string" ? options.prompt : Array.isArray(options.prompt) ? options.prompt.filter((p) => p.type === "text").map((p) => p.text).join("\n") : "";
-    session?.startRun(runId, promptLabel);
+    session?.startRun(runId, promptLabel, {
+      ...options.parentRunId ? { parentRunId: options.parentRunId } : {},
+      depth: typeof options.depth === "number" ? options.depth : 0
+    });
     if (session) {
       await session.updateStatus("running");
       await hooks.callHook("session:start", { sessionId: session.id, runId, prompt: promptLabel });
@@ -994,6 +1059,11 @@ function createAgent({ harness: harnessOption, provider, behavior: agentBehavior
     const perRunUnregisters = [];
     if (options.hooks) {
       for (const [event, handler] of Object.entries(options.hooks)) {
+        if (!isKnownHookEvent(event)) {
+          throw new Error(
+            `Unknown hook event "${event}" passed to run(). See AgentHooks for valid events.`
+          );
+        }
         const handlerList = Array.isArray(handler) ? handler : [handler];
         for (const fn of handlerList) {
           if (typeof fn !== "function")
@@ -1012,10 +1082,10 @@ function createAgent({ harness: harnessOption, provider, behavior: agentBehavior
         mcpConnection = await connectMcpServers(allMcpServers, void 0, hooks);
       }
     }
-    if (!skillsDisabled && mergedSkillsConfig && !resolvedSkills) {
-      resolvedSkills = await resolveSkills(mergedSkillsConfig);
+    if (!skillsDisabled && skillsConfig && !resolvedSkills) {
+      resolvedSkills = await resolveSkills(skillsConfig);
       await hooks.callHook("skills:resolve", { skills: resolvedSkills });
-      const skillsToolRegistered = mergedSkillsConfig?.tool !== false && resolvedSkills.length > 0;
+      const skillsToolRegistered = skillsConfig?.tool !== false && resolvedSkills.length > 0;
       const catalogCtx = {
         catalog: buildCatalog(resolvedSkills, { skillsToolRegistered }),
         skills: resolvedSkills
@@ -1045,17 +1115,17 @@ function createAgent({ harness: harnessOption, provider, behavior: agentBehavior
     }
     const thinking = options.thinking ?? "off";
     const model = options.model ?? provider.meta.defaultModel;
-    const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema } = resolveBehavior(harness.behavior, agentBehavior, options.behavior);
-    let system = options.system || harness.system || "You are a helpful assistant.";
+    const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema } = resolveBehavior(agentBehavior, options.behavior);
+    let system = options.system || agentSystem || "You are a helpful assistant.";
     if (skillsCatalog) {
       system = `${system}
 
 ${skillsCatalog}`;
     }
-    const baseTools = options.tools !== void 0 ? options.tools : mcpConnection ? { ...harness.tools, ...mcpConnection.tools } : harness.tools;
-    const shouldInjectSkillTools = options.tools === void 0 && !!resolvedSkills && resolvedSkills.length > 0 && mergedSkillsConfig?.tool !== false;
+    const runBaseTools = options.tools !== void 0 ? options.tools : mcpConnection ? { ...sourceTools, ...mcpConnection.tools } : sourceTools;
+    const shouldInjectSkillTools = options.tools === void 0 && !!resolvedSkills && resolvedSkills.length > 0 && skillsConfig?.tool !== false;
     const mergedWithSkills = shouldInjectSkillTools ? {
-      // Auto-injected first so harness + MCP tools can override by name.
+      // Auto-injected first so agent + MCP tools can override by name.
       skills_use: createSkillsUseTool({
         catalog: resolvedSkills,
         state: skillActivationState,
@@ -1068,15 +1138,15 @@ ${skillsCatalog}`;
       skills_run_script: createSkillsRunScriptTool({
         catalog: resolvedSkills,
         state: skillActivationState,
-        scriptTimeoutMs: mergedSkillsConfig?.scriptTimeoutMs
+        scriptTimeoutMs: skillsConfig?.scriptTimeoutMs
       }),
-      ...baseTools
-    } : baseTools;
+      ...runBaseTools
+    } : runBaseTools;
     const tools = {};
     for (const tool of Object.values(mergedWithSkills)) {
       tools[tool.spec.name] = tool;
     }
-    const aliasMaps = buildAliasMaps(harness.toolAliases, Object.keys(tools));
+    const aliasMaps = buildAliasMaps(toolAliases, Object.keys(tools));
     const toolSpecs = Object.values(tools).map(
       (t) => ({
         name: aliasMaps.aliasByCanonical.get(t.spec.name) ?? t.spec.name,
@@ -1140,11 +1210,18 @@ ${skillsCatalog}`;
     }
     const uninstallAllowedToolsGate = installAllowedToolsGate(hooks, skillActivationState);
     const runStartMs = Date.now();
+    const runDepth = typeof options.depth === "number" ? options.depth : 0;
     try {
       const stats = await runLoop({
         provider,
         hooks,
-        harness,
+        agentName,
+        agentSystem,
+        agentTools: sourceTools,
+        agentToolAliases: toolAliases,
+        agentMcpServers: mcpServers,
+        agentSkills,
+        agentBehavior,
         tools,
         formattedTools,
         aliasMaps,
@@ -1162,6 +1239,8 @@ ${skillsCatalog}`;
         generateTurnId: () => session?.generateTurnId() ?? crypto.randomUUID(),
         maxTurns,
         maxTokens,
+        ...session ? { session } : {},
+        depth: runDepth,
         thinkingBudget,
         schema,
         runStartMs
@@ -1199,7 +1278,8 @@ ${skillsCatalog}`;
         await hooks.callHook("agent:done", stats);
         return stats;
       }
-      session?.errorRun(runId, err.message);
+      const message = err instanceof Error ? err.message : String(err);
+      session?.errorRun(runId, message);
       await finalizeSession("error");
       throw err;
     } finally {
@@ -1230,12 +1310,13 @@ ${skillsCatalog}`;
   function waitForIdle() {
     return idlePromise ?? Promise.resolve();
   }
-  function reset() {
+  async function reset() {
     conversationTurns = [];
     steeringQueue.length = 0;
     followUpQueue.length = 0;
-    for (const record of skillActivationState.clear())
-      void hooks.callHook("skills:deactivate", { skill: record.skill, reason: "reset" });
+    const cleared = skillActivationState.clear();
+    for (const record of cleared)
+      await hooks.callHook("skills:deactivate", { skill: record.skill, reason: "reset" });
   }
   async function activateSkill(name) {
     if (!resolvedSkills) {
@@ -1251,7 +1332,7 @@ ${skillsCatalog}`;
     const outcome = skillActivationState.activate(skill, "explicit");
     if (outcome === "cap-reached") {
       throw new Error(
-        `Cannot activate skill "${name}" \u2014 the maxActive cap of ${mergedSkillsConfig?.maxActive} has been reached.`
+        `Cannot activate skill "${name}" \u2014 the maxActive cap of ${skillsConfig?.maxActive} has been reached.`
       );
     }
     if (outcome === "ok")
@@ -1271,10 +1352,16 @@ ${skillsCatalog}`;
     };
     session.setMeta = (key, value) => {
       originalSetMeta(key, value);
-      hooks.callHook("session:meta", { sessionId: session.id, key, value });
+      void Promise.resolve(hooks.callHook("session:meta", { sessionId: session.id, key, value })).catch((err) => {
+        console.error("[zidane] session:meta listener rejected:", err);
+      });
     };
   }
+  let destroyed = false;
   async function destroy() {
+    if (destroyed)
+      return;
+    destroyed = true;
     if (mcpConnection) {
       await mcpConnection.close();
       mcpConnection = null;
@@ -1313,11 +1400,34 @@ ${skillsCatalog}`;
     get activeSkills() {
       return skillActivationState.active();
     },
-    meta: provider.meta
+    // Expose a frozen view of provider.meta. Hosts previously could mutate
+    // the underlying provider meta (e.g. via `agent.meta.defaultModel = …`),
+    // which quietly affected every other agent sharing the same provider
+    // instance. Freezing forces callers to construct a new provider when
+    // they want to override model/capabilities.
+    meta: Object.freeze({ ...provider.meta })
   };
 }
 
 // src/tools/spawn.ts
+var BUBBLED_EVENTS = [
+  "stream:text",
+  "stream:thinking",
+  "stream:end",
+  "tool:before",
+  "tool:after",
+  "tool:error",
+  "turn:after"
+];
+var CHILD_EVENT_NAME = {
+  "stream:text": "child:stream:text",
+  "stream:thinking": "child:stream:thinking",
+  "stream:end": "child:stream:end",
+  "tool:before": "child:tool:before",
+  "tool:after": "child:tool:after",
+  "tool:error": "child:tool:error",
+  "turn:after": "child:turn:after"
+};
 function extractText(message) {
   if (!message || typeof message !== "object")
     return "";
@@ -1325,15 +1435,60 @@ function extractText(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 msg.content.filter((block) => !!block && typeof block === "object" && block.type === "text").map((block) => block.text).join("\n");
   }
   return "";
 }
+async function raceWithTimeout(task, timeoutMs) {
+  if (!timeoutMs || timeoutMs <= 0)
+    return task;
+  let timer;
+  try {
+    return await new Promise((resolve, reject) => {
+      timer = setTimeout(() => reject(new SpawnTimeoutError(timeoutMs)), timeoutMs);
+      task.then(resolve, reject);
+    });
+  } finally {
+    if (timer)
+      clearTimeout(timer);
+  }
+}
+var SpawnTimeoutError = class extends Error {
+  timeoutMs;
+  constructor(timeoutMs) {
+    super(`Child agent timed out after ${timeoutMs}ms`);
+    this.name = "SpawnTimeoutError";
+    this.timeoutMs = timeoutMs;
+  }
+};
+function bubbleHooks(childHooks, parentHooks, childId, depth) {
+  const unregisters = [];
+  const fire = parentHooks.callHook;
+  for (const evt of BUBBLED_EVENTS) {
+    const parentEvt = CHILD_EVENT_NAME[evt];
+    const unregister = childHooks.hook(evt, (ctx) => {
+      void fire(parentEvt, { ...ctx, childId, depth });
+    });
+    unregisters.push(unregister);
+  }
+  for (const evt of BUBBLED_EVENTS) {
+    const parentEvt = CHILD_EVENT_NAME[evt];
+    const unregister = childHooks.hook(parentEvt, (ctx) => {
+      void fire(parentEvt, ctx);
+    });
+    unregisters.push(unregister);
+  }
+  return () => {
+    for (const u of unregisters) u();
+  };
+}
 function createSpawnTool(options = {}) {
   const localChildren = /* @__PURE__ */ new Map();
   let localCounter = 0;
   let localActiveCount = 0;
   const maxConcurrent = options.maxConcurrent ?? 3;
+  const maxDepth = options.maxDepth ?? 3;
+  const forwardHooks = options.forwardHooks ?? true;
   const localStats = {
     totalIn: 0,
     totalOut: 0,
@@ -1368,51 +1523,128 @@ function createSpawnTool(options = {}) {
     async execute(input, ctx) {
       const task = input.task;
       const systemOverride = input.system;
+      const parentDepth = ctx.depth ?? 0;
+      const childDepth = parentDepth + 1;
+      if (childDepth > maxDepth) {
+        return `Cannot spawn: maxDepth=${maxDepth} reached (parent depth=${parentDepth}). Deepen the cap with createSpawnTool({ maxDepth }).`;
+      }
       if (localActiveCount >= maxConcurrent) {
         return `Cannot spawn: ${localActiveCount}/${maxConcurrent} sub-agents already running. Wait for one to complete.`;
       }
+      if (ctx.signal.aborted) {
+        return `[sub-agent pre-aborted] Parent signal was already aborted \u2014 skipped "${task.slice(0, 80)}"`;
+      }
       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 });
+      const child = { id, task, startedAt: Date.now(), depth: childDepth };
+      localChildren.set(id, child);
+      let destroyError;
+      let childRunStatus = "completed";
+      let finalStats;
+      let result = "";
+      let unbubble;
       try {
-        const stats = await agent.run({
+        const parentPreset = {
+          ...ctx.name !== void 0 ? { name: ctx.name } : {},
+          ...ctx.system !== void 0 ? { system: ctx.system } : {},
+          tools: ctx.tools,
+          ...ctx.toolAliases !== void 0 ? { toolAliases: ctx.toolAliases } : {},
+          ...ctx.mcpServers !== void 0 ? { mcpServers: ctx.mcpServers } : {},
+          ...ctx.skills !== void 0 ? { skills: ctx.skills } : {},
+          ...ctx.behavior !== void 0 ? { behavior: ctx.behavior } : {}
+        };
+        const agent = createAgent({
+          ...parentPreset,
+          ...options.preset,
+          provider: ctx.provider,
+          execution: ctx.execution,
+          // Share the parent's session on opt-in. Child turns get appended to
+          // the same session.turns stream with the child's runId; the child
+          // run itself is tagged with parentRunId below, via AgentRunOptions.
+          ...options.persist && ctx.session ? { session: ctx.session } : {}
+        });
+        if (forwardHooks)
+          unbubble = bubbleHooks(agent.hooks, ctx.hooks, id, childDepth);
+        options.onSpawn?.(child);
+        await ctx.hooks.callHook("spawn:before", { id, task, depth: childDepth });
+        const runPromise = agent.run({
           prompt: task,
           model: options.model,
           system: systemOverride ?? options.system,
           thinking: options.thinking,
-          signal: ctx.signal
+          signal: ctx.signal,
+          depth: childDepth,
+          ...options.persist && ctx.runId ? { parentRunId: ctx.runId } : {}
         });
-        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", {
+        try {
+          finalStats = await raceWithTimeout(runPromise, options.timeoutMs);
+          if (ctx.signal.aborted) {
+            childRunStatus = "aborted";
+            result = [
+              `[sub-agent ${id}] Aborted after ${finalStats.turns} turns (${finalStats.elapsed}ms)`,
+              `Tokens: ${finalStats.totalIn} in / ${finalStats.totalOut} out`
+            ].join("\n");
+          } else {
+            const response = extractText(agent.turns.at(-1));
+            result = [
+              `[sub-agent ${id}] Completed in ${finalStats.turns} turns (${finalStats.elapsed}ms)`,
+              `Tokens: ${finalStats.totalIn} in / ${finalStats.totalOut} out`,
+              "",
+              response || "(no text response)"
+            ].join("\n");
+          }
+        } catch (err) {
+          if (err instanceof SpawnTimeoutError) {
+            childRunStatus = "timeout";
+            agent.abort();
+            try {
+              finalStats = await runPromise;
+            } catch {
+              finalStats = { totalIn: 0, totalOut: 0, turns: 0, elapsed: err.timeoutMs };
+            }
+            result = `[sub-agent ${id}] Timed out after ${err.timeoutMs}ms`;
+          } else {
+            const error = err instanceof Error ? err : new Error(String(err));
+            childRunStatus = "error";
+            finalStats = { totalIn: 0, totalOut: 0, turns: 0, elapsed: 0 };
+            result = `[sub-agent ${id}] Error: ${error.message}`;
+            await ctx.hooks.callHook("spawn:error", { id, task, depth: childDepth, error });
+          }
+        } finally {
+          try {
+            await agent.destroy();
+          } catch (err) {
+            destroyError = err instanceof Error ? err : new Error(String(err));
+          }
+        }
+        if (finalStats) {
+          localStats.totalIn += finalStats.totalIn;
+          localStats.totalOut += finalStats.totalOut;
+          localStats.turns += finalStats.turns;
+          localStats.elapsed += finalStats.elapsed;
+        }
+        const childRunStats = {
           id,
           task,
-          stats
-        });
-        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`,
-          "",
-          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}`;
+          stats: finalStats,
+          depth: childDepth,
+          status: childRunStatus,
+          ...finalStats.output ? { output: finalStats.output } : {}
+        };
+        options.onComplete?.(child, finalStats, childRunStatus);
+        await ctx.hooks.callHook("spawn:complete", childRunStats);
+        if (destroyError) {
+          await ctx.hooks.callHook("spawn:error", {
+            id,
+            task,
+            depth: childDepth,
+            error: destroyError
+          });
+        }
+        return result;
       } finally {
+        unbubble?.();
         localActiveCount--;
-        await agent.destroy();
         localChildren.delete(id);
       }
     }

package/dist/{chunk-7JTBBZ2U.js → chunk-LNN5UTS2.js}

@@ -14,11 +14,18 @@ var AgentProviderError = class extends Error {
   code = "provider_error";
   provider;
   providerCode;
+  /**
+   * Whether a retry with backoff is likely to succeed. See
+   * {@link ClassifiedError.retryable}. Absent when the provider did not
+   * classify the error — callers should treat absent as "don't retry".
+   */
+  retryable;
   constructor(message, options) {
     super(message, options.cause !== void 0 ? { cause: options.cause } : void 0);
     this.name = "AgentProviderError";
     this.provider = options.provider;
     this.providerCode = options.providerCode;
+    this.retryable = options.retryable;
   }
 };
 var AgentAbortedError = class extends Error {
@@ -74,6 +81,7 @@ function toTypedError(classification, provider, cause) {
   return new AgentProviderError(message, {
     provider,
     providerCode: classification.providerCode,
+    retryable: classification.retryable,
     cause
   });
 }

package/dist/{chunk-VG2E6YK3.js → chunk-PMCQOMV4.js}

@@ -368,12 +368,14 @@ async function createSession(options = {}) {
     get metadata() {
       return data.metadata;
     },
-    startRun(runId, prompt) {
+    startRun(runId, prompt, extras) {
       data.runs.push({
         id: runId,
         startedAt: Date.now(),
         prompt: prompt ?? "",
-        status: "running"
+        status: "running",
+        ...extras?.parentRunId ? { parentRunId: extras.parentRunId } : {},
+        ...typeof extras?.depth === "number" ? { depth: extras.depth } : {}
       });
       touch();
     },