zidane 5.13.11 → 5.13.13

package/dist/{tools-DhzKzB1y.js → tools-BvATiiCO.js}

@@ -1,17 +1,17 @@
-import { F as canonicalizePrompt, O as appendStaticSection, P as buildPromptMessage, R as fnv1aBase36, a as detectTurnInterruption, c as filterUnresolvedToolUses, d as remintDuplicateToolCallIds, f as resolveContentRefsInMessages, j as renderSystemForWire, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureEndsWithUserMessage, s as ensureToolResultPairing } from "./messages-DEsLGBB9.js";
+import { F as canonicalizePrompt, O as appendStaticSection, P as buildPromptMessage, R as fnv1aBase36, a as detectTurnInterruption, c as filterUnresolvedToolUses, d as remintDuplicateToolCallIds, f as resolveContentRefsInMessages, j as renderSystemForWire, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureEndsWithUserMessage, s as ensureToolResultPairing } from "./messages-U_87Z7GH.js";
 import { n as estimateTokens, r as utf8ByteLength } from "./utils-ngQzYzZD.js";
 import { t as buildContextBreakdown } from "./context-breakdown-kO-pDsay.js";
 import { a as formatTaskStatus, i as formatDuration, o as formatTaskSummary, s as previewLine } from "./format-BNOXpl-1.js";
 import { r as createProcessContext, t as resolveDetachedTasksCapability } from "./contexts-DHi8LPCp.js";
-import { a as toolOutputByteLength, i as toolOutputBudgetByteLength, o as toolResultToText, r as documentBlockMarker, t as DEFAULT_AGENT_CLOCK } from "./types-DxHDaqN7.js";
+import { a as toolOutputBudgetByteLength, i as documentBlockMarker, o as toolOutputByteLength, s as toolResultToText, t as DEFAULT_AGENT_CLOCK } from "./types-CyVGdbia.js";
 import { i as styleReplacementForVia, n as resolveOldString, r as stripLineNumberPrefixes, t as describeVia } from "./edit-utils-EGosADZq.js";
-import { a as markReadStateElided, n as getToolDedupState, o as readStateKey, r as hashContent, s as resolveReadStateMap, t as getReadState } from "./read-state-DH2IuQHX.js";
+import { a as markReadStateElided, n as getToolDedupState, o as readStateKey, r as hashContent, s as resolveReadStateMap, t as getReadState } from "./read-state-CLK9yVpm.js";
 import { i as AgentProviderError, l as errorMessage, m as toTypedError, n as AgentBudgetExceededError, o as AgentToolPairingError, t as AgentAbortedError, u as isAbortLikeError } from "./errors-BpPfMo_4.js";
 import { n as reconcileImageMediaType } from "./media-sniff-Bn76JxAu.js";
 import { n as writeFileAtomicAsync } from "./atomic-write-Bgtr5JPu.js";
 import { S as escapeXml, d as buildCatalog, n as stripShellInterpolations, p as installAllowedToolsGate, r as resolveSkills, t as interpolateShellCommands, v as validateResourcePathReal, x as createSkillActivationState } from "./interpolate-ConAiXGy.js";
 import { n as flattenTurns, r as formatTokenUsage, t as effectiveInputFromTurn } from "./stats-DAKBEKjc.js";
-import { n as connectMcpServers, s as wrapDiscoveredMcpTools } from "./mcp-C_TIj91j.js";
+import { n as connectMcpServers, s as wrapDiscoveredMcpTools } from "./mcp-2OGi_NQu.js";
 import { n as shellQuote, t as alwaysQuote } from "./shell-quote-BmnhZmdM.js";
 import { isAbsolute, join, resolve } from "node:path";
 import { createHooks } from "hookable";
