zidane 5.6.11 → 5.6.13

package/dist/{tools-CxOfTt3R.js → tools-DE9pR_NG.js}

@@ -1,14 +1,14 @@
 import { n as createProcessContext } from "./contexts-BOtMvzli.js";
 import { c as errorMessage, i as AgentProviderError, n as AgentBudgetExceededError, o as AgentToolPairingError, t as AgentAbortedError, u as toTypedError } from "./errors-DdZXnyXE.js";
 import { n as toolOutputByteLength, t as DEFAULT_AGENT_CLOCK } from "./types-oKPBdCmL.js";
-import { a as detectTurnInterruption, c as filterUnresolvedToolUses, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureEndsWithUserMessage, s as ensureToolResultPairing } from "./messages-BfmXLDT4.js";
-import { t as connectMcpServers } from "./mcp-0jRkIV0g.js";
+import { E as appendStaticSection, a as detectTurnInterruption, c as filterUnresolvedToolUses, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureEndsWithUserMessage, s as ensureToolResultPairing } from "./messages-Dym8S_YH.js";
+import { t as connectMcpServers } from "./mcp-DGeB7-3D.js";
 import { _ as validateResourcePath, b as createSkillActivationState, d as escapeXml, n as resolveSkills, p as installAllowedToolsGate, t as interpolateShellCommands, u as buildCatalog } from "./interpolate-DM1UcKeQ.js";
 import { n as formatTokenUsage, t as flattenTurns } from "./stats-Lc3zL3RM.js";
 import { dirname, isAbsolute, join, resolve } from "node:path";
 import { createHooks } from "hookable";
 import { homedir } from "node:os";
-import { mkdir, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
+import { glob, mkdir, readdir, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
 import { Buffer } from "node:buffer";
 //#region src/aliasing.ts
 /**
@@ -60,6 +60,45 @@ function toCanonicalName(wire, maps) {
 	return maps.canonicalByAlias.get(wire) ?? wire;
 }
 /**
+* Augment {@link AliasMaps} with INBOUND-ONLY aliases for the Claude Code
+* `mcp__server__tool` double-underscore naming convention. For every MCP
+* tool registered with the canonical `mcp_<server>_<tool>` form, add a
+* `canonicalByAlias` entry mapping the double-underscore variant to the
+* same canonical name. Outbound (`aliasByCanonical`) is left untouched —
+* the model still sees the single-underscore canonical on the wire, so
+* the tools-array byte count (and the provider prompt cache) is
+* unaffected.
+*
+* Why: SDK consumers and tool descriptions across the ecosystem
+* inconsistently reference one form or the other (Anthropic's docs use
+* double, zidane uses single). A Claude-Code-trained model emitting
+* `mcp__supabase__apply_migration` against a server zidane registered as
+* `mcp_supabase_apply_migration` would otherwise trip the `tool:unknown`
+* path and waste a turn on the correction.
+*
+* Idempotent: a canonical that already has a double-underscore alias
+* mapped (host's explicit `toolAliases` got there first) is left alone.
+* Tools whose canonical name DOESN'T start with `mcp_` (or that contain
+* no inner separator) are skipped — we don't want to invent aliases for
+* non-MCP tools or malformed names.
+*
+* Mutates `maps.canonicalByAlias` in place and returns the same object
+* for chaining.
+*/
+function augmentMcpDoubleUnderscoreAliases(maps, canonicalNames) {
+	for (const canonical of canonicalNames) {
+		if (!canonical.startsWith("mcp_")) continue;
+		const tail = canonical.slice(4);
+		const sep = tail.indexOf("_");
+		if (sep <= 0 || sep >= tail.length - 1) continue;
+		const doubleForm = `mcp__${tail.slice(0, sep)}__${tail.slice(sep + 1)}`;
+		if (doubleForm === canonical) continue;
+		if (maps.canonicalByAlias.has(doubleForm)) continue;
+		maps.canonicalByAlias.set(doubleForm, canonical);
+	}
+	return maps;
+}
+/**
 * Rewrite `tool_call` block names in a content array from canonical → wire for outbound
 * messages sent to the provider. Mutation is non-destructive (returns a new array).
 */
@@ -326,36 +365,86 @@ function installDedupToolsGate(hooks, getDedupTools, getSession) {
 	function pendingKey(callId, name) {
 		return `${callId}::${name}`;
 	}
+	/**
+	* Resolve the legacy hasher-only form vs the new config-object form to
+	* the same internal shape. Centralised so the gate/after handlers stay
+	* single-branch. Returns `null` when the tool has no dedup config.
+	*/
+	function resolveConfig(name) {
+		const raw = getDedupTools()?.[name];
+		if (!raw) return null;
+		if (typeof raw === "function") return {
+			hasher: raw,
+			mode: "replay",
+			threshold: Infinity,
+			reason: void 0
+		};
+		const threshold = (typeof raw.threshold === "number" && Number.isFinite(raw.threshold) ? Math.max(2, Math.floor(raw.threshold)) : void 0) ?? (raw.mode === "block-after" ? 4 : Infinity);
+		return {
+			hasher: raw.hasher,
+			mode: raw.mode ?? "replay",
+			threshold,
+			reason: raw.reason
+		};
+	}
+	function formatReason(reason, toolName, input, count) {
+		if (typeof reason === "string") return reason;
+		if (typeof reason === "function") try {
+			const out = reason(input, count);
+			if (typeof out === "string" && out.length > 0) return out;
+		} catch {}
+		return `Identical \`${toolName}\` call repeated ${count} times — break the loop by changing your approach or moving on to a different step.`;
+	}
 	function gateHandler(ctx) {
 		if (ctx.block || ctx.result !== void 0) return;
-		const hasher = getDedupTools()?.[ctx.name];
-		if (!hasher) return;
+		const config = resolveConfig(ctx.name);
+		if (!config) return;
 		const state = getToolDedupState(getSession());
 		if (!state) return;
 		let hash;
 		try {
-			hash = hasher(ctx.input);
+			hash = config.hasher(ctx.input);
 		} catch {
 			return;
 		}
 		if (typeof hash !== "string" || hash.length === 0) return;
 		const prior = state.get(ctx.name);
 		if (prior && prior.hash === hash) {
+			const priorRepeats = prior.repeats ?? 0;
+			const count = priorRepeats + 2;
+			if (config.mode === "block-after" && count >= config.threshold) {
+				ctx.block = true;
+				ctx.reason = formatReason(config.reason, ctx.name, ctx.input, count);
+				state.set(ctx.name, {
+					hash,
+					result: prior.result,
+					repeats: priorRepeats + 1
+				});
+				return;
+			}
 			ctx.result = prior.result;
+			pending.set(pendingKey(ctx.callId, ctx.name), {
+				hash,
+				repeats: priorRepeats + 1
+			});
 			return;
 		}
-		pending.set(pendingKey(ctx.callId, ctx.name), hash);
+		pending.set(pendingKey(ctx.callId, ctx.name), {
+			hash,
+			repeats: 0
+		});
 	}
 	function afterHandler(ctx) {
 		const key = pendingKey(ctx.callId, ctx.name);
-		const hash = pending.get(key);
-		if (hash === void 0) return;
+		const entry = pending.get(key);
+		if (entry === void 0) return;
 		pending.delete(key);
 		const state = getToolDedupState(getSession());
 		if (!state) return;
 		state.set(ctx.name, {
-			hash,
-			result: ctx.result
+			hash: entry.hash,
+			result: ctx.result,
+			repeats: entry.repeats
 		});
 	}
 	const unregisterGate = hooks.hook("tool:gate", gateHandler);
@@ -1412,6 +1501,8 @@ async function runLoop(ctx) {
 	const startTime = Date.now();
 	const maxTurns = ctx.maxTurns ?? Number.POSITIVE_INFINITY;
 	let turnsCompleted = 0;
+	const pauseCap = ctx.maxConsecutivePauseTurns ?? 5;
+	let consecutiveEmptyPauseTurns = 0;
 	const ttft = { mark: void 0 };
 	const markTtft = () => {
 		if (ttft.mark === void 0) ttft.mark = Date.now() - ctx.runStartMs;
@@ -1446,6 +1537,10 @@ async function runLoop(ctx) {
 				totalIn,
 				totalOut
 			});
+			if (result.pauseEmpty) {
+				consecutiveEmptyPauseTurns += 1;
+				if (pauseCap > 0 && consecutiveEmptyPauseTurns >= pauseCap) break;
+			} else consecutiveEmptyPauseTurns = 0;
 			if (ctx.signal.aborted) {
 				await ctx.hooks.callHook("agent:abort", {});
 				break;
@@ -1621,6 +1716,106 @@ function extractStreamErrorMeta(err) {
 	}
 	return out;
 }
+/** Defaults applied when `behavior.retry` is absent or has missing fields. */
+const RETRY_DEFAULTS = {
+	maxAttempts: 3,
+	initialDelayMs: 1e3,
+	maxDelayMs: 3e4
+};
+/**
+* Normalize a user-supplied `RetryConfig` (any field may be missing or invalid)
+* into a fully-populated config the retry loop can use without per-field guards.
+*
+* Invalid values (non-finite, < 1 for `maxAttempts`, < 0 for delays) fall back
+* to defaults rather than throwing — this is a behavior knob, not a validation
+* boundary, and a bad value here shouldn't crash a run.
+*/
+function resolveRetryConfig(cfg) {
+	return {
+		maxAttempts: Number.isFinite(cfg?.maxAttempts) && cfg.maxAttempts >= 1 ? Math.floor(cfg.maxAttempts) : RETRY_DEFAULTS.maxAttempts,
+		initialDelayMs: Number.isFinite(cfg?.initialDelayMs) && cfg.initialDelayMs >= 0 ? cfg.initialDelayMs : RETRY_DEFAULTS.initialDelayMs,
+		maxDelayMs: Number.isFinite(cfg?.maxDelayMs) && cfg.maxDelayMs >= 0 ? cfg.maxDelayMs : RETRY_DEFAULTS.maxDelayMs
+	};
+}
+/**
+* Compute the backoff delay for the upcoming retry.
+*
+* Strategy:
+*   - If the server returned `retry-after` / `retry-after-ms`, honor it (capped at `maxDelayMs`).
+*   - Otherwise: `initialDelayMs * 2^(attempt-1)`, capped at `maxDelayMs`, then "full jitter"
+*     (`Math.random() * computed`). Full jitter scatters retries from concurrent clients
+*     across the whole window — empirically better than fixed exponential under thundering-herd
+*     (per AWS Architecture Blog's analysis of EBO+jitter strategies).
+*
+* `attempt` is the 1-indexed number of the attempt that just *failed*, so the first
+* post-failure delay uses `attempt=1` → `initialDelayMs * 1` before jitter.
+*/
+function computeRetryDelayMs(attempt, cfg, retryAfterMs) {
+	if (retryAfterMs !== void 0 && retryAfterMs >= 0) return Math.min(retryAfterMs, cfg.maxDelayMs);
+	const exponential = cfg.initialDelayMs * 2 ** (attempt - 1);
+	const capped = Math.min(exponential, cfg.maxDelayMs);
+	return Math.floor(Math.random() * capped);
+}
+/**
+* Extract a `retry-after` value (in milliseconds) from an error's `.headers`, if any.
+*
+* Supports both `retry-after-ms` (non-standard but Stainless-emitted; already in ms,
+* always integer) and the standard `retry-after` header (integer seconds, RFC 7231).
+* Returns `undefined` when neither is present, non-numeric, or negative.
+*
+* `parseInt` over `parseFloat` here matches the actual contract — Stainless emits
+* `retry-after-ms` as an integer and RFC 7231 specifies a non-negative integer for
+* the seconds form. The HTTP-date form of `retry-after` is deliberately unsupported
+* (Anthropic + OpenAI both emit numeric seconds; supporting dates invites clock-skew
+* concerns for negligible benefit).
+*/
+function extractRetryAfterMs(err) {
+	if (!err || typeof err !== "object") return void 0;
+	const headers = err.headers;
+	if (!headers || typeof headers !== "object") return void 0;
+	const get = (key) => {
+		const h = headers;
+		if (typeof h.get === "function") {
+			const v = h.get(key);
+			return typeof v === "string" ? v : void 0;
+		}
+		const v = h[key];
+		return typeof v === "string" ? v : void 0;
+	};
+	const ms = get("retry-after-ms");
+	if (ms !== void 0) {
+		const parsed = Number.parseInt(ms, 10);
+		if (Number.isFinite(parsed) && parsed >= 0) return parsed;
+	}
+	const seconds = get("retry-after");
+	if (seconds !== void 0) {
+		const parsed = Number.parseInt(seconds, 10);
+		if (Number.isFinite(parsed) && parsed >= 0) return parsed * 1e3;
+	}
+}
+/**
+* `setTimeout` that rejects if the given signal aborts before the timer fires.
+*
+* Resolves with `undefined` on normal completion. Rejects with the signal's
+* `reason` (or a generic AbortError when no reason is set) on abort. Cleans
+* up its `abort` listener in both paths so callers don't leak handlers.
+*/
+function abortableSleep(ms, signal) {
+	if (signal.aborted) return Promise.reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+	return new Promise((resolve, reject) => {
+		let timer;
+		const onAbort = () => {
+			clearTimeout(timer);
+			signal.removeEventListener("abort", onAbort);
+			reject(signal.reason ?? new DOMException("Aborted", "AbortError"));
+		};
+		timer = setTimeout(() => {
+			signal.removeEventListener("abort", onAbort);
+			resolve();
+		}, ms);
+		signal.addEventListener("abort", onAbort, { once: true });
+	});
+}
 async function executeTurn(ctx, turn, priorUsage) {
 	const turnId = await ctx.generateTurnId();
 	let canonicalMessages = turnsToMessages(applyCompactSummaryCutoff(ctx.turns));
@@ -1635,6 +1830,21 @@ async function executeTurn(ctx, turn, priorUsage) {
 		const threshold = typeof ctx.compactThreshold === "number" && ctx.compactThreshold > 0 ? ctx.compactThreshold : 131072;
 		const keep = typeof ctx.compactKeepTurns === "number" && ctx.compactKeepTurns >= 0 ? ctx.compactKeepTurns : 4;
 		sanitizedMessages = applyTailCompaction(sanitizedMessages, threshold, keep);
+	} else if (typeof ctx.compactStrategy === "function") {
+		const threshold = typeof ctx.compactThreshold === "number" && ctx.compactThreshold > 0 ? ctx.compactThreshold : 131072;
+		const keep = typeof ctx.compactKeepTurns === "number" && ctx.compactKeepTurns >= 0 ? ctx.compactKeepTurns : 4;
+		let totalBytes = 0;
+		for (const msg of sanitizedMessages) for (const block of msg.content) if (block.type === "tool_result") totalBytes += toolOutputByteLength(block.output);
+		try {
+			const compacted = await ctx.compactStrategy(sanitizedMessages, {
+				threshold,
+				keepTurns: keep,
+				totalBytes
+			});
+			if (Array.isArray(compacted)) sanitizedMessages = compacted;
+		} catch (err) {
+			console.error("[zidane] compactStrategy function threw:", err);
+		}
 	}
 	const effectiveThinkingBudget = applyThinkingDecay(ctx.thinkingBudget, ctx.thinkingDecay, turn);
 	const formattedTools = ctx.rebuildFormattedTools ? ctx.rebuildFormattedTools() : ctx.formattedTools;
@@ -1668,6 +1878,8 @@ async function executeTurn(ctx, turn, priorUsage) {
 		turnId,
 		options: streamOptions
 	});
+	streamOptions.messages = applyPairingRepair(ctx, streamOptions.messages, turnId);
+	streamOptions.messages = ensureEndsWithUserMessage(streamOptions.messages, ctx.provider);
 	let currentText = "";
 	let currentThinking = "";
 	const streamStartedAt = Date.now();
@@ -1679,74 +1891,104 @@ async function executeTurn(ctx, turn, priorUsage) {
 		turnId,
 		startedAt: streamStartedAt
 	});
+	const retryCfg = resolveRetryConfig(ctx.retry);
 	let result;
-	try {
-		result = await ctx.provider.stream(streamOptions, {
-			onText(delta) {
-				markTurnTtft();
-				currentText += delta;
-				ctx.hooks.callHook("stream:text", {
-					delta,
-					text: currentText,
-					turnId
+	let attempt = 0;
+	while (true) {
+		attempt += 1;
+		try {
+			result = await ctx.provider.stream(streamOptions, {
+				onText(delta) {
+					markTurnTtft();
+					currentText += delta;
+					ctx.hooks.callHook("stream:text", {
+						delta,
+						text: currentText,
+						turnId
+					});
+				},
+				onThinking(delta) {
+					markTurnTtft();
+					currentThinking += delta;
+					ctx.hooks.callHook("stream:thinking", {
+						delta,
+						thinking: currentThinking,
+						turnId
+					});
+				},
+				onOAuthRefresh(refreshCtx) {
+					return ctx.hooks.callHook("oauth:refresh", refreshCtx);
+				}
+			});
+			break;
+		} catch (caught) {
+			let terminalErr = caught;
+			let wasAborted = ctx.signal.aborted || caught instanceof Error && caught.name === "AbortError";
+			const classified = !wasAborted ? ctx.provider.classifyError?.(caught) : null;
+			const isRetryable = classified?.kind === "provider_error" && classified.retryable === true;
+			if (!wasAborted && isRetryable && currentText === "" && currentThinking === "" && attempt < retryCfg.maxAttempts) {
+				const meta = extractStreamErrorMeta(caught);
+				const delayMs = computeRetryDelayMs(attempt, retryCfg, extractRetryAfterMs(caught));
+				await ctx.hooks.callHook("stream:retry", {
+					turnId,
+					attempt,
+					nextAttempt: attempt + 1,
+					delayMs,
+					err: caught,
+					...meta
 				});
-			},
-			onThinking(delta) {
-				markTurnTtft();
-				currentThinking += delta;
-				ctx.hooks.callHook("stream:thinking", {
-					delta,
-					thinking: currentThinking,
-					turnId
+				try {
+					await abortableSleep(delayMs, ctx.signal);
+					continue;
+				} catch {
+					const abortErr = /* @__PURE__ */ new Error("Agent run aborted");
+					abortErr.name = "AbortError";
+					terminalErr = abortErr;
+					wasAborted = true;
+				}
+			}
+			const errorUsage = {
+				input: 0,
+				output: 0
+			};
+			const placeholderText = wasAborted ? "[⏹ Streaming was aborted.]" : buildStreamErrorPlaceholder(terminalErr);
+			const errorContent = currentText ? [{
+				type: "text",
+				text: currentText
+			}] : [{
+				type: "text",
+				text: placeholderText
+			}];
+			const errorTurn = {
+				id: turnId,
+				runId: ctx.runId,
+				role: "assistant",
+				content: errorContent,
+				usage: errorUsage,
+				createdAt: await ctx.clock.now()
+			};
+			ctx.turns.push(errorTurn);
+			if (!wasAborted) {
+				const meta = extractStreamErrorMeta(terminalErr);
+				await ctx.hooks.callHook("stream:error", {
+					err: terminalErr,
+					turnId,
+					...meta
 				});
-			},
-			onOAuthRefresh(refreshCtx) {
-				return ctx.hooks.callHook("oauth:refresh", refreshCtx);
 			}
-		});
-	} catch (err) {
-		const wasAborted = ctx.signal.aborted || err instanceof Error && err.name === "AbortError";
-		const errorUsage = {
-			input: 0,
-			output: 0
-		};
-		const placeholderText = wasAborted ? "[⏹ Streaming was aborted.]" : buildStreamErrorPlaceholder(err);
-		const errorContent = currentText ? [{
-			type: "text",
-			text: currentText
-		}] : [{
-			type: "text",
-			text: placeholderText
-		}];
-		const errorTurn = {
-			id: turnId,
-			runId: ctx.runId,
-			role: "assistant",
-			content: errorContent,
-			usage: errorUsage,
-			createdAt: await ctx.clock.now()
-		};
-		ctx.turns.push(errorTurn);
-		if (!wasAborted) {
-			const meta = extractStreamErrorMeta(err);
-			await ctx.hooks.callHook("stream:error", {
-				err,
+			await ctx.hooks.callHook("turn:after", {
+				turn,
 				turnId,
-				...meta
+				usage: errorUsage,
+				message: errorTurn,
+				toolCounts: {
+					turn: Object.freeze({}),
+					run: Object.freeze({ ...ctx.runToolCounts })
+				},
+				cumulativeUsage: buildCumulativeUsage(priorUsage, errorUsage)
 			});
+			throw wrapProviderError(terminalErr, ctx);
 		}
-		await ctx.hooks.callHook("turn:after", {
-			turn,
-			turnId,
-			usage: errorUsage,
-			message: errorTurn,
-			toolCounts: {
-				turn: Object.freeze({}),
-				run: Object.freeze({ ...ctx.runToolCounts })
-			},
-			cumulativeUsage: buildCumulativeUsage(priorUsage, errorUsage)
-		});
-		throw wrapProviderError(err, ctx);
 	}
 	if (currentText) await ctx.hooks.callHook("stream:end", {
 		text: currentText,
@@ -1844,6 +2086,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 			usage: result.usage
 		};
 	}
+	const finishedEmptyPause = canonicalToolCalls.length === 0 && result.usage.finishReason === "pause" && currentText.length === 0 && currentThinking.length === 0;
 	if (canonicalToolCalls.length === 0 && result.usage.finishReason === "pause") {
 		const continueMsg = ctx.provider.userMessage("Please continue.");
 		ctx.turns.push({
@@ -1856,7 +2099,8 @@ async function executeTurn(ctx, turn, priorUsage) {
 		return {
 			ended: false,
 			turnId,
-			usage: result.usage
+			usage: result.usage,
+			...finishedEmptyPause ? { pauseEmpty: true } : {}
 		};
 	}
 	const toolResults = await executeToolBatch(ctx, canonicalToolCalls, turnId);
@@ -2032,6 +2276,11 @@ async function runSingleToolDispatch(ctx, call, turnId, fixed) {
 	}
 	let effectiveInput = gateCtx.input;
 	if (!toolDef) {
+		await ctx.hooks.callHook("tool:before", {
+			...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
+			runToolCounts,
+			unknown: true
+		});
 		const unknownCtx = {
 			...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
 			suppressError: false
@@ -3431,9 +3680,12 @@ function selectToolSearchMatches(catalog, input, defaultLimit = DEFAULT_LIMIT$1)
 * normal "tool not callable" error on its next attempt, which is the
 * correct response when a tool genuinely no longer exists.
 */
-function applyToolSearchToUnlocked(catalog, input, unlocked, defaultLimit) {
+function applyToolSearchToUnlocked(catalog, input, unlocked, defaultLimit, addUnlock) {
 	const { shown } = selectToolSearchMatches(catalog, input, defaultLimit ?? DEFAULT_LIMIT$1);
-	for (const entry of shown) unlocked.add(entry.canonicalName);
+	for (const entry of shown) {
+		unlocked.add(entry.canonicalName);
+		addUnlock?.(entry.canonicalName);
+	}
 }
 /**
 * Factory for `tool_search`. Auto-injected by the agent when
@@ -3476,7 +3728,10 @@ function createToolSearchTool(options) {
 			if (ctx.signal?.aborted) return "<tool_search_results matches=\"0\" aborted=\"true\">Run aborted.</tool_search_results>";
 			if (options.catalog.length === 0) return "<tool_search_results matches=\"0\">No lazy tools registered for this run.</tool_search_results>";
 			const { shown, total, truncated, misses, query, server } = selectToolSearchMatches(options.catalog, input, defaultLimit);
-			for (const entry of shown) options.unlocked.add(entry.canonicalName);
+			for (const entry of shown) {
+				options.unlocked.add(entry.canonicalName);
+				options.addUnlock?.(entry.canonicalName);
+			}
 			const parts = [];
 			const queryAttr = query ? ` query="${escapeXml(query)}"` : "";
 			const serverAttr = server ? ` server="${escapeXml(server)}"` : "";
@@ -3540,6 +3795,7 @@ const HOOK_EVENT_SET = new Set([
 	"stream:end",
 	"stream:thinking",
 	"stream:error",
+	"stream:retry",
 	"oauth:refresh",
 	"tool:gate",
 	"tool:dispatched",
@@ -3673,6 +3929,7 @@ function resolveBehavior(agentBehavior, runBehavior) {
 		maxConcurrentTools: runBehavior?.maxConcurrentTools ?? agentBehavior?.maxConcurrentTools,
 		maxTurns: runBehavior?.maxTurns ?? agentBehavior?.maxTurns,
 		maxCostUsd: runBehavior?.maxCostUsd ?? agentBehavior?.maxCostUsd,
+		retry: runBehavior?.retry ?? agentBehavior?.retry,
 		maxTotalTokens: runBehavior?.maxTotalTokens ?? agentBehavior?.maxTotalTokens,
 		maxTokens: runBehavior?.maxTokens ?? agentBehavior?.maxTokens,
 		thinkingBudget: runBehavior?.thinkingBudget ?? agentBehavior?.thinkingBudget,
@@ -3692,13 +3949,15 @@ function resolveBehavior(agentBehavior, runBehavior) {
 		elideStaleReads: runBehavior?.elideStaleReads ?? agentBehavior?.elideStaleReads,
 		toolDisclosure: runBehavior?.toolDisclosure ?? agentBehavior?.toolDisclosure ?? "eager",
 		toolSearch: runBehavior?.toolSearch ?? agentBehavior?.toolSearch,
+		surfaceMcpInstructions: runBehavior?.surfaceMcpInstructions ?? agentBehavior?.surfaceMcpInstructions ?? true,
 		persistThreshold: runBehavior?.persistThreshold ?? agentBehavior?.persistThreshold,
 		persistExcludeTools: runBehavior?.persistExcludeTools ?? agentBehavior?.persistExcludeTools,
 		persistDir: runBehavior?.persistDir ?? agentBehavior?.persistDir,
 		persistMaxBytes: runBehavior?.persistMaxBytes ?? agentBehavior?.persistMaxBytes,
 		tasksDir: runBehavior?.tasksDir ?? agentBehavior?.tasksDir,
 		disableBackgroundTasks: runBehavior?.disableBackgroundTasks ?? agentBehavior?.disableBackgroundTasks,
-		strictToolPairing: runBehavior?.strictToolPairing ?? agentBehavior?.strictToolPairing ?? false
+		strictToolPairing: runBehavior?.strictToolPairing ?? agentBehavior?.strictToolPairing ?? false,
+		maxConsecutivePauseTurns: runBehavior?.maxConsecutivePauseTurns ?? agentBehavior?.maxConsecutivePauseTurns
 	};
 }
 /**
@@ -3821,6 +4080,40 @@ function installLazyDisclosureGate(hooks, lazyCanonicalNames, unlocked, discover
 	});
 }
 /**
+* Render the per-server MCP `instructions` payloads into a single
+* `# MCP Server Instructions` section. Matches the shape the Claude Code
+* SDK emits so eval traces stay comparable.
+*
+* Empty / whitespace-only entries are filtered out upstream (see
+* `bootstrapServer`); this function only renders what survived. Callers
+* that pass an empty map get an empty string back — no stub heading.
+*
+* Output shape:
+*
+*     # MCP Server Instructions
+*
+*     ## supabase
+*     The project is provisioned. Use `apply_migration` directly.
+*
+*     ## linear
+*     …
+*
+* Server names are emitted in Map iteration order (config order), which
+* is byte-stable across runs.
+*/
+function renderMcpInstructionsSection(instructions) {
+	if (instructions.size === 0) return "";
+	const parts = ["# MCP Server Instructions", ""];
+	let first = true;
+	for (const [name, body] of instructions) {
+		if (!first) parts.push("");
+		first = false;
+		parts.push(`## ${name}`);
+		parts.push(body.trim());
+	}
+	return parts.join("\n");
+}
+/**
 * 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
@@ -4007,9 +4300,9 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			const thinking = options.thinking ?? "off";
 			const model = options.model ?? provider.meta.defaultModel;
 			const resolvedBehavior = resolveBehavior(agentBehavior, options.behavior);
-			const { maxConcurrentTools, maxTurns, maxCostUsd, maxTotalTokens, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, toolOutputBudgetExcludeTools, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch, persistThreshold, persistExcludeTools, persistDir, persistMaxBytes, strictToolPairing } = resolvedBehavior;
+			const { maxConcurrentTools, maxTurns, maxCostUsd, maxTotalTokens, maxTokens, retry, thinkingBudget, schema, cache, toolOutputBudget, toolOutputBudgetExcludeTools, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch, surfaceMcpInstructions, persistThreshold, persistExcludeTools, persistDir, persistMaxBytes, strictToolPairing, maxConsecutivePauseTurns } = resolvedBehavior;
 			let system = options.system || agentSystem || "You are a helpful assistant.";
-			if (skillsCatalog) system = `${system}\n\n${skillsCatalog}`;
+			if (skillsCatalog) system = appendStaticSection(system, skillsCatalog);
 			const runBaseTools = options.tools !== void 0 ? options.tools : mcpConnection ? {
 				...sourceTools,
 				...mcpConnection.tools
@@ -4041,6 +4334,16 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			});
 			const disclosure = partitionToolDisclosure(toolsPreSearch, mcpToolNames, mcpServers, toolDisclosure, toolAliases);
 			const unlocked = new Set(disclosure.eagerCanonicalNames);
+			const initialUnlocked = new Set(disclosure.eagerCanonicalNames);
+			const dynamicUnlockOrder = [];
+			const dynamicUnlockSeen = /* @__PURE__ */ new Set();
+			function recordDynamicUnlock(canonical) {
+				if (initialUnlocked.has(canonical)) return;
+				if (dynamicUnlockSeen.has(canonical)) return;
+				dynamicUnlockSeen.add(canonical);
+				unlocked.add(canonical);
+				dynamicUnlockOrder.push(canonical);
+			}
 			const hostDefinedToolSearch = !!toolsPreSearch.tool_search;
 			const shouldInjectToolSearch = disclosure.lazyEntries.length > 0 && toolSearch?.tool !== false && !hostDefinedToolSearch;
 			let tools = toolsPreSearch;
@@ -4048,6 +4351,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 				const toolSearchTool = createToolSearchTool({
 					catalog: disclosure.lazyEntries,
 					unlocked,
+					addUnlock: recordDynamicUnlock,
 					...toolSearch?.limit !== void 0 ? { defaultLimit: toolSearch.limit } : {}
 				});
 				tools = {
@@ -4055,14 +4359,29 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					[toolSearchTool.spec.name]: toolSearchTool
 				};
 				unlocked.add(toolSearchTool.spec.name);
+				initialUnlocked.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 })}`;
+			if (disclosure.lazyEntries.length > 0) system = appendStaticSection(system, buildSearchableCatalog(disclosure.lazyEntries, { discoveryToolName }));
+			if (surfaceMcpInstructions && mcpConnection?.instructions && mcpConnection.instructions.size > 0) {
+				const section = renderMcpInstructionsSection(mcpConnection.instructions);
+				if (section.length > 0) system = appendStaticSection(system, section);
+			}
 			const aliasMaps = buildAliasMaps(toolAliases, Object.keys(tools));
+			augmentMcpDoubleUnderscoreAliases(aliasMaps, Object.keys(tools));
 			function buildFormattedTools() {
 				const specs = [];
 				for (const t of Object.values(tools)) {
-					if (!unlocked.has(t.spec.name)) continue;
+					if (!initialUnlocked.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
+					});
+				}
+				for (const canonical of dynamicUnlockOrder) {
+					const t = tools[canonical];
+					if (!t) continue;
 					specs.push({
 						name: aliasMaps.aliasByCanonical.get(t.spec.name) ?? t.spec.name,
 						description: t.spec.description || "",
@@ -4085,7 +4404,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 						if (block.type !== "tool_call") continue;
 						if (block.name !== "tool_search") continue;
 						if (!resolvedCallIds.has(block.id)) continue;
-						applyToolSearchToUnlocked(disclosure.lazyEntries, block.input, unlocked, toolSearch?.limit);
+						applyToolSearchToUnlocked(disclosure.lazyEntries, block.input, unlocked, toolSearch?.limit, recordDynamicUnlock);
 					}
 				}
 			}
@@ -4206,6 +4525,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					maxTurns,
 					...maxCostUsd !== void 0 ? { maxCostUsd } : {},
 					...maxTotalTokens !== void 0 ? { maxTotalTokens } : {},
+					...retry !== void 0 ? { retry } : {},
 					maxTokens,
 					...session ? { session } : {},
 					...agentReadState ? { readState: agentReadState } : {},
@@ -4226,6 +4546,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					...persistDir !== void 0 ? { persistDir } : {},
 					...persistMaxBytes !== void 0 ? { persistMaxBytes } : {},
 					...strictToolPairing ? { strictToolPairing: true } : {},
+					...maxConsecutivePauseTurns !== void 0 ? { maxConsecutivePauseTurns } : {},
 					providerName: provider.name,
 					runStartMs,
 					runToolCounts: {},
@@ -4523,7 +4844,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 		get activeSkills() {
 			return skillActivationState.active();
 		},
-		meta: Object.freeze({ ...provider.meta })
+		meta: Object.freeze({ ...provider.meta }),
+		[Symbol.asyncDispose]: destroy
 	};
 }
 //#endregion
@@ -4799,7 +5121,7 @@ const edit = {
 			properties: {
 				path: {
 					type: "string",
-					description: "Relative file path."
+					description: "File path (relative to the execution-context cwd, or absolute)."
 				},
 				old_string: {
 					type: "string",
@@ -4904,12 +5226,19 @@ function sharedPrefixLength(a, b) {
 /**
 * Glob-pattern file matching.
 *
-* Uses Bun's native `Bun.Glob` engine when running in the in-process execution
-* context. For non-process contexts (docker, sandbox), falls back to running
-* the pattern through a shell `find` invocation so the match is executed
-* wherever the context lives.
+* Uses the Node `fs/promises` `glob` API in the in-process execution
+* context (Bun ≥1.3 re-implements the same module-level entry, so the
+* same code path serves both runtimes). For non-process contexts
+* (docker, sandbox), falls back to running the pattern through a shell
+* `find` invocation so the match is executed wherever the context lives.
+*
+* Behavioral note: Node's `fs.glob` yields directories alongside files
+* and Bun's port doesn't yet accept `withFileTypes`, so we post-filter
+* with `stat` to keep the historical files-only contract.
 *
-* Results are capped at 1000 entries to keep model input bounded.
+* Results are capped at 1000 entries to keep model input bounded. The
+* cap applies after the directory filter, so dirs don't consume the
+* file budget.
 *
 * By default each row carries `<path>\t<size>\t<mtime>` metadata so the
 * model can rank "what changed recently" without a follow-up `read_file`.
@@ -4921,10 +5250,14 @@ function sharedPrefixLength(a, b) {
 const DEFAULT_LIMIT = 1e3;
 const SAFE_GLOB_PATTERN_RE = /^[\w./*?[\]{}!,^@+-]+$/;
 async function globInProcess(pattern, cwd, limit) {
-	const glob = new Bun.Glob(pattern);
 	const results = [];
-	for await (const file of glob.scan({ cwd })) {
-		results.push(file);
+	for await (const rel of glob(pattern, { cwd })) {
+		try {
+			if (!(await stat(resolve(cwd, rel))).isFile()) continue;
+		} catch {
+			continue;
+		}
+		results.push(rel);
 		if (results.length >= limit) break;
 	}
 	return results.sort();
@@ -4936,7 +5269,7 @@ async function globViaShell(pattern, ctx, limit) {
 	if (result.exitCode !== 0 && !result.stdout) return [];
 	return result.stdout.split("\n").filter((line) => line.length > 0);
 }
-const glob = {
+const glob$1 = {
 	isConcurrencySafe: true,
 	spec: {
 		name: "glob",
@@ -4986,10 +5319,10 @@ const glob = {
 /**
 * Search file contents by regex.
 *
-* Wraps ripgrep (`rg`) when available, falls back to an in-process Bun.Glob +
-* regex implementation when running in the in-process execution context. For
-* non-process contexts without `rg`, returns a clear hint rather than silently
-* doing nothing.
+* Wraps ripgrep (`rg`) when available, falls back to an in-process
+* `fs/promises` `glob` + regex implementation when running in the
+* in-process execution context. For non-process contexts without `rg`,
+* returns a clear hint rather than silently doing nothing.
 *
 * The tool surface mirrors Claude Code's `Grep` so models authored against the
 * Anthropic tool surface need no relearning. Output modes:
@@ -5006,7 +5339,7 @@ const grep = {
 	isConcurrencySafe: true,
 	spec: {
 		name: "grep",
-		description: "Search file contents by regex. Returns matching paths (default), match content, or per-file counts. Backed by ripgrep when available with a Bun.Glob fallback for in-process runs.",
+		description: "Search file contents by regex. Returns matching paths (default), match content, or per-file counts. Backed by ripgrep when available with an in-process glob fallback for in-process runs.",
 		inputSchema: {
 			type: "object",
 			properties: {
@@ -5190,13 +5523,12 @@ async function enumerateFiles(input, ctx) {
 		if ((await ctx.execution.exec(ctx.handle, `test -f ${shellQuote(input.path)} && echo file || echo dir`)).stdout.trim() === "file") return [input.path];
 	} catch {}
 	const pattern = input.glob ?? "**/*";
-	const glob = new Bun.Glob(pattern);
-	const out = [];
 	const scanRoot = root === "." ? cwd : `${cwd.replace(/\/$/, "")}/${root.replace(/^\.\//, "")}`;
-	for await (const file of glob.scan({
-		cwd: scanRoot,
-		onlyFiles: true
-	})) out.push(root === "." ? file : `${root.replace(/\/$/, "")}/${file}`);
+	const prefix = root === "." ? "" : `${root.replace(/\/$/, "")}/`;
+	const out = [];
+	for await (const rel of glob(pattern, { cwd: scanRoot })) try {
+		if ((await stat(resolve(scanRoot, rel))).isFile()) out.push(prefix ? `${prefix}${rel}` : rel);
+	} catch {}
 	return out.sort();
 }
 function formatPaginated(text, input) {
@@ -5242,12 +5574,12 @@ const listFiles = {
 	isConcurrencySafe: true,
 	spec: {
 		name: "list_files",
-		description: "List files and directories at the given path (relative to project root).",
+		description: "List the immediate entries (files and subdirectories) at `path`. Returns a newline-separated list, or `(empty directory)` when the directory exists but is empty. Returns `Directory not found: <path>` for a missing path. Non-recursive — use `glob` for pattern matching across nested directories.",
 		inputSchema: {
 			type: "object",
 			properties: { path: {
 				type: "string",
-				description: "Relative directory path (default: \".\")"
+				description: "Directory path (relative to the execution-context cwd, or absolute). Defaults to `.`."
 			} },
 			required: []
 		}
@@ -5294,7 +5626,7 @@ const multiEdit = {
 			properties: {
 				path: {
 					type: "string",
-					description: "Relative file path."
+					description: "File path (relative to the execution-context cwd, or absolute)."
 				},
 				edits: {
 					type: "array",
@@ -5504,7 +5836,7 @@ const readFile$1 = {
 			properties: {
 				path: {
 					type: "string",
-					description: "Relative file path."
+					description: "File path (relative to the execution-context cwd, or absolute)."
 				},
 				offset: {
 					type: "integer",
@@ -5720,6 +6052,62 @@ function extractText(message) {
 	return "";
 }
 /**
+* Read-only tool whitelist applied when a subagent preset has
+* `readonly: true` and no explicit `tools` list. Intentionally narrow —
+* only obviously non-mutating built-ins. Hosts wanting a different
+* read-only profile (e.g. include `glob` for a code-search agent) should
+* pass an explicit `tools` array on the subagent def.
+*/
+const READONLY_TOOL_DEFAULTS = [
+	"read_file",
+	"grep",
+	"glob",
+	"list_files"
+];
+/**
+* Apply a subagent preset's tool filter to the parent's tool registry.
+* Always a strict subset of the input — the child agent never gains
+* tools the parent doesn't have. Names that don't match a parent tool
+* are silently dropped (matches MCP's lenient `enabledTools` behavior).
+*
+* Precedence: `def.tools` (explicit list) > `def.readonly: true`
+* (built-in read-only set) > unfiltered.
+*/
+function filterToolsForSubagent(parentTools, def) {
+	if (!parentTools) return parentTools;
+	const explicit = def.tools;
+	if (explicit && explicit.length > 0) {
+		const wanted = new Set(explicit);
+		const filtered = {};
+		for (const [registryKey, t] of Object.entries(parentTools)) if (wanted.has(t.spec.name)) filtered[registryKey] = t;
+		return filtered;
+	}
+	if (def.readonly) {
+		const wanted = new Set(READONLY_TOOL_DEFAULTS);
+		const filtered = {};
+		for (const [registryKey, t] of Object.entries(parentTools)) if (wanted.has(t.spec.name)) filtered[registryKey] = t;
+		return filtered;
+	}
+	return parentTools;
+}
+/**
+* Render the per-type descriptions into a single schema-field
+* description string the model reads when choosing a `subagent_type`.
+* Falls back to a generic line when the host didn't supply any per-type
+* descriptions.
+*/
+function buildSubagentTypeDescription(registry) {
+	const lines = [];
+	let hasAny = false;
+	for (const [key, def] of Object.entries(registry)) if (def.description) {
+		lines.push(`- "${key}": ${def.description}`);
+		hasAny = true;
+	} else lines.push(`- "${key}"`);
+	lines.push("- \"general-purpose\": no specialization; uses the spawn tool's default config.");
+	if (!hasAny) return `Optional subagent preset. One of: ${lines.map((l) => l.replace(/^- /, "").replace(/:.*$/, "")).join(", ")}.`;
+	return `Optional subagent preset that overlays the spawn tool's defaults.\n${lines.join("\n")}`;
+}
+/**
 * Race `task` (an already-running child `agent.run()` promise) against a
 * timer. Does NOT race against the parent abort signal — the child agent
 * already observes the same signal internally and handles its own aborted
@@ -5856,6 +6244,8 @@ function createSpawnTool(options = {}) {
 		turns: 0,
 		elapsed: 0
 	};
+	const subagentRegistry = options.subagents;
+	const subagentTypeKeys = !!subagentRegistry && Object.keys(subagentRegistry).length > 0 ? [...new Set([...Object.keys(subagentRegistry), "general-purpose"])] : [];
 	return {
 		get children() {
 			return localChildren;
@@ -5877,7 +6267,12 @@ function createSpawnTool(options = {}) {
 					system: {
 						type: "string",
 						description: "Optional system prompt override for this specific sub-agent."
-					}
+					},
+					...subagentTypeKeys.length > 0 ? { subagent_type: {
+						type: "string",
+						enum: subagentTypeKeys,
+						description: buildSubagentTypeDescription(subagentRegistry)
+					} } : {}
 				},
 				required: ["task"]
 			}
@@ -5885,6 +6280,8 @@ function createSpawnTool(options = {}) {
 		async execute(input, ctx) {
 			const task = input.task;
 			const systemOverride = input.system;
+			const requestedSubagentType = typeof input.subagent_type === "string" ? input.subagent_type : void 0;
+			const subagentDef = requestedSubagentType && subagentRegistry ? subagentRegistry[requestedSubagentType] ?? void 0 : void 0;
 			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 }).`;
@@ -5905,10 +6302,11 @@ function createSpawnTool(options = {}) {
 			let result = "";
 			let unbubble;
 			try {
+				const filteredTools = subagentDef ? filterToolsForSubagent(ctx.tools, subagentDef) : ctx.tools;
 				const parentPreset = {
 					...ctx.name !== void 0 ? { name: ctx.name } : {},
 					...ctx.system !== void 0 ? { system: ctx.system } : {},
-					tools: ctx.tools,
+					tools: filteredTools,
 					...ctx.toolAliases !== void 0 ? { toolAliases: ctx.toolAliases } : {},
 					...ctx.mcpServers !== void 0 ? { mcpServers: ctx.mcpServers } : {},
 					...ctx.skills !== void 0 ? { skills: ctx.skills } : {},
@@ -5948,10 +6346,11 @@ function createSpawnTool(options = {}) {
 				};
 				await ctx.hooks.callHook("spawn:before", spawnHookCtx);
 				const propagatedTracing = Object.keys(spawnHookCtx.tracingContext).length > 0 ? Object.freeze({ ...spawnHookCtx.tracingContext }) : void 0;
+				const effectiveSystem = systemOverride ?? subagentDef?.system ?? options.system;
 				const runPromise = agent.run({
 					prompt: task,
 					model: options.model,
-					system: systemOverride ?? options.system,
+					system: effectiveSystem,
 					thinking: options.thinking,
 					signal: ctx.signal,
 					depth: childDepth,
@@ -6088,17 +6487,17 @@ function createSpawnTool(options = {}) {
 const writeFile$1 = {
 	spec: {
 		name: "write_file",
-		description: "Write content to a file (creates parent directories). Returns Created / Updated / \"No change needed\" so the model can detect no-ops without a separate read.",
+		description: "Write `content` to `path`, creating any missing parent directories. Overwrites existing files in full; prefer `edit` / `multi_edit` for surgical changes when you only want to alter part of a file. Returns one of: `Created <path> (N bytes)` (file did not exist), `Updated <path> (N bytes)` (content differed), or `No change needed: <path> already at target state (N bytes)` — so the model can detect no-ops without a separate `read_file`.",
 		inputSchema: {
 			type: "object",
 			properties: {
 				path: {
 					type: "string",
-					description: "Relative file path."
+					description: "File path (relative to the execution-context cwd, or absolute)."
 				},
 				content: {
 					type: "string",
-					description: "File content."
+					description: "Complete file content. Overwrites any existing file at `path`."
 				}
 			},
 			required: ["path", "content"]
@@ -6118,6 +6517,6 @@ const writeFile$1 = {
 	}
 };
 //#endregion
-export { resolvePersistDir as A, formatTaskStatus as B, TOOL_USE_SKIPPED_MESSAGE as C, buildPersistedStub as D, PERSISTENCE_PREVIEW_BYTES as E, resolveReadStateMap as F, previewLine as H, ageString as I, compactPath as L, getReadState as M, hashContent as N, cleanupPersistedSession as O, readStateKey as P, fmtTokens as R, TOOL_USE_CANCELLED_MESSAGE as S, PERSISTED_STUB_PREFIX as T, shortId as U, formatTaskSummary as V, createSkillsReadTool as _, multiEdit as a, INTERRUPT_MESSAGE_FOR_TOOL_USE as b, grep as c, resolveOldString as d, styleReplacementForVia as f, createSkillsRunScriptTool as g, createSkillsUseTool as h, readFile$1 as i, resolveTasksDir as j, maybePersistToolResult as k, glob as l, createToolSearchTool as m, createSpawnTool as n, listFiles as o, createAgent as p, shellKill as r, createInteractionTool as s, writeFile$1 as t, edit as u, createShellTool as v, validateToolArgs as w, SHELL_CASCADE_CANCEL_MESSAGE as x, shell as y, formatDuration as z };
+export { resolvePersistDir as A, formatTaskStatus as B, TOOL_USE_SKIPPED_MESSAGE as C, buildPersistedStub as D, PERSISTENCE_PREVIEW_BYTES as E, resolveReadStateMap as F, previewLine as H, ageString as I, compactPath as L, getReadState as M, hashContent as N, cleanupPersistedSession as O, readStateKey as P, fmtTokens as R, TOOL_USE_CANCELLED_MESSAGE as S, PERSISTED_STUB_PREFIX as T, shortId as U, formatTaskSummary as V, createSkillsReadTool as _, multiEdit as a, INTERRUPT_MESSAGE_FOR_TOOL_USE as b, grep as c, resolveOldString as d, styleReplacementForVia as f, createSkillsRunScriptTool as g, createSkillsUseTool as h, readFile$1 as i, resolveTasksDir as j, maybePersistToolResult as k, glob$1 as l, createToolSearchTool as m, createSpawnTool as n, listFiles as o, createAgent as p, shellKill as r, createInteractionTool as s, writeFile$1 as t, edit as u, createShellTool as v, validateToolArgs as w, SHELL_CASCADE_CANCEL_MESSAGE as x, shell as y, formatDuration as z };
 
-//# sourceMappingURL=tools-CxOfTt3R.js.map
+//# sourceMappingURL=tools-DE9pR_NG.js.map