zidane 4.1.4 → 4.1.6

package/dist/skills.d.ts

@@ -1,3 +1,3 @@
-import { C as SkillsConfig, S as SkillSource, a as ActivationVia, b as SkillDiagnostic, c as SkillActivationState, l as SkillActivationStateOptions, o as ActiveSkill, s as DeactivationReason, u as createSkillActivationState, x as SkillResource, y as SkillConfig } from "./agent-BoV5Twdl.js";
-import { S as installAllowedToolsGate, _ as inferSource, a as SkillValidationResult, b as buildCatalog, c as parseAllowedToolPattern, d as validateSkillName, f as resolveSkills, g as getDefaultScanPaths, h as discoverSkills, i as SkillValidationIssue, l as validateResourcePath, m as SourcedScanPath, n as writeSkillToDisk, o as isToolAllowedByUnion, p as interpolateShellCommands, r as writeSkillsToDisk, s as matchesAllowedTool, t as defineSkill, u as validateSkillForWrite, v as parseFrontmatter, x as IMPLICITLY_ALLOWED_SKILL_TOOLS, y as parseSkillFile } from "./index-DPsd0qwm.js";
+import { C as SkillsConfig, S as SkillSource, a as ActivationVia, b as SkillDiagnostic, c as SkillActivationState, l as SkillActivationStateOptions, o as ActiveSkill, s as DeactivationReason, u as createSkillActivationState, x as SkillResource, y as SkillConfig } from "./agent-BAoqUvwA.js";
+import { S as installAllowedToolsGate, _ as inferSource, a as SkillValidationResult, b as buildCatalog, c as parseAllowedToolPattern, d as validateSkillName, f as resolveSkills, g as getDefaultScanPaths, h as discoverSkills, i as SkillValidationIssue, l as validateResourcePath, m as SourcedScanPath, n as writeSkillToDisk, o as isToolAllowedByUnion, p as interpolateShellCommands, r as writeSkillsToDisk, s as matchesAllowedTool, t as defineSkill, u as validateSkillForWrite, v as parseFrontmatter, x as IMPLICITLY_ALLOWED_SKILL_TOOLS, y as parseSkillFile } from "./index-CqpNqjDy.js";
 export { ActivationVia, ActiveSkill, DeactivationReason, IMPLICITLY_ALLOWED_SKILL_TOOLS, SkillActivationState, SkillActivationStateOptions, SkillConfig, SkillDiagnostic, SkillResource, SkillSource, SkillValidationIssue, SkillValidationResult, SkillsConfig, SourcedScanPath, buildCatalog, createSkillActivationState, defineSkill, discoverSkills, getDefaultScanPaths, inferSource, installAllowedToolsGate, interpolateShellCommands, isToolAllowedByUnion, matchesAllowedTool, parseAllowedToolPattern, parseFrontmatter, parseSkillFile, resolveSkills, validateResourcePath, validateSkillForWrite, validateSkillName, writeSkillToDisk, writeSkillsToDisk };

package/dist/{stats-DoKUtF5T.js → stats-BT9l57RS.js}

@@ -1,4 +1,36 @@
 //#region src/stats.ts