@@ -2506,6 +2506,31 @@ const SHELL_CASCADE_CANCEL_MESSAGE = "Cancelled: a sibling `shell` call in the s
 */
 const CANCELLED_BY_USER_SENTINEL = "zidane:tool:cancelled-by-user";
 /**
+* Compose the run-scoped `ctx.signal` and a per-call abort into one child
+* signal for a tool body — WITHOUT `AbortSignal.any`.
+*
+* `AbortSignal.any([runSignal, perCall])` registers a dependent-signal
+* algorithm on each source; the run signal is long-lived (whole run), so one
+* composite per tool call accumulates on it until the composite is GC'd —
+* a slow leak across a long run with many calls. Manual `linkAbortSignal`
+* listeners removed in `dispose()` keep the run signal's listener set bounded
+* to currently-dispatching calls. `dispose()` MUST be called once the body has
+* settled. `reason` propagates from whichever source fires first (so a
+* signal-aware body still sees the per-call cancel reason).
+*/
+function composePerCallSignal(runSignal, perCallSignal) {
+	const controller = new AbortController();
+	const unlinkRun = linkAbortSignal(runSignal, controller);
+	const unlinkPerCall = linkAbortSignal(perCallSignal, controller);
+	return {
+		signal: controller.signal,
+		dispose: () => {
+			unlinkRun();
+			unlinkPerCall();
+		}
+	};
+}
+/**
 * Grace window after a run-level abort before we force-settle a tool body that
 * hasn't returned. Well-behaved tools observe `childSignal` and finalize their
 * own bookkeeping (e.g. `spawn` awaits its child's session-persisting `finally`
@@ -4310,7 +4335,7 @@ async function executeSingleTool(ctx, call, turnId) {
 	const displayName = toWireName(call.name, ctx.aliasMaps);
 	const runToolCounts = Object.freeze({ ...ctx.runToolCounts });
 	const perCallAbort = new AbortController();
-	ctx.pendingToolCancels?.set(callId, perCallAbort);
+	ctx.toolCancels?.register(callId, perCallAbort);
 	try {
 		return await runSingleToolDispatch(ctx, call, turnId, {
 			toolDef,
@@ -4320,7 +4345,7 @@ async function executeSingleTool(ctx, call, turnId) {
 			perCallAbort
 		});
 	} finally {
-		ctx.pendingToolCancels?.delete(callId);
+		ctx.toolCancels?.unregister(callId);
 	}
 }
 /**
@@ -4440,7 +4465,8 @@ async function runSingleToolDispatch(ctx, call, turnId, fixed) {
 	let isError = false;
 	let cancelledByUser = false;
 	let reportedOutcome;
-	const childSignal = typeof AbortSignal.any === "function" ? AbortSignal.any([ctx.signal, perCallAbort.signal]) : ctx.signal;
+	const composedSignal = composePerCallSignal(ctx.signal, perCallAbort.signal);
+	const childSignal = composedSignal.signal;
 	try {
 		const toolCtx = {
 			provider: ctx.provider,
@@ -4505,6 +4531,7 @@ async function runSingleToolDispatch(ctx, call, turnId, fixed) {
 			removeAbortListener?.();
 			removeRunAbortListener?.();
 			if (runAbortTimer !== void 0) clearTimeout(runAbortTimer);
+			composedSignal.dispose();
 		}
 	} catch (err) {
 		const isOurSentinel = err instanceof Error && err.message === CANCELLED_BY_USER_SENTINEL;
@@ -4852,7 +4879,10 @@ async function executeCustomToolBatch(ctx, toolCalls, turnId, executor) {
 				isError: true
 			});
 		} finally {
-			for (const start of starts) childCtx.pendingToolCancels?.delete(start.callId);
+			for (const start of starts) {
+				childCtx.toolCancels?.unregister(start.callId);
+				start.disposeSignal();
+			}
 		}
 	};
 	const executionCtx = {
@@ -4903,9 +4933,9 @@ async function startDurableToolExecution(ctx, call, turnId, index) {
 	const displayName = toWireName(call.name, ctx.aliasMaps);
 	const runToolCounts = Object.freeze({ ...ctx.runToolCounts });
 	const perCallAbort = new AbortController();
-	ctx.pendingToolCancels?.set(callId, perCallAbort);
+	ctx.toolCancels?.register(callId, perCallAbort);
 	const cleanupResult = (result) => {
-		ctx.pendingToolCancels?.delete(callId);
+		ctx.toolCancels?.unregister(callId);
 		return {
 			kind: "result",
 			result
@@ -5015,7 +5045,8 @@ async function startDurableToolExecution(ctx, call, turnId, index) {
 		runToolCounts,
 		...coercions ? { coercions } : {}
 	});
-	const childSignal = typeof AbortSignal.any === "function" ? AbortSignal.any([ctx.signal, perCallAbort.signal]) : ctx.signal;
+	const composedSignal = composePerCallSignal(ctx.signal, perCallAbort.signal);
+	const childSignal = composedSignal.signal;
 	let reportedOutcome;
 	const toolCtx = {
 		provider: ctx.provider,
@@ -5055,6 +5086,7 @@ async function startDurableToolExecution(ctx, call, turnId, index) {
 			input: effectiveInput,
 			runToolCounts,
 			perCallAbort,
+			disposeSignal: composedSignal.dispose,
 			...coercions ? { coercions } : {},
 			promise: durableExecute(effectiveInput, toolCtx),
 			reportedOutcome: () => reportedOutcome
@@ -5682,6 +5714,84 @@ function defaultHardBlockMessage(tool, count, hardMax) {
 	return `Tool '${tool}' has been called ${count} times this run, past its hard ceiling of ${hardMax} — the earlier budget warning was not heeded. Further invocations are refused; finish the task with the information you already have.`;
 }
 //#endregion
+//#region src/tool-cancel.ts
+/**
+* Per-call tool-cancellation registry shared between the agent and the loop.
+*
+* The loop registers an `AbortController` for each tool call right before it
+* dispatches (gate → execute), and unregisters it in a `finally`, so the live
+* map only ever holds *currently dispatching* calls. `agent.cancelTool(callId)`
+* flips the matching call's controller without unwinding the rest of the run.
+*
+* Two subtleties this registry owns so callers don't have to:
+*
+*  - **Pre-registration race.** A host can learn a call's id from the streamed
+*    assistant turn and ask to cancel it BEFORE the loop has dispatched it
+*    (very reachable under the sequential `maxConcurrentTools: 1` default —
+*    later calls in a batch register only when their turn comes). A cancel for
+*    an un-registered id is parked in a bounded FIFO and applied the instant
+*    the call registers, instead of being silently dropped.
+*
+*  - **Bounded parking.** Parked kills for ids that never dispatch (a
+*    hallucinated id, a call the model retracted) can't accumulate: the FIFO
+*    evicts oldest past its cap, and the agent clears it at run boundaries so a
+*    stale kill never leaks across runs onto a later call that happens to reuse
+*    the same id.
+*/
+/** Fallback reason stamped on the abort signal when `cancel` gets no explicit reason. */
+const DEFAULT_KILL_MESSAGE = "user-cancelled-tool";
+/** Upper bound on parked pre-registration kills — FIFO-evicted past this. */
+const DEFAULT_MAX_PENDING_KILLS = 64;
+function createToolCancelRegistry(options = {}) {
+	const defaultMessage = options.defaultMessage ?? DEFAULT_KILL_MESSAGE;
+	const maxPending = typeof options.maxPendingKills === "number" && options.maxPendingKills > 0 ? Math.floor(options.maxPendingKills) : DEFAULT_MAX_PENDING_KILLS;
+	const live = /* @__PURE__ */ new Map();
+	const pending = /* @__PURE__ */ new Map();
+	function park(callId, reason) {
+		pending.delete(callId);
+		pending.set(callId, reason);
+		while (pending.size > maxPending) {
+			const oldest = pending.keys().next().value;
+			if (oldest === void 0) break;
+			pending.delete(oldest);
+		}
+	}
+	function applyParked(callId, controller) {
+		const reason = pending.get(callId);
+		if (reason === void 0) return;
+		pending.delete(callId);
+		if (!controller.signal.aborted) controller.abort(reason);
+	}
+	return {
+		register(callId, controller) {
+			live.set(callId, controller);
+			applyParked(callId, controller);
+		},
+		unregister(callId) {
+			live.delete(callId);
+		},
+		cancel(callId, reason) {
+			const message = reason ?? defaultMessage;
+			const controller = live.get(callId);
+			if (controller) {
+				if (controller.signal.aborted) return false;
+				controller.abort(message);
+				return true;
+			}
+			park(callId, message);
+			return false;
+		},
+		abortAll(reason) {
+			for (const controller of live.values()) if (!controller.signal.aborted) controller.abort(reason);
+			live.clear();
+			pending.clear();
+		},
+		clearPending() {
+			pending.clear();
+		}
+	};
+}
+//#endregion
 //#region src/tools/shell-semantics.ts
 const DEFAULT_SEMANTIC = (exitCode) => ({
 	isError: exitCode !== 0,
@@ -5728,6 +5838,61 @@ function extractTrailingCommand(command) {
 	return (segments[segments.length - 1]?.trim() ?? command).split(/\s+/).filter((t) => !/^[A-Z_]\w*=/i.test(t))[0] ?? "";
 }
 //#endregion
+//#region src/tools/truncate.ts
+/**
+* Tail-priority, byte-budgeted truncation shared across tools.
+*
+* "Tail-priority" because the most useful signal in command / job output
+* (errors, exit summaries, the last thing that happened) lives at the END.
+* When `text` exceeds the byte budget the HEAD is dropped and replaced with a
+* marker, keeping as much of the tail as fits.
+*
+* The budget is a UTF-8 *byte* count, not a character count — wire/output
+* accounting is bytes, and a naive `String.prototype.slice` (UTF-16 code
+* units) under-counts multibyte text badly. The cut always lands on a whole
+* code point: the walk steps by code point (surrogate pairs included), so an
+* emoji or CJK glyph is never split into a lone surrogate. As a final safety
+* net against callers that hand us text already sliced mid-codepoint at a raw
+* byte boundary (the classic `Buffer.subarray(...).toString()` pattern, which
+* decodes a partial lead/continuation byte to U+FFFD), a leading run of
+* replacement characters is stripped from the kept tail.
+*/
+function defaultMarker(droppedBytes) {
+	return `…(${droppedBytes} bytes truncated from head)…\n`;
+}
+/**
+* Keep the last `maxBytes` UTF-8 bytes of `text`, dropping the head and
+* prefixing a marker. A non-positive `maxBytes` disables truncation and
+* returns `text` unchanged.
+*
+* `maxBytes` budgets the kept tail only; the marker is added on top and may
+* push the returned string slightly past `maxBytes`. That tradeoff is
+* intentional — folding the marker into the budget would shrink the content
+* actually shown.
+*/
+function tailTruncate(text, maxBytes, options = {}) {
+	if (!Number.isFinite(maxBytes) || maxBytes <= 0) return text;
+	const totalBytes = Buffer.byteLength(text);
+	if (totalBytes <= maxBytes) return text;
+	let bytes = 0;
+	let cut = text.length;
+	while (cut > 0) {
+		let start = cut - 1;
+		const code = text.charCodeAt(start);
+		if (code >= 56320 && code <= 57343 && start > 0) {
+			const high = text.charCodeAt(start - 1);
+			if (high >= 55296 && high <= 56319) start -= 1;
+		}
+		const codePointBytes = Buffer.byteLength(text.slice(start, cut));
+		if (bytes + codePointBytes > maxBytes) break;
+		bytes += codePointBytes;
+		cut = start;
+	}
+	const tail = text.slice(cut).replace(/^\uFFFD+/, "");
+	const droppedBytes = totalBytes - Buffer.byteLength(tail);
+	return `${(options.marker ?? defaultMarker)(droppedBytes)}${tail}`;
+}
+//#endregion
 //#region src/tools/shell.ts
 /**
 * Execute a shell command in the agent's execution context.
@@ -6011,19 +6176,19 @@ function createShellTool(opts = {}) {
 			const cap = normalizeCap(maxOutputBytes);
 			const semantic = interpretShellResult(cmd, result.exitCode);
 			if (result.exitCode === 0) {
-				const stdoutTail = truncateTail(result.stdout || "(no output)", cap);
+				const stdoutTail = tailTruncate(result.stdout || "(no output)", cap);
 				if (!wantMetadata) return stdoutTail;
 				const stderrTrimmed = result.stderr.trim();
-				return `${stdoutTail}${stderrTrimmed ? `\n[stderr]\n${truncateTail(stderrTrimmed, Math.min(cap, 2048))}` : ""}\n(exit 0, ${durationMs}ms)`;
+				return `${stdoutTail}${stderrTrimmed ? `\n[stderr]\n${tailTruncate(stderrTrimmed, Math.min(cap, 2048))}` : ""}\n(exit 0, ${durationMs}ms)`;
 			}
 			if (!semantic.isError) {
-				const tail = truncateTail((result.stdout || result.stderr || "").trim(), cap);
+				const tail = tailTruncate((result.stdout || result.stderr || "").trim(), cap);
 				const semanticFooter = semantic.message ? `\n(${semantic.message})` : "";
 				const timingFooter = wantMetadata ? `\n(exit ${result.exitCode}, ${durationMs}ms)` : "";
 				return `${tail.length > 0 ? tail : semantic.message ?? "(no output)"}${semanticFooter}${timingFooter}`;
 			}
 			const combined = `${result.stdout}\n${result.stderr}`.trim();
-			return `${wantMetadata ? `Exit code ${result.exitCode} (${durationMs}ms)` : `Exit code ${result.exitCode}`}\n${truncateTail(combined, cap)}`;
+			return `${wantMetadata ? `Exit code ${result.exitCode} (${durationMs}ms)` : `Exit code ${result.exitCode}`}\n${tailTruncate(combined, cap)}`;
 		}
 	};
 }
@@ -6113,32 +6278,6 @@ function normalizeCap(value) {
 	if (value < 0) return DEFAULT_MAX_OUTPUT_BYTES;
 	return Math.floor(value);
 }
-/**
-* Tail-priority byte truncation. When `text` exceeds `cap` bytes, the head is
-* dropped and replaced with a marker. Always cuts on character boundaries (no
-* mid-codepoint splits) by walking from the end with `Buffer.byteLength`.
-*
-* `cap === 0` disables truncation. `cap` is interpreted as a UTF-8 byte budget
-* for the tail itself — the marker is added on top and may push the visible
-* length slightly past `cap`. That tradeoff is intentional: a marker that
-* always fits inside the budget would shrink the actual content displayed.
-*/
-function truncateTail(text, cap) {
-	if (cap === 0) return text;
-	const totalBytes = Buffer.byteLength(text);
-	if (totalBytes <= cap) return text;
-	let bytes = 0;
-	let charIdx = text.length;
-	while (charIdx > 0) {
-		const ch = text[charIdx - 1];
-		const chBytes = Buffer.byteLength(ch);
-		if (bytes + chBytes > cap) break;
-		bytes += chBytes;
-		charIdx--;
-	}
-	const tail = text.slice(charIdx);
-	return `…(${totalBytes - Buffer.byteLength(tail)} bytes truncated from head)…\n${tail}`;
-}
 //#endregion
 //#region src/tools/binary-detect.ts
 /**
@@ -6621,7 +6760,7 @@ const waitTask = {
 	async execute(input, ctx) {
 		const taskId = input.task_id;
 		if (!ctx.execution.waitBackground) return `wait_task error: the active execution context (${ctx.execution.type}) does not support waiting on background tasks.`;
-		if (ctx.execution.listBackground) {
+		if (resolveDetachedTasksCapability(ctx.execution) !== "durable" && ctx.execution.listBackground) {
 			if (!(await ctx.execution.listBackground(ctx.handle)).some((e) => e.taskId === taskId)) return `wait_task: no such task "${taskId}". It may have already exited and been cleaned up, or it was never started in this session.`;
 		}
 		const requested = typeof input.timeout_ms === "number" && Number.isFinite(input.timeout_ms) && input.timeout_ms > 0 ? input.timeout_ms : DEFAULT_TIMEOUT_MS;
@@ -7251,7 +7390,7 @@ function validateAndPrepareResume(session, prompt, hasPendingTaskNotifications =
 	}
 	return resumeFilteredTurns;
 }
-function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, readState: agentReadState, skills: agentSkills, mcpConnector, mcpToolWrap, eager, hooks: initialHooks, clock: agentClock }) {
+function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, readState: agentReadState, skills: agentSkills, mcpConnector, mcpToolWrap, eager, hooks: initialHooks, clock: agentClock, toolKill }) {
 	const hooks = createHooks();
 	const executionContext = execution ?? createProcessContext();
 	const sourceTools = agentTools ?? {};
@@ -7277,7 +7416,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 	const pendingTaskNotifications = /* @__PURE__ */ new Map();
 	const pendingStallNotifications = /* @__PURE__ */ new Map();
 	const notifiedTaskIds = /* @__PURE__ */ new Set();
-	const pendingToolCancels = /* @__PURE__ */ new Map();
+	const toolCancels = createToolCancelRegistry(toolKill?.defaultMessage !== void 0 ? { defaultMessage: toolKill.defaultMessage } : {});
 	let executionHandle = null;
 	let mcpConnection = null;
 	let lastContextAssembly = null;
@@ -7355,6 +7494,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 		let externalAbortListener;
 		const externalSignal = options.signal;
 		running = true;
+		toolCancels.clearPending();
 		try {
 			abortController = new AbortController();
 			idlePromise = new Promise((resolve) => {
@@ -7625,7 +7765,9 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			const reconciled = new Map(pendingTaskNotifications);
 			pendingTaskNotifications.clear();
 			if (executionContext.listBackground && executionHandle && typeof resolvedBehavior?.tasksDir === "string" && resolvedBehavior.tasksDir.length > 0) try {
-				const entries = await executionContext.listBackground(executionHandle);
+				const listBackground = executionContext.listBackground;
+				const handle = executionHandle;
+				const entries = options.journalReconcile ? await options.journalReconcile(() => listBackground(handle)) : await listBackground(handle);
 				const acks = entries.some((e) => e.status !== "running") ? collectTaskAcksFromTurns(session ? session.turns : turns) : void 0;
 				for (const entry of entries) {
 					if (entry.status === "running" || notifiedTaskIds.has(entry.taskId) || reconciled.has(entry.taskId)) continue;
@@ -7837,7 +7979,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					providerName: provider.name,
 					runStartMs,
 					runToolCounts: {},
-					pendingToolCancels,
+					toolCancels,
 					usageMirror
 				});
 				const parentTurnCost = stats.turnUsage?.reduce((sum, t) => sum + (t.cost ?? 0), 0) ?? 0;
@@ -7979,10 +8121,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 		abortController?.abort();
 	}
 	function cancelTool(callId, reason) {
-		const controller = pendingToolCancels.get(callId);
-		if (!controller || controller.signal.aborted) return false;
-		controller.abort(reason ?? "user-cancelled-tool");
-		return true;
+		return toolCancels.cancel(callId, reason);
 	}
 	async function killBackgroundTask(taskId) {
 		if (!executionHandle) return false;
@@ -8167,8 +8306,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 		pendingTaskNotifications.clear();
 		pendingStallNotifications.clear();
 		if (abortController && !abortController.signal.aborted) abortController.abort("agent-destroyed");
-		for (const controller of pendingToolCancels.values()) if (!controller.signal.aborted) controller.abort("agent-destroyed");
-		pendingToolCancels.clear();
+		toolCancels.abortAll("agent-destroyed");
 		const destroyTimeoutMs = resolveTimeoutMs(agentBehavior?.destroyTimeoutMs, DEFAULT_DESTROY_TIMEOUT_MS);
 		if (mcpWarmupPromise) try {
 			await withTimeout(mcpWarmupPromise, {
@@ -10059,6 +10197,6 @@ const writeFile$1 = {
 	}
 };
 //#endregion
-export { stripImagesFromTurns as $, PERSISTENCE_PREVIEW_BYTES as A, selectRecentFiles as B, stableStringify as C, TOOL_USE_SKIPPED_MESSAGE as D, TOOL_USE_CANCELLED_MESSAGE as E, resolvePersistDir as F, buildCompactPrompt as G, BASE_INSTRUCTIONS as H, resolveTasksDir as I, buildTailCompactPrompt as J, buildFromCompactPrompt as K, buildPostCompactAttachments as L, cleanupPersistedSession as M, maybePersistToolResult as N, validateToolArgs as O, resolveMcpWarningsDir as P, sliceForCompaction as Q, selectFilesFromReadState as R, normalizeShellCommand as S, SHELL_CASCADE_CANCEL_MESSAGE as T, NO_TOOLS_PREAMBLE as U, compactConversation as V, TRAILER as W, ANCHOR_PREVIEW_MAX_CHARS as X, buildUpToCompactPrompt as Y, anchorPreviewFor as Z, createSkillsReadTool as _, multiEdit as a, withTimeout as at, defaultRepeatGuardNormalize as b, grep as c, effectiveContextWindow as ct, createAgent as d, summaryToTurn as et, WAIT_TASK_TIMED_OUT_PREFIX as f, createSkillsRunScriptTool as g, createSkillsUseTool as h, readFile$1 as i, OperationTimeoutError as it, buildPersistedStub as j, PERSISTED_STUB_PREFIX as k, glob as l, shouldAutoCompact as lt, createToolSearchTool as m, createSpawnTool as n, CompactInvalidInputError as nt, listFiles as o, AUTO_COMPACT_MIN_GROWTH_FRACTION as ot, waitTask as p, buildFullCompactPrompt as q, shellKill as r, CompactPromptTooLongError as rt, createInteractionTool as s, OUTPUT_RESERVE_TOKENS as st, writeFile$1 as t, truncateHeadForPtlRetry as tt, edit as u, createShellTool as v, INTERRUPT_MESSAGE_FOR_TOOL_USE as w, defaultRepeatGuardTracked as x, shell as y, selectFilesFromSession as z };
+export { sliceForCompaction as $, PERSISTED_STUB_PREFIX as A, selectFilesFromSession as B, normalizeShellCommand as C, TOOL_USE_CANCELLED_MESSAGE as D, SHELL_CASCADE_CANCEL_MESSAGE as E, resolveMcpWarningsDir as F, TRAILER as G, compactConversation as H, resolvePersistDir as I, buildFullCompactPrompt as J, buildCompactPrompt as K, resolveTasksDir as L, buildPersistedStub as M, cleanupPersistedSession as N, TOOL_USE_SKIPPED_MESSAGE as O, maybePersistToolResult as P, anchorPreviewFor as Q, buildPostCompactAttachments as R, defaultRepeatGuardTracked as S, INTERRUPT_MESSAGE_FOR_TOOL_USE as T, BASE_INSTRUCTIONS as U, selectRecentFiles as V, NO_TOOLS_PREAMBLE as W, buildUpToCompactPrompt as X, buildTailCompactPrompt as Y, ANCHOR_PREVIEW_MAX_CHARS as Z, createSkillsReadTool as _, multiEdit as a, OperationTimeoutError as at, tailTruncate as b, grep as c, OUTPUT_RESERVE_TOKENS as ct, createAgent as d, stripImagesFromTurns as et, WAIT_TASK_TIMED_OUT_PREFIX as f, createSkillsRunScriptTool as g, createSkillsUseTool as h, readFile$1 as i, CompactPromptTooLongError as it, PERSISTENCE_PREVIEW_BYTES as j, validateToolArgs as k, glob as l, effectiveContextWindow as lt, createToolSearchTool as m, createSpawnTool as n, truncateHeadForPtlRetry as nt, listFiles as o, withTimeout as ot, waitTask as p, buildFromCompactPrompt as q, shellKill as r, CompactInvalidInputError as rt, createInteractionTool as s, AUTO_COMPACT_MIN_GROWTH_FRACTION as st, writeFile$1 as t, summaryToTurn as tt, edit as u, shouldAutoCompact as ut, createShellTool as v, stableStringify as w, defaultRepeatGuardNormalize as x, shell as y, selectFilesFromReadState as z };
 
-//# sourceMappingURL=tools-DhzKzB1y.js.map
+//# sourceMappingURL=tools-BvATiiCO.js.map