zidane 4.1.8 → 5.0.0

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

@@ -1,9 +1,9 @@
 import { n as createProcessContext } from "./contexts-3Arvn7yR.js";
 import { r as AgentProviderError, s as toTypedError, t as AgentAbortedError } from "./errors-D1lhd6mX.js";
 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 { n as formatTokenUsage, t as flattenTurns } from "./stats-BT9l57RS.js";
+import { t as connectMcpServers } from "./mcp-Dw-fRPVk.js";
+import { _ as validateResourcePath, b as createSkillActivationState, d as escapeXml, n as resolveSkills, p as installAllowedToolsGate, t as interpolateShellCommands, u as buildCatalog } from "./interpolate-Ck970-61.js";
+import { n as formatTokenUsage, t as flattenTurns } from "./stats-DZIsGqzu.js";
 import { createHooks } from "hookable";
 import { stat } from "node:fs/promises";
 import { resolve } from "node:path";
@@ -892,12 +892,19 @@ async function executeTurn(ctx, turn) {
 	}
 	const toolResults = ctx.toolExecution === "parallel" ? await executeToolsParallel(ctx, canonicalToolCalls, turnId) : await executeToolsSequential(ctx, canonicalToolCalls, turnId);
 	const toolResultMsg = ctx.provider.toolResultsMessage(toolResults);
-	ctx.turns.push({
+	const toolResultsTurn = {
 		id: await ctx.generateTurnId(),
 		runId: ctx.runId,
 		role: toolResultMsg.role,
 		content: toolResultMsg.content,
 		createdAt: Date.now()
+	};
+	ctx.turns.push(toolResultsTurn);
+	await ctx.hooks.callHook("tool-results:after", {
+		turn,
+		turnId,
+		message: toolResultsTurn,
+		results: toolResults
 	});
 	if (typeof ctx.toolOutputBudget === "number" && ctx.toolOutputBudget > 0) {
 		const totalBytes = toolResults.reduce((sum, r) => sum + toolOutputByteLength(r.content), 0);
@@ -1151,8 +1158,21 @@ async function executeToolsSequential(ctx, toolCalls, turnId) {
 			});
 			return results;
 		}
-		const { result } = await executeSingleTool(ctx, call, turnId);
-		results.push(result);
+		try {
+			const { result } = await executeSingleTool(ctx, call, turnId);
+			results.push(result);
+		} catch (err) {
+			const message = err instanceof Error ? err.message : String(err);
+			results.push({
+				id: call.id,
+				content: `Error: ${message}`
+			});
+			for (let j = i + 1; j < toolCalls.length; j++) results.push({
+				id: toolCalls[j].id,
+				content: "Skipped: previous tool call threw"
+			});
+			return results;
+		}
 	}
 	return results;
 }
@@ -1737,6 +1757,7 @@ const HOOK_EVENT_SET = new Set([
 	"system:before",
 	"turn:before",
 	"turn:after",
+	"tool-results:after",
 	"stream:text",
 	"stream:end",
 	"stream:thinking",
@@ -1794,6 +1815,45 @@ const HOOK_EVENT_SET = new Set([
 function isKnownHookEvent(event) {
 	return HOOK_EVENT_SET.has(event);
 }
+/**
+* If the trailing assistant turn in `turns` carries `tool_call` blocks with
+* no matching `tool_result` in a following user turn, mutate `turns` in
+* place to append a synthetic tool-results turn that closes every dangling
+* tool_use id. Used by the error path of `agent.run` to prevent a thrown
+* loop from leaving the persisted session with an orphan tool_use — which
+* Anthropic rejects on resume.
+*
+* No-op when:
+* - The trailing turn isn't an assistant turn (already closed, or session
+*   ends with the seeded user prompt).
+* - The assistant turn has no `tool_call` blocks.
+* - All tool_use ids are already answered by a tool_result somewhere later
+*   in the conversation (defensive — shouldn't happen but cheap to check).
+*/
+function synthesizeMissingToolResults(turns, syntheticTurnId, runId, provider) {
+	if (turns.length === 0) return;
+	const last = turns[turns.length - 1];
+	if (last.role !== "assistant") return;
+	const pendingIds = [];
+	for (const block of last.content) if (block.type === "tool_call") pendingIds.push(block.id);
+	if (pendingIds.length === 0) return;
+	const answered = /* @__PURE__ */ new Set();
+	for (const turn of turns.slice(0, -1)) for (const block of turn.content) if (block.type === "tool_result") answered.add(block.callId);
+	const dangling = pendingIds.filter((id) => !answered.has(id));
+	if (dangling.length === 0) return;
+	const results = dangling.map((id) => ({
+		id,
+		content: "Aborted: run failed before tool execution completed"
+	}));
+	const msg = provider.toolResultsMessage(results);
+	turns.push({
+		id: syntheticTurnId,
+		runId,
+		role: msg.role,
+		content: msg.content,
+		createdAt: Date.now()
+	});
+}
 function resolveBehavior(agentBehavior, runBehavior) {
 	return {
 		toolExecution: runBehavior?.toolExecution ?? agentBehavior?.toolExecution ?? "parallel",
@@ -1936,10 +1996,43 @@ function installLazyDisclosureGate(hooks, lazyCanonicalNames, unlocked, discover
 		ctx.reason = discoveryToolName ? `Tool "${ctx.name}" is listed in <searchable_tools> but its schema has not been loaded. Call the \`${discoveryToolName}\` tool with names: ["${ctx.name}"] first, then re-issue the call.` : `Tool "${ctx.name}" is listed in <searchable_tools> but its schema has not been loaded.`;
 	});
 }
-function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, mcpConnector, eager }) {
+/**
+* Pick the next safe value for `runCounter` so `run_${++counter}` mints
+* an id that doesn't collide with any runId already referenced by the
+* session — whether the runId lives in `session.runs` or only in
+* `session.turns[].runId`. The regex matches the canonical `run_<int>`
+* shape minted by this module; any caller-supplied custom id schemes
+* are ignored (they don't conflict with `run_N`).
+*
+* Returning 0 for a sessionless / clean session preserves the original
+* "first run is run_1" semantics.
+*/
+function initialRunCounter(session) {
+	if (!session) return 0;
+	let max = 0;
+	const consider = (id) => {
+		if (!id) return;
+		const m = /^run_(\d+)$/.exec(id);
+		if (!m) return;
+		const n = Number.parseInt(m[1], 10);
+		if (Number.isFinite(n) && n > max) max = n;
+	};
+	for (const r of session.runs) consider(r.id);
+	for (const t of session.turns) consider(t.runId);
+	return max;
+}
+function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, skills: agentSkills, mcpConnector, eager, hooks: initialHooks }) {
 	const hooks = createHooks();
 	const executionContext = execution ?? createProcessContext();
 	const sourceTools = agentTools ?? {};
+	if (initialHooks) for (const [event, handler] of Object.entries(initialHooks)) {
+		if (!isKnownHookEvent(event)) throw new Error(`Unknown hook event "${event}" passed to createAgent(). See AgentHooks for valid events.`);
+		const handlerList = Array.isArray(handler) ? handler : [handler];
+		for (const fn of handlerList) {
+			if (typeof fn !== "function") continue;
+			hooks.hook(event, fn);
+		}
+	}
 	let abortController;
 	let running = false;
 	let idleResolve;
@@ -1951,354 +2044,397 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 	const steeringQueue = [];
 	const followUpQueue = [];
 	let conversationTurns = session?.turns.slice() ?? [];
-	let runCounter = session?.runs.length ?? 0;
+	let runCounter = initialRunCounter(session);
 	const skillsConfig = agentSkills;
 	const skillsEnabledValue = skillsConfig?.enabled;
 	const skillsDisabled = skillsEnabledValue === false || Array.isArray(skillsEnabledValue) && skillsEnabledValue.length === 0;
 	let resolvedSkills = null;
 	let skillsCatalog = null;
+	let skillsResolvePromise = null;
 	let skillsCleanup = () => {};
-	const skillActivationState = createSkillActivationState({ maxActive: skillsConfig?.maxActive });
-	async function run(options) {
-		if (running) throw new Error("Agent is already running. Use steer() or followUp() to queue messages, or waitForIdle().");
-		const hasSessionTurns = session && session.turns.length > 0;
-		if (!options.prompt && !hasSessionTurns) throw new Error("prompt is required when no session with existing turns is provided");
-		if (!options.prompt && hasSessionTurns) {
-			const lastTurn = session.turns.at(-1);
-			if (lastTurn && lastTurn.role !== "user") throw new Error("cannot resume without prompt: last session turn must be a user message");
-		}
-		running = true;
-		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, {
-			...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
-			});
-		}
-		if (options.signal) if (options.signal.aborted) abortController.abort();
-		else {
-			const onExternalAbort = () => abortController?.abort();
-			options.signal.addEventListener("abort", onExternalAbort, { once: true });
-		}
-		idlePromise = new Promise((resolve) => {
-			idleResolve = resolve;
-		});
-		const childrenStats = [];
-		const unregisterSpawnHook = hooks.hook("spawn:complete", (ctx) => {
-			childrenStats.push(ctx);
-		});
-		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") continue;
-				perRunUnregisters.push(hooks.hook(event, fn));
-			}
-		}
-		if (!executionHandle) executionHandle = await executionContext.spawn();
-		if (allMcpServers.length > 0 && !mcpConnection) await warmup();
-		if (!skillsDisabled && skillsConfig && !resolvedSkills) {
+	/**
+	* Resolve skills once for the lifetime of the agent. Idempotent and
+	* concurrency-safe; no-op when `skills` is disabled or omitted.
+	*
+	* Used by `run()` (lazy bootstrap), `warmup()` (eager bootstrap), and
+	* `activateSkill()` (so the public API doesn't leak the timing of `run()`).
+	* Fires `skills:resolve` (mutable `skills` array) and `skills:catalog`
+	* (mutable `catalog`) in that order — exactly once per agent.
+	*/
+	async function ensureSkillsResolved() {
+		if (skillsDisabled || !skillsConfig) return;
+		if (resolvedSkills) return;
+		if (skillsResolvePromise) return skillsResolvePromise;
+		skillsResolvePromise = (async () => {
 			const bundle = await resolveSkills(skillsConfig);
 			resolvedSkills = bundle.skills;
 			skillsCleanup = bundle.cleanup;
 			await hooks.callHook("skills:resolve", { skills: resolvedSkills });
-			const skillsToolRegistered = skillsConfig?.tool !== false && resolvedSkills.length > 0;
+			const skillsToolRegistered = skillsConfig.tool !== false && resolvedSkills.length > 0;
 			const catalogCtx = {
 				catalog: buildCatalog(resolvedSkills, { skillsToolRegistered }),
 				skills: resolvedSkills
 			};
 			await hooks.callHook("skills:catalog", catalogCtx);
 			skillsCatalog = catalogCtx.catalog;
+		})();
+		try {
+			await skillsResolvePromise;
+		} catch (err) {
+			skillsResolvePromise = null;
+			throw err;
 		}
-		if (resolvedSkills && session && session.turns.length > 0 && skillActivationState.active().length === 0) {
-			const skillsByName = new Map(resolvedSkills.map((s) => [s.name, s]));
-			for (const turn of session.turns) {
-				if (turn.role !== "assistant") continue;
-				for (const block of turn.content) {
-					if (block.type !== "tool_call" || block.name !== "skills_use") continue;
-					const skillName = block.input?.name;
-					if (!skillName) continue;
-					const skill = skillsByName.get(skillName);
-					if (!skill) continue;
-					if (skillActivationState.activate(skill, "resume") === "ok") await hooks.callHook("skills:activate", {
-						skill,
-						via: "resume"
-					});
-				}
-			}
+	}
+	const skillActivationState = createSkillActivationState({ maxActive: skillsConfig?.maxActive });
+	async function run(options) {
+		if (running) throw new Error("Agent is already running. Use steer() or followUp() to queue messages, or waitForIdle().");
+		const hasSessionTurns = session && session.turns.length > 0;
+		if (!options.prompt && !hasSessionTurns) throw new Error("prompt is required when no session with existing turns is provided");
+		if (!options.prompt && hasSessionTurns) {
+			const lastTurn = session.turns.at(-1);
+			if (lastTurn && lastTurn.role !== "user") throw new Error("cannot resume without prompt: last session turn must be a user message");
 		}
-		const thinking = options.thinking ?? "off";
-		const model = options.model ?? provider.meta.defaultModel;
-		const resolvedBehavior = resolveBehavior(agentBehavior, options.behavior);
-		const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch } = resolvedBehavior;
-		let system = options.system || agentSystem || "You are a helpful assistant.";
-		if (skillsCatalog) system = `${system}\n\n${skillsCatalog}`;
-		const runBaseTools = options.tools !== void 0 ? options.tools : mcpConnection ? {
-			...sourceTools,
-			...mcpConnection.tools
-		} : sourceTools;
-		const mcpToolNames = options.tools === void 0 && mcpConnection ? new Set(Object.keys(mcpConnection.tools)) : /* @__PURE__ */ new Set();
-		const mergedWithSkills = options.tools === void 0 && !!resolvedSkills && resolvedSkills.length > 0 && skillsConfig?.tool !== false ? {
-			skills_use: createSkillsUseTool({
-				catalog: resolvedSkills,
-				state: skillActivationState,
-				hooks
-			}),
-			skills_read: createSkillsReadTool({
-				catalog: resolvedSkills,
-				state: skillActivationState
-			}),
-			skills_run_script: createSkillsRunScriptTool({
-				catalog: resolvedSkills,
-				state: skillActivationState,
-				scriptTimeoutMs: skillsConfig?.scriptTimeoutMs
-			}),
-			...runBaseTools
-		} : runBaseTools;
-		const toolsPreSearch = {};
-		for (const tool of Object.values(mergedWithSkills)) toolsPreSearch[tool.spec.name] = tool;
-		const disclosure = partitionToolDisclosure(toolsPreSearch, mcpToolNames, mcpServers, toolDisclosure, toolAliases);
-		const unlocked = new Set(disclosure.eagerCanonicalNames);
-		const hostDefinedToolSearch = !!toolsPreSearch.tool_search;
-		const shouldInjectToolSearch = disclosure.lazyEntries.length > 0 && toolSearch?.tool !== false && !hostDefinedToolSearch;
-		let tools = toolsPreSearch;
-		if (shouldInjectToolSearch) {
-			const toolSearchTool = createToolSearchTool({
-				catalog: disclosure.lazyEntries,
-				unlocked,
-				...toolSearch?.limit !== void 0 ? { defaultLimit: toolSearch.limit } : {}
+		let externalAbortListener;
+		const externalSignal = options.signal;
+		running = true;
+		try {
+			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, {
+				...options.parentRunId ? { parentRunId: options.parentRunId } : {},
+				depth: typeof options.depth === "number" ? options.depth : 0
 			});
-			tools = {
-				...toolsPreSearch,
-				[toolSearchTool.spec.name]: toolSearchTool
-			};
-			unlocked.add(toolSearchTool.spec.name);
-		}
-		const discoveryToolName = shouldInjectToolSearch ? "tool_search" : hostDefinedToolSearch ? toolAliases?.tool_search ?? "tool_search" : null;
-		if (disclosure.lazyEntries.length > 0) system = `${system}\n\n${buildSearchableCatalog(disclosure.lazyEntries, { discoveryToolName })}`;
-		const aliasMaps = buildAliasMaps(toolAliases, Object.keys(tools));
-		const uninstallLazyDisclosureGate = installLazyDisclosureGate(hooks, disclosure.lazyCanonicalNames, unlocked, discoveryToolName);
-		function buildFormattedTools() {
-			const specs = [];
-			for (const t of Object.values(tools)) {
-				if (!unlocked.has(t.spec.name)) continue;
-				specs.push({
-					name: aliasMaps.aliasByCanonical.get(t.spec.name) ?? t.spec.name,
-					description: t.spec.description || "",
-					inputSchema: t.spec.inputSchema
+			if (session) {
+				await session.updateStatus("running");
+				await hooks.callHook("session:start", {
+					sessionId: session.id,
+					runId,
+					prompt: promptLabel
 				});
 			}
-			return specs.length > 0 ? provider.formatTools(specs) : [];
-		}
-		const formattedTools = buildFormattedTools();
-		const 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);
-		if (promptParts) {
-			const promptMsg = buildPromptMessage(provider, promptParts);
-			turns.push({
-				id: crypto.randomUUID(),
-				runId,
-				role: promptMsg.role,
-				content: promptMsg.content,
-				createdAt: Date.now()
+			if (externalSignal) if (externalSignal.aborted) abortController.abort();
+			else {
+				externalAbortListener = () => abortController?.abort();
+				externalSignal.addEventListener("abort", externalAbortListener, { once: true });
+			}
+			idlePromise = new Promise((resolve) => {
+				idleResolve = resolve;
 			});
-		}
-		conversationTurns = turns;
-		let lastPersistedTurnCount = isResume ? session.turns.length : 0;
-		if (session && turns.length > lastPersistedTurnCount) {
-			const seededTurns = turns.slice(lastPersistedTurnCount);
-			await session.appendTurns(seededTurns);
-			lastPersistedTurnCount = turns.length;
-			await hooks.callHook("session:turns", {
-				sessionId: session.id,
-				turns: seededTurns,
-				count: turns.length
+			const childrenStats = [];
+			const unregisterSpawnHook = hooks.hook("spawn:complete", (ctx) => {
+				childrenStats.push(ctx);
 			});
-		}
-		const unregisterSessionSync = session ? hooks.hook("turn:after", async () => {
-			const newTurns = turns.slice(lastPersistedTurnCount);
-			if (newTurns.length > 0) {
-				await session.appendTurns(newTurns);
+			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") continue;
+					perRunUnregisters.push(hooks.hook(event, fn));
+				}
+			}
+			if (!executionHandle) executionHandle = await executionContext.spawn();
+			if (allMcpServers.length > 0 && !mcpConnection) await warmup();
+			await ensureSkillsResolved();
+			if (resolvedSkills && session && session.turns.length > 0 && skillActivationState.active().length === 0) {
+				const skillsByName = new Map(resolvedSkills.map((s) => [s.name, s]));
+				for (const turn of session.turns) {
+					if (turn.role !== "assistant") continue;
+					for (const block of turn.content) {
+						if (block.type !== "tool_call" || block.name !== "skills_use") continue;
+						const skillName = block.input?.name;
+						if (!skillName) continue;
+						const skill = skillsByName.get(skillName);
+						if (!skill) continue;
+						if (skillActivationState.activate(skill, "resume") === "ok") await hooks.callHook("skills:activate", {
+							skill,
+							via: "resume"
+						});
+					}
+				}
+			}
+			const thinking = options.thinking ?? "off";
+			const model = options.model ?? provider.meta.defaultModel;
+			const resolvedBehavior = resolveBehavior(agentBehavior, options.behavior);
+			const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch } = resolvedBehavior;
+			let system = options.system || agentSystem || "You are a helpful assistant.";
+			if (skillsCatalog) system = `${system}\n\n${skillsCatalog}`;
+			const runBaseTools = options.tools !== void 0 ? options.tools : mcpConnection ? {
+				...sourceTools,
+				...mcpConnection.tools
+			} : sourceTools;
+			const mcpToolNames = options.tools === void 0 && mcpConnection ? new Set(Object.keys(mcpConnection.tools)) : /* @__PURE__ */ new Set();
+			const mergedWithSkills = options.tools === void 0 && !!resolvedSkills && resolvedSkills.length > 0 && skillsConfig?.tool !== false ? {
+				skills_use: createSkillsUseTool({
+					catalog: resolvedSkills,
+					state: skillActivationState,
+					hooks
+				}),
+				skills_read: createSkillsReadTool({
+					catalog: resolvedSkills,
+					state: skillActivationState
+				}),
+				skills_run_script: createSkillsRunScriptTool({
+					catalog: resolvedSkills,
+					state: skillActivationState,
+					scriptTimeoutMs: skillsConfig?.scriptTimeoutMs
+				}),
+				...runBaseTools
+			} : runBaseTools;
+			const toolsPreSearch = {};
+			for (const tool of Object.values(mergedWithSkills)) toolsPreSearch[tool.spec.name] = tool;
+			const disclosure = partitionToolDisclosure(toolsPreSearch, mcpToolNames, mcpServers, toolDisclosure, toolAliases);
+			const unlocked = new Set(disclosure.eagerCanonicalNames);
+			const hostDefinedToolSearch = !!toolsPreSearch.tool_search;
+			const shouldInjectToolSearch = disclosure.lazyEntries.length > 0 && toolSearch?.tool !== false && !hostDefinedToolSearch;
+			let tools = toolsPreSearch;
+			if (shouldInjectToolSearch) {
+				const toolSearchTool = createToolSearchTool({
+					catalog: disclosure.lazyEntries,
+					unlocked,
+					...toolSearch?.limit !== void 0 ? { defaultLimit: toolSearch.limit } : {}
+				});
+				tools = {
+					...toolsPreSearch,
+					[toolSearchTool.spec.name]: toolSearchTool
+				};
+				unlocked.add(toolSearchTool.spec.name);
+			}
+			const discoveryToolName = shouldInjectToolSearch ? "tool_search" : hostDefinedToolSearch ? toolAliases?.tool_search ?? "tool_search" : null;
+			if (disclosure.lazyEntries.length > 0) system = `${system}\n\n${buildSearchableCatalog(disclosure.lazyEntries, { discoveryToolName })}`;
+			const aliasMaps = buildAliasMaps(toolAliases, Object.keys(tools));
+			function buildFormattedTools() {
+				const specs = [];
+				for (const t of Object.values(tools)) {
+					if (!unlocked.has(t.spec.name)) continue;
+					specs.push({
+						name: aliasMaps.aliasByCanonical.get(t.spec.name) ?? t.spec.name,
+						description: t.spec.description || "",
+						inputSchema: t.spec.inputSchema
+					});
+				}
+				return specs.length > 0 ? provider.formatTools(specs) : [];
+			}
+			const formattedTools = buildFormattedTools();
+			const 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);
+			if (promptParts) {
+				const promptMsg = buildPromptMessage(provider, promptParts);
+				turns.push({
+					id: crypto.randomUUID(),
+					runId,
+					role: promptMsg.role,
+					content: promptMsg.content,
+					createdAt: Date.now()
+				});
+			}
+			conversationTurns = turns;
+			let lastPersistedTurnCount = isResume ? session.turns.length : 0;
+			if (session && turns.length > lastPersistedTurnCount) {
+				const seededTurns = turns.slice(lastPersistedTurnCount);
+				await session.appendTurns(seededTurns);
 				lastPersistedTurnCount = turns.length;
 				await hooks.callHook("session:turns", {
 					sessionId: session.id,
-					turns: newTurns,
+					turns: seededTurns,
 					count: turns.length
 				});
 			}
-		}) : void 0;
-		async function flushTurns() {
-			if (!session) return;
-			const remaining = turns.slice(lastPersistedTurnCount);
-			if (remaining.length > 0) {
-				await session.appendTurns(remaining);
+			const persistPendingTurns = async () => {
+				if (!session) return;
+				const newTurns = turns.slice(lastPersistedTurnCount);
+				if (newTurns.length === 0) return;
+				await session.appendTurns(newTurns);
 				lastPersistedTurnCount = turns.length;
 				await hooks.callHook("session:turns", {
 					sessionId: session.id,
-					turns: remaining,
+					turns: newTurns,
 					count: turns.length
 				});
+			};
+			const unregisterTurnSync = session ? hooks.hook("turn:after", persistPendingTurns) : void 0;
+			const unregisterToolResultsSync = session ? hooks.hook("tool-results:after", persistPendingTurns) : void 0;
+			async function flushTurns(opts = {}) {
+				if (!session) return;
+				if (opts.failureFallback) synthesizeMissingToolResults(turns, await session.generateTurnId?.() ?? crypto.randomUUID(), runId, provider);
+				const remaining = turns.slice(lastPersistedTurnCount);
+				if (remaining.length > 0) {
+					await session.appendTurns(remaining);
+					lastPersistedTurnCount = turns.length;
+					await hooks.callHook("session:turns", {
+						sessionId: session.id,
+						turns: remaining,
+						count: turns.length
+					});
+				}
 			}
-		}
-		async function deactivateAllSkills() {
-			for (const record of skillActivationState.clear()) await hooks.callHook("skills:deactivate", {
-				skill: record.skill,
-				reason: "run-end"
-			});
-		}
-		async function finalizeSession(status) {
-			if (!session) return;
-			const run = session.runs.find((r) => r.id === runId);
-			if (run) await session.updateRun(run);
-			await session.updateStatus(status === "aborted" ? "idle" : status);
-			await hooks.callHook("session:end", {
-				sessionId: session.id,
-				runId,
-				status,
-				turnRange: [runTurnStart, turns.length - 1]
-			});
-		}
-		const uninstallAllowedToolsGate = installAllowedToolsGate(hooks, skillActivationState);
-		const uninstallToolBudgets = installToolBudgetsGate(hooks, () => toolBudgets, (msg) => steeringQueue.push(msg));
-		const uninstallDedupTools = installDedupToolsGate(hooks, () => dedupTools, () => session ?? void 0);
-		const runStartMs = Date.now();
-		const runDepth = typeof options.depth === "number" ? options.depth : 0;
-		try {
-			const stats = await runLoop({
-				provider,
-				hooks,
-				agentName,
-				agentSystem,
-				agentTools: sourceTools,
-				agentToolAliases: toolAliases,
-				agentMcpServers: mcpServers,
-				agentSkills,
-				agentBehavior: resolvedBehavior,
-				tools,
-				formattedTools,
-				rebuildFormattedTools: disclosure.lazyEntries.length > 0 ? buildFormattedTools : void 0,
-				aliasMaps,
-				model,
-				system,
-				thinking,
-				toolExecution,
-				signal: abortController.signal,
-				execution: executionContext,
-				handle: executionHandle,
-				steeringQueue,
-				followUpQueue,
-				turns,
-				runId,
-				generateTurnId: () => session?.generateTurnId() ?? crypto.randomUUID(),
-				maxTurns,
-				maxTokens,
-				...session ? { session } : {},
-				depth: runDepth,
-				thinkingBudget,
-				schema,
-				cache,
-				toolOutputBudget,
-				compactStrategy,
-				compactThreshold,
-				compactKeepTurns,
-				...elideStaleReads !== void 0 ? { elideStaleReads } : {},
-				...thinkingDecay !== void 0 ? { thinkingDecay } : {},
-				runStartMs,
-				runToolCounts: {}
-			});
-			const parentTurnCost = stats.turnUsage?.reduce((sum, t) => sum + (t.cost ?? 0), 0) ?? 0;
-			let childrenIn = 0;
-			let childrenOut = 0;
-			let childrenCost = 0;
-			let childrenCacheRead = 0;
-			let childrenCacheCreation = 0;
-			for (const c of childrenStats) {
-				childrenIn += c.stats.totalIn;
-				childrenOut += c.stats.totalOut;
-				childrenCost += c.stats.cost ?? 0;
-				childrenCacheRead += c.stats.totalCacheRead;
-				childrenCacheCreation += c.stats.totalCacheCreation;
+			async function deactivateAllSkills() {
+				for (const record of skillActivationState.clear()) await hooks.callHook("skills:deactivate", {
+					skill: record.skill,
+					reason: "run-end"
+				});
 			}
-			const cumulativeCost = parentTurnCost + childrenCost;
-			const finalStats = {
-				...stats,
-				totalIn: stats.totalIn + childrenIn,
-				totalOut: stats.totalOut + childrenOut,
-				totalCacheRead: stats.totalCacheRead + childrenCacheRead,
-				totalCacheCreation: stats.totalCacheCreation + childrenCacheCreation,
-				...cumulativeCost > 0 ? { cost: cumulativeCost } : {},
-				children: childrenStats.length > 0 ? childrenStats : void 0
-			};
-			await flushTurns();
-			if (abortController.signal.aborted) {
-				session?.abortRun(runId);
-				await finalizeSession("aborted");
-				await hooks.callHook("agent:done", finalStats);
-				return finalStats;
+			async function finalizeSession(status) {
+				if (!session) return;
+				const run = session.runs.find((r) => r.id === runId);
+				if (run) await session.updateRun(run);
+				await session.updateStatus(status === "aborted" ? "idle" : status);
+				await hooks.callHook("session:end", {
+					sessionId: session.id,
+					runId,
+					status,
+					turnRange: [runTurnStart, turns.length - 1]
+				});
 			}
-			session?.completeRun(runId, {
-				turns: stats.turns,
-				tokensIn: stats.totalIn,
-				tokensOut: stats.totalOut,
-				turnUsage: stats.turnUsage,
-				cost: parentTurnCost > 0 ? parentTurnCost : void 0
-			});
-			await finalizeSession("completed");
-			await hooks.callHook("agent:done", finalStats);
-			return finalStats;
-		} catch (err) {
-			await flushTurns();
-			if (abortController.signal.aborted) {
-				session?.abortRun(runId);
-				await finalizeSession("aborted");
-				const stats = {
-					totalIn: 0,
-					totalOut: 0,
-					totalCacheRead: 0,
-					totalCacheCreation: 0,
-					turns: 0,
-					elapsed: 0
+			const uninstallAllowedToolsGate = installAllowedToolsGate(hooks, skillActivationState);
+			const uninstallToolBudgets = installToolBudgetsGate(hooks, () => toolBudgets, (msg) => steeringQueue.push(msg));
+			const uninstallDedupTools = installDedupToolsGate(hooks, () => dedupTools, () => session ?? void 0);
+			const uninstallLazyDisclosureGate = installLazyDisclosureGate(hooks, disclosure.lazyCanonicalNames, unlocked, discoveryToolName);
+			const runStartMs = Date.now();
+			const runDepth = typeof options.depth === "number" ? options.depth : 0;
+			try {
+				const stats = await runLoop({
+					provider,
+					hooks,
+					agentName,
+					agentSystem,
+					agentTools: sourceTools,
+					agentToolAliases: toolAliases,
+					agentMcpServers: mcpServers,
+					agentSkills,
+					agentBehavior: resolvedBehavior,
+					tools,
+					formattedTools,
+					rebuildFormattedTools: disclosure.lazyEntries.length > 0 ? buildFormattedTools : void 0,
+					aliasMaps,
+					model,
+					system,
+					thinking,
+					toolExecution,
+					signal: abortController.signal,
+					execution: executionContext,
+					handle: executionHandle,
+					steeringQueue,
+					followUpQueue,
+					turns,
+					runId,
+					generateTurnId: () => session?.generateTurnId() ?? crypto.randomUUID(),
+					maxTurns,
+					maxTokens,
+					...session ? { session } : {},
+					depth: runDepth,
+					thinkingBudget,
+					schema,
+					cache,
+					toolOutputBudget,
+					compactStrategy,
+					compactThreshold,
+					compactKeepTurns,
+					...elideStaleReads !== void 0 ? { elideStaleReads } : {},
+					...thinkingDecay !== void 0 ? { thinkingDecay } : {},
+					runStartMs,
+					runToolCounts: {}
+				});
+				const parentTurnCost = stats.turnUsage?.reduce((sum, t) => sum + (t.cost ?? 0), 0) ?? 0;
+				let childrenIn = 0;
+				let childrenOut = 0;
+				let childrenCost = 0;
+				let childrenCacheRead = 0;
+				let childrenCacheCreation = 0;
+				for (const c of childrenStats) {
+					childrenIn += c.stats.totalIn;
+					childrenOut += c.stats.totalOut;
+					childrenCost += c.stats.cost ?? 0;
+					childrenCacheRead += c.stats.totalCacheRead;
+					childrenCacheCreation += c.stats.totalCacheCreation;
+				}
+				const cumulativeCost = parentTurnCost + childrenCost;
+				const finalStats = {
+					...stats,
+					totalIn: stats.totalIn + childrenIn,
+					totalOut: stats.totalOut + childrenOut,
+					totalCacheRead: stats.totalCacheRead + childrenCacheRead,
+					totalCacheCreation: stats.totalCacheCreation + childrenCacheCreation,
+					...cumulativeCost > 0 ? { cost: cumulativeCost } : {},
+					children: childrenStats.length > 0 ? childrenStats : void 0
 				};
-				await hooks.callHook("agent:done", stats);
-				return stats;
+				await flushTurns();
+				if (abortController.signal.aborted) {
+					session?.abortRun(runId, {
+						turns: stats.turns,
+						tokensIn: stats.totalIn,
+						tokensOut: stats.totalOut,
+						turnUsage: stats.turnUsage,
+						cost: parentTurnCost > 0 ? parentTurnCost : void 0
+					});
+					await finalizeSession("aborted");
+					await hooks.callHook("agent:done", finalStats);
+					return finalStats;
+				}
+				session?.completeRun(runId, {
+					turns: stats.turns,
+					tokensIn: stats.totalIn,
+					tokensOut: stats.totalOut,
+					turnUsage: stats.turnUsage,
+					cost: parentTurnCost > 0 ? parentTurnCost : void 0
+				});
+				await finalizeSession("completed");
+				await hooks.callHook("agent:done", finalStats);
+				return finalStats;
+			} catch (err) {
+				await flushTurns({ failureFallback: true });
+				if (abortController.signal.aborted) {
+					session?.abortRun(runId);
+					await finalizeSession("aborted");
+					const stats = {
+						totalIn: 0,
+						totalOut: 0,
+						totalCacheRead: 0,
+						totalCacheCreation: 0,
+						turns: 0,
+						elapsed: 0
+					};
+					await hooks.callHook("agent:done", stats);
+					return stats;
+				}
+				const message = err instanceof Error ? err.message : String(err);
+				session?.errorRun(runId, message);
+				await finalizeSession("error");
+				throw err;
+			} finally {
+				await deactivateAllSkills();
+				uninstallAllowedToolsGate();
+				uninstallDedupTools();
+				uninstallToolBudgets();
+				uninstallLazyDisclosureGate();
+				unregisterSpawnHook();
+				unregisterTurnSync?.();
+				unregisterToolResultsSync?.();
+				for (const unregister of perRunUnregisters) unregister();
+				running = false;
+				abortController = void 0;
+				steeringQueue.length = 0;
+				followUpQueue.length = 0;
+				idleResolve?.();
+				idlePromise = void 0;
+				idleResolve = void 0;
 			}
-			const message = err instanceof Error ? err.message : String(err);
-			session?.errorRun(runId, message);
-			await finalizeSession("error");
-			throw err;
 		} finally {
-			await deactivateAllSkills();
-			uninstallAllowedToolsGate();
-			uninstallDedupTools();
-			uninstallToolBudgets();
-			uninstallLazyDisclosureGate();
-			unregisterSpawnHook();
-			unregisterSessionSync?.();
-			for (const unregister of perRunUnregisters) unregister();
 			running = false;
 			abortController = void 0;
-			steeringQueue.length = 0;
-			followUpQueue.length = 0;
 			idleResolve?.();
 			idlePromise = void 0;
 			idleResolve = void 0;
+			if (externalSignal && externalAbortListener) externalSignal.removeEventListener("abort", externalAbortListener);
 		}
 	}
 	function abort() {
@@ -2325,7 +2461,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 		});
 	}
 	async function activateSkill(name) {
-		if (!resolvedSkills) throw new Error(`Cannot activate skill "${name}" — skills have not been resolved yet. Call activateSkill after the first \`run()\`, or pass a skills config that resolves at agent-creation time.`);
+		await ensureSkillsResolved();
+		if (!resolvedSkills) throw new Error(`Cannot activate skill "${name}" — skills are disabled for this agent.`);
 		const skill = resolvedSkills.find((s) => s.name === name);
 		if (!skill) {
 			const available = resolvedSkills.map((s) => s.name).join(", ") || "<none>";
@@ -2371,8 +2508,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 	* retry — leaving a rejected promise cached would permanently poison future
 	* runs on the same agent.
 	*/
-	async function warmup() {
-		if (destroyed) return;
+	async function ensureMcpConnected() {
 		if (mcpConnection || allMcpServers.length === 0) return;
 		if (mcpWarmupPromise) return mcpWarmupPromise;
 		mcpWarmupPromise = (async () => {
@@ -2390,6 +2526,10 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			throw err;
 		}
 	}
+	async function warmup() {
+		if (destroyed) return;
+		await Promise.all([ensureMcpConnected(), ensureSkillsResolved()]);
+	}
 	async function destroy() {
 		if (destroyed) return;
 		destroyed = true;
@@ -2407,7 +2547,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 		skillsCleanup();
 		skillsCleanup = () => {};
 	}
-	if (eager && allMcpServers.length > 0) warmup().catch(() => {});
+	const eagerHasWork = allMcpServers.length > 0 || !skillsDisabled && !!skillsConfig;
+	if (eager && eagerHasWork) warmup().catch(() => {});
 	return {
 		hooks,
 		run,
@@ -3701,17 +3842,33 @@ var SpawnTimeoutError = class extends Error {
 * Called before `agent.run()` starts, torn down in a finally block — so
 * nothing leaks even if the child throws mid-run.
 */
+/**
+* Surface a thrown observational-bubble listener without killing the
+* process. Observational events (`child:stream:text`, `child:tool:after`,
+* `child:turn:after`, …) are fire-and-forget — a rejected promise here
+* has no caller. Without this handler, a buggy parent listener bubbles
+* up to an unhandled-rejection, and Node/Bun under
+* `--unhandled-rejections=strict` terminates the host.
+*
+* Gated on `ZIDANE_DEBUG` so production logs stay quiet; debug builds
+* still get the tagged line.
+*/
+function swallowBubbleError(eventName, err) {
+	if (!process.env.ZIDANE_DEBUG) return;
+	const message = err instanceof Error ? err.stack ?? err.message : String(err);
+	process.stderr.write(`[zidane/spawn] parent listener for "${eventName}" rejected: ${message}\n`);
+}
 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) => {
-			fire(parentEvt, {
+			Promise.resolve(fire(parentEvt, {
 				...ctx,
 				childId,
 				depth
-			});
+			})).catch((err) => swallowBubbleError(parentEvt, err));
 		});
 		unregisters.push(unregister);
 	}
@@ -3731,7 +3888,7 @@ function bubbleHooks(childHooks, parentHooks, childId, depth) {
 	for (const evt of BUBBLED_EVENTS) {
 		const parentEvt = CHILD_EVENT_NAME[evt];
 		unregisters.push(chainHook(parentEvt, (ctx) => {
-			fire(parentEvt, ctx);
+			Promise.resolve(fire(parentEvt, ctx)).catch((err) => swallowBubbleError(parentEvt, err));
 		}));
 	}
 	for (const evt of BUBBLED_GATE_EVENTS) {
@@ -3988,4 +4145,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-C8kDot0H.js.map
+//# sourceMappingURL=tools-CLazLRb4.js.map