+function normalize(stats) {
+	return {
+		input: stats.totalIn ?? 0,
+		output: stats.totalOut ?? 0,
+		cacheRead: stats.totalCacheRead ?? 0,
+		cacheCreation: stats.totalCacheCreation ?? 0
+	};
+}
+/**
+* Render a one-line token summary suitable for spawn-end markers, child
+* tool-result text, and any other per-run "what did this cost?" surface.
+*
+*   `in 52413 (cache 50000) / 4075 out`
+*
+* The `in` total includes cached reads and cache-creation tokens (see
+* {@link effectiveInputTokens}); the `(cache N)` parenthetical breaks out
+* the cached portion so the user can tell at a glance how much was reused
+* vs new. The parenthetical is omitted when its value is zero, so
+* non-caching providers and brand-new runs read simply as `in N / M out`.
+*
+* Output-side caching is not a concept any current provider exposes —
+* Anthropic's `cacheRead` / `cacheCreation` are both input-billed. If a
+* future provider ships an output cache, extend `TokenUsageLike` with
+* output-cache fields and add a parallel `(cache N)` slot on the `out`
+* side here; today the right side is always plain `${N} out`.
+*/
+function formatTokenUsage(stats) {
+	const { input, output, cacheRead, cacheCreation } = normalize(stats);
+	const inputTotal = input + cacheRead + cacheCreation;
+	const inputCache = cacheRead + cacheCreation;
+	return `${inputCache > 0 ? `in ${inputTotal} (cache ${inputCache})` : `in ${inputTotal}`} / ${output} out`;
+}
 /**
 * Depth-first walk over the stats tree, returning every `TurnUsage` entry
 * — parent loop first, then each child subtree in completion order.
@@ -53,6 +85,6 @@ function statsByModel(stats) {
 	return out;
 }
 //#endregion
-export { statsByModel as n, flattenTurns as t };
+export { formatTokenUsage as n, statsByModel as r, flattenTurns as t };
 
-//# sourceMappingURL=stats-DoKUtF5T.js.map
+//# sourceMappingURL=stats-BT9l57RS.js.map

package/dist/stats-BT9l57RS.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"stats-BT9l57RS.js","names":[],"sources":["../src/stats.ts"],"sourcesContent":["/**\n * Pure derivations over `AgentStats`.\n *\n * Both helpers are tree-shakeable — import only what you need. They never\n * touch agent state, never do I/O, and always operate on the recursive\n * `AgentStats` tree returned by `agent.run()`.\n */\n\nimport type { AgentStats, TurnUsage } from './types'\n\n/**\n * Per-model usage rollup produced by {@link statsByModel}.\n *\n * `turns` counts the number of `TurnUsage` entries attributed to the model\n * across the whole tree (parent loop + every recursively-spawned child).\n * Cache and cost numbers are summed from the same set of turns.\n */\nexport interface ModelUsage {\n  input: number\n  output: number\n  cost: number\n  cacheRead: number\n  cacheCreation: number\n  turns: number\n}\n\n/**\n * Common shape for token-usage helpers. Mirrors `AgentStats`'s cumulative\n * fields. Callers working with `TurnUsage` / `SessionRun.totalUsage`\n * (`input` / `output` / `cacheRead` / `cacheCreation`) map their fields in\n * at the call site — we don't accept both shapes here because\n * `AgentStats.output` is a structured-output payload (`Record<string,\n * unknown>`), not a token count, so the field name `output` is ambiguous.\n */\nexport interface TokenUsageLike {\n  totalIn?: number\n  totalOut?: number\n  totalCacheRead?: number\n  totalCacheCreation?: number\n}\n\nfunction normalize(stats: TokenUsageLike): {\n  input: number\n  output: number\n  cacheRead: number\n  cacheCreation: number\n} {\n  return {\n    input: stats.totalIn ?? 0,\n    output: stats.totalOut ?? 0,\n    cacheRead: stats.totalCacheRead ?? 0,\n    cacheCreation: stats.totalCacheCreation ?? 0,\n  }\n}\n\n/**\n * Sum of `input + cacheRead + cacheCreation` — i.e. the number of tokens the\n * model actually saw, regardless of how they were billed.\n *\n * With provider prompt caching (Anthropic, OpenRouter→Anthropic, Gemini),\n * `AgentStats.totalIn` only counts **new uncached** tokens per turn; the\n * bulk of an N-turn run's context lives in `totalCacheRead`, plus a smaller\n * `totalCacheCreation` chunk for whichever turns added new breakpoints.\n * Showing only `totalIn` in a per-run summary makes long subagent runs look\n * suspiciously cheap (e.g. \"13 in\" for 8 turns over a large repo).\n *\n * `TurnUsage` / `SessionRun.totalUsage` callers map their fields to the\n * `total*` names at the call site (see {@link TokenUsageLike}).\n */\nexport function effectiveInputTokens(stats: TokenUsageLike): number {\n  const { input, cacheRead, cacheCreation } = normalize(stats)\n  return input + cacheRead + cacheCreation\n}\n\n/**\n * Render a one-line token summary suitable for spawn-end markers, child\n * tool-result text, and any other per-run \"what did this cost?\" surface.\n *\n *   `in 52413 (cache 50000) / 4075 out`\n *\n * The `in` total includes cached reads and cache-creation tokens (see\n * {@link effectiveInputTokens}); the `(cache N)` parenthetical breaks out\n * the cached portion so the user can tell at a glance how much was reused\n * vs new. The parenthetical is omitted when its value is zero, so\n * non-caching providers and brand-new runs read simply as `in N / M out`.\n *\n * Output-side caching is not a concept any current provider exposes —\n * Anthropic's `cacheRead` / `cacheCreation` are both input-billed. If a\n * future provider ships an output cache, extend `TokenUsageLike` with\n * output-cache fields and add a parallel `(cache N)` slot on the `out`\n * side here; today the right side is always plain `${N} out`.\n */\nexport function formatTokenUsage(stats: TokenUsageLike): string {\n  const { input, output, cacheRead, cacheCreation } = normalize(stats)\n  const inputTotal = input + cacheRead + cacheCreation\n  const inputCache = cacheRead + cacheCreation\n  const inPart = inputCache > 0\n    ? `in ${inputTotal} (cache ${inputCache})`\n    : `in ${inputTotal}`\n  return `${inPart} / ${output} out`\n}\n\n/**\n * Depth-first walk over the stats tree, returning every `TurnUsage` entry\n * — parent loop first, then each child subtree in completion order.\n *\n * Closes the cache-token aggregation gap: `TurnUsage.cacheRead` /\n * `cacheCreation` live only on per-turn entries, and the top-level\n * `AgentStats` deliberately doesn't carry cumulative forms (one source of\n * truth, no risk of drift). Anything that needs a tree-wide sum walks\n * through this.\n */\nexport function flattenTurns(stats: AgentStats): TurnUsage[] {\n  const out: TurnUsage[] = []\n  collectTurns(stats, out)\n  return out\n}\n\nfunction collectTurns(stats: AgentStats, out: TurnUsage[]): void {\n  if (stats.turnUsage)\n    out.push(...stats.turnUsage)\n  if (stats.children) {\n    for (const child of stats.children)\n      collectTurns(child.stats, out)\n  }\n}\n\n/**\n * Group cumulative usage by `TurnUsage.modelId`. Each entry sums the input,\n * output, cache, cost, and turn-count across every turn the tree attributed\n * to that model — naturally handling cross-model runs (vision-fallback,\n * model-shifted subagents, mixed-provider workflows).\n *\n * Turns missing `modelId` (mock providers, providers that don't echo a model\n * id) are bucketed under the literal string `'(unknown)'`.\n */\nexport function statsByModel(stats: AgentStats): Map<string, ModelUsage> {\n  const out = new Map<string, ModelUsage>()\n  for (const turn of flattenTurns(stats)) {\n    const key = turn.modelId ?? '(unknown)'\n    let entry = out.get(key)\n    if (!entry) {\n      entry = { input: 0, output: 0, cost: 0, cacheRead: 0, cacheCreation: 0, turns: 0 }\n      out.set(key, entry)\n    }\n    entry.input += turn.input\n    entry.output += turn.output\n    entry.cost += turn.cost ?? 0\n    entry.cacheRead += turn.cacheRead ?? 0\n    entry.cacheCreation += turn.cacheCreation ?? 0\n    entry.turns += 1\n  }\n  return out\n}\n"],"mappings":";AAyCA,SAAS,UAAU,OAKjB;CACA,OAAO;EACL,OAAO,MAAM,WAAW;EACxB,QAAQ,MAAM,YAAY;EAC1B,WAAW,MAAM,kBAAkB;EACnC,eAAe,MAAM,sBAAsB;EAC5C;;;;;;;;;;;;;;;;;;;;AAwCH,SAAgB,iBAAiB,OAA+B;CAC9D,MAAM,EAAE,OAAO,QAAQ,WAAW,kBAAkB,UAAU,MAAM;CACpE,MAAM,aAAa,QAAQ,YAAY;CACvC,MAAM,aAAa,YAAY;CAI/B,OAAO,GAHQ,aAAa,IACxB,MAAM,WAAW,UAAU,WAAW,KACtC,MAAM,aACO,KAAK,OAAO;;;;;;;;;;;;AAa/B,SAAgB,aAAa,OAAgC;CAC3D,MAAM,MAAmB,EAAE;CAC3B,aAAa,OAAO,IAAI;CACxB,OAAO;;AAGT,SAAS,aAAa,OAAmB,KAAwB;CAC/D,IAAI,MAAM,WACR,IAAI,KAAK,GAAG,MAAM,UAAU;CAC9B,IAAI,MAAM,UACR,KAAK,MAAM,SAAS,MAAM,UACxB,aAAa,MAAM,OAAO,IAAI;;;;;;;;;;;AAapC,SAAgB,aAAa,OAA4C;CACvE,MAAM,sBAAM,IAAI,KAAyB;CACzC,KAAK,MAAM,QAAQ,aAAa,MAAM,EAAE;EACtC,MAAM,MAAM,KAAK,WAAW;EAC5B,IAAI,QAAQ,IAAI,IAAI,IAAI;EACxB,IAAI,CAAC,OAAO;GACV,QAAQ;IAAE,OAAO;IAAG,QAAQ;IAAG,MAAM;IAAG,WAAW;IAAG,eAAe;IAAG,OAAO;IAAG;GAClF,IAAI,IAAI,KAAK,MAAM;;EAErB,MAAM,SAAS,KAAK;EACpB,MAAM,UAAU,KAAK;EACrB,MAAM,QAAQ,KAAK,QAAQ;EAC3B,MAAM,aAAa,KAAK,aAAa;EACrC,MAAM,iBAAiB,KAAK,iBAAiB;EAC7C,MAAM,SAAS;;CAEjB,OAAO"}

package/dist/{tools-DpeWKzP1.js → tools-C8kDot0H.js}

@@ -3,7 +3,7 @@ import { r as AgentProviderError, s as toTypedError, t as AgentAbortedError } fr
 import { t as toolOutputByteLength } from "./types-Bx_F8jet.js";
 import { t as connectMcpServers } from "./mcp-8wClKY-3.js";
 import { _ as validateResourcePath, b as createSkillActivationState, d as escapeXml, n as resolveSkills, p as installAllowedToolsGate, t as interpolateShellCommands, u as buildCatalog } from "./interpolate-CukJwP2G.js";
-import { t as flattenTurns } from "./stats-DoKUtF5T.js";
+import { n as formatTokenUsage, t as flattenTurns } from "./stats-BT9l57RS.js";
 import { createHooks } from "hookable";
 import { stat } from "node:fs/promises";
 import { resolve } from "node:path";
@@ -1135,12 +1135,18 @@ async function emitToolResult(ctx, params) {
 }
 async function executeToolsSequential(ctx, toolCalls, turnId) {
 	const results = [];
-	for (const call of toolCalls) {
-		if (ctx.signal.aborted) break;
+	for (let i = 0; i < toolCalls.length; i++) {
+		const call = toolCalls[i];
+		if (ctx.signal.aborted) {
+			for (let j = i; j < toolCalls.length; j++) results.push({
+				id: toolCalls[j].id,
+				content: "Aborted: run was cancelled"
+			});
+			return results;
+		}
 		if (ctx.steeringQueue.length > 0) {
-			const fromIdx = toolCalls.indexOf(call);
-			for (let i = fromIdx; i < toolCalls.length; i++) results.push({
-				id: toolCalls[i].id,
+			for (let j = i; j < toolCalls.length; j++) results.push({
+				id: toolCalls[j].id,
 				content: "Skipped: steering message received"
 			});
 			return results;
@@ -1752,6 +1758,8 @@ const HOOK_EVENT_SET = new Set([
 	"child:stream:text",
 	"child:stream:thinking",
 	"child:stream:end",
+	"child:tool:gate",
+	"child:mcp:tool:gate",
 	"child:tool:before",
 	"child:tool:after",
 	"child:tool:error",
@@ -2093,8 +2101,12 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 		}
 		const formattedTools = buildFormattedTools();
 		const turns = [];
-		const isResume = session && session.turns.length > 0 && (session.runs.length > 0 || !options.prompt);
-		if (isResume) turns.push(...session.turns);
+		const isResume = session && session.turns.length > 0 && (session.runs.length > 0 || !options.prompt) && !options.parentRunId;
+		if (isResume) {
+			const childRunIds = new Set(session.runs.filter((r) => (r.depth ?? 0) > 0).map((r) => r.id));
+			const resumed = childRunIds.size === 0 ? session.turns : session.turns.filter((t) => !t.runId || !childRunIds.has(t.runId));
+			turns.push(...resumed);
+		}
 		const runTurnStart = turns.length;
 		if (options.system) await hooks.callHook("system:before", { system: options.system });
 		const promptParts = canonicalizePrompt(options.prompt);
@@ -3605,6 +3617,7 @@ const BUBBLED_EVENTS = [
 	"tool:error",
 	"turn:after"
 ];
+const BUBBLED_GATE_EVENTS = ["tool:gate", "mcp:tool:gate"];
 const CHILD_EVENT_NAME = {
 	"stream:text": "child:stream:text",
 	"stream:thinking": "child:stream:thinking",
@@ -3614,6 +3627,18 @@ const CHILD_EVENT_NAME = {
 	"tool:error": "child:tool:error",
 	"turn:after": "child:turn:after"
 };
+const CHILD_GATE_EVENT_NAME = {
+	"tool:gate": "child:tool:gate",
+	"mcp:tool:gate": "child:mcp:tool:gate"
+};
+const sessionChildCounters = /* @__PURE__ */ new WeakMap();
+function reserveChildLabel(session) {
+	let counter = sessionChildCounters.get(session);
+	if (counter === void 0) counter = session.runs.filter((r) => (r.depth ?? 0) > 0).length;
+	counter += 1;
+	sessionChildCounters.set(session, counter);
+	return `child-${counter}`;
+}
 function extractText(message) {
 	if (!message || typeof message !== "object") return "";
 	const msg = message;
@@ -3656,15 +3681,21 @@ var SpawnTimeoutError = class extends Error {
 /**
 * Wire child's hooks to bubble into `parentHooks` as `child:*` events.
 *
-* Two kinds of forwarding:
+* Three kinds of forwarding:
 *
-* 1. **Originating events** (`stream:text`, `tool:before`, …) → rewrite to
-*    the matching `child:*` event, inject `{ childId, depth }` from this
-*    spawn, then fire on the parent's hook bus.
-* 2. **Re-bubbled events** (`child:stream:text`, `child:tool:before`, …)
-*    from a grandchild already carry `childId` + `depth` pointing at the
-*    originating subagent. Forward them verbatim so the top-level listener
-*    sees the correct ancestry, not the immediate parent's.
+* 1. **Originating observational events** (`stream:text`, `tool:before`, …)
+*    → rewrite to the matching `child:*` event, inject `{ childId, depth }`,
+*    fire on the parent's hook bus as a **spread copy** (so parent listeners
+*    can't accidentally mutate the child's ctx).
+* 2. **Originating gate events** (`tool:gate`, `mcp:tool:gate`) → forward
+*    the **same ctx reference**, augmented with `childId` / `depth`, so a
+*    parent listener writing `ctx.block = true` lands on the gate the
+*    child's loop is awaiting on. The bubble itself `await`s the parent's
+*    callHook so any async approval (e.g. a TUI picker) completes before
+*    the child's loop sees the decision.
+* 3. **Re-bubbled `child:*` events** from a grandchild already carry the
+*    originating `childId` + `depth`. Forward verbatim so a top-level
+*    listener sees true ancestry, not the immediate parent's.
 *
 * Returns a function that unregisters every listener registered here.
 * Called before `agent.run()` starts, torn down in a finally block — so
@@ -3684,12 +3715,30 @@ function bubbleHooks(childHooks, parentHooks, childId, depth) {
 		});
 		unregisters.push(unregister);
 	}
+	const tagOnCtx = (ctx) => {
+		ctx.childId = childId;
+		ctx.depth = depth;
+	};
+	for (const evt of BUBBLED_GATE_EVENTS) {
+		const parentEvt = CHILD_GATE_EVENT_NAME[evt];
+		const unregister = childHooks.hook(evt, async (ctx) => {
+			tagOnCtx(ctx);
+			await fire(parentEvt, ctx);
+		});
+		unregisters.push(unregister);
+	}
+	const chainHook = childHooks.hook;
 	for (const evt of BUBBLED_EVENTS) {
 		const parentEvt = CHILD_EVENT_NAME[evt];
-		const unregister = childHooks.hook(parentEvt, (ctx) => {
+		unregisters.push(chainHook(parentEvt, (ctx) => {
 			fire(parentEvt, ctx);
-		});
-		unregisters.push(unregister);
+		}));
+	}
+	for (const evt of BUBBLED_GATE_EVENTS) {
+		const parentEvt = CHILD_GATE_EVENT_NAME[evt];
+		unregisters.push(chainHook(parentEvt, async (ctx) => {
+			await fire(parentEvt, ctx);
+		}));
 	}
 	return () => {
 		for (const u of unregisters) u();
@@ -3751,7 +3800,7 @@ function createSpawnTool(options = {}) {
 			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 — skipped "${task.slice(0, 80)}"`;
-			const id = `child-${++localCounter}`;
+			const id = ctx.session ? reserveChildLabel(ctx.session) : `child-${++localCounter}`;
 			localActiveCount++;
 			const child = {
 				id,
@@ -3798,14 +3847,15 @@ function createSpawnTool(options = {}) {
 				try {
 					finalStats = await raceWithTimeout(runPromise, options.timeoutMs);
 					const treeTurns = flattenTurns(finalStats).length;
+					const usage = formatTokenUsage(finalStats);
 					if (ctx.signal.aborted) {
 						childRunStatus = "aborted";
-						result = [`[sub-agent ${id}] Aborted after ${treeTurns} turns (${finalStats.elapsed}ms)`, `Tokens: ${finalStats.totalIn} in / ${finalStats.totalOut} out`].join("\n");
+						result = [`[sub-agent ${id}] Aborted after ${treeTurns} turns (${finalStats.elapsed}ms)`, `Tokens: ${usage}`].join("\n");
 					} else {
 						const response = extractText(agent.turns.at(-1));
 						result = [
 							`[sub-agent ${id}] Completed in ${treeTurns} turns (${finalStats.elapsed}ms)`,
-							`Tokens: ${finalStats.totalIn} in / ${finalStats.totalOut} out`,
+							`Tokens: ${usage}`,
 							"",
 							response || "(no text response)"
 						].join("\n");
@@ -3938,4 +3988,4 @@ const writeFile$1 = {
 //#endregion
 export { multiEdit as a, grep as c, createAgent as d, createToolSearchTool as f, validateToolArgs as g, createSkillsReadTool as h, readFile$1 as i, glob as l, createSkillsRunScriptTool as m, createSpawnTool as n, listFiles as o, createSkillsUseTool as p, shell as r, createInteractionTool as s, writeFile$1 as t, edit as u };
 
-//# sourceMappingURL=tools-DpeWKzP1.js.map
+//# sourceMappingURL=tools-C8kDot0H.js.map