zidane 5.3.0 → 5.3.2

package/dist/{tools-CMVruxF0.js → tools-CCsL5SCO.js}

@@ -1,9 +1,9 @@
 import { n as createProcessContext } from "./contexts-BwiHIr2w.js";
-import { c as toTypedError, o as errorMessage, r as AgentProviderError, t as AgentAbortedError } from "./errors-COmsomd5.js";
+import { a as AgentToolPairingError, l as toTypedError, r as AgentProviderError, s as errorMessage, t as AgentAbortedError } from "./errors-Byb0F8B9.js";
 import { t as toolOutputByteLength } from "./types-IcokUOyC.js";
-import { i as sanitizeOrphanedToolCalls } from "./messages-DsbMYNmt.js";
-import { t as connectMcpServers } from "./mcp-B1psg7jf.js";
-import { _ as validateResourcePath, b as createSkillActivationState, d as escapeXml, n as resolveSkills, p as installAllowedToolsGate, t as interpolateShellCommands, u as buildCatalog } from "./interpolate-BhmHKD6x.js";
+import { a as detectTurnInterruption, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureToolResultPairing, s as filterUnresolvedToolUses } from "./messages-D0xT979U.js";
+import { t as connectMcpServers } from "./mcp-DhmmJfxK.js";
+import { _ as validateResourcePath, b as createSkillActivationState, d as escapeXml, n as resolveSkills, p as installAllowedToolsGate, t as interpolateShellCommands, u as buildCatalog } from "./interpolate-ERgZUxgg.js";
 import { n as formatTokenUsage, t as flattenTurns } from "./stats-DgOvY7wd.js";
 import { createHooks } from "hookable";
 import { mkdir, rename, rm, stat, writeFile } from "node:fs/promises";
@@ -107,8 +107,14 @@ function rewriteMessagesToWire(messages, maps) {
 const STATE = /* @__PURE__ */ new WeakMap();
 /**
 * Get or lazily create the per-session read-state map. Returns `undefined`
-* when no session is provided — tools should treat that as "no dedup, no
-* guard": the state has nowhere to live, so every read is fresh.
+* when no session is provided.
+*
+* Most tool callers should prefer {@link resolveReadStateMap}, which
+* additionally honors an explicit `ctx.readState` (the path
+* `spawn`'s `shareReadState: true` uses to forward the parent's map
+* into a sessionless child). Use this helper directly only when the
+* Session-keyed map is exactly what you want and you don't need to
+* accept an override.
 */
 function getReadState(session) {
 	if (!session) return void 0;
@@ -119,19 +125,38 @@ function getReadState(session) {
 	}
 	return map;
 }
-const TOOL_DEDUP_STATE = /* @__PURE__ */ new WeakMap();
 /**
-* Get or lazily create the per-session tool-dedup map. Returns `undefined`
-* when no session is provided — middleware should treat that as "no dedup".
+* Resolve the active read-state map from a tool context. An explicit
+* `ctx.readState` wins (used by `spawn`'s `shareReadState` opt-in to
+* forward the parent's map into a sessionless child); otherwise the
+* usual `Session`-keyed lookup applies.
+*
+* Tools should call this helper instead of `getReadState(ctx.session)`
+* directly so the `shareReadState` plumbing is honored uniformly.
 */
-function getToolDedupState(session) {
-	if (!session) return void 0;
-	let map = TOOL_DEDUP_STATE.get(session);
-	if (!map) {
-		map = /* @__PURE__ */ new Map();
-		TOOL_DEDUP_STATE.set(session, map);
-	}
-	return map;
+function resolveReadStateMap(ctx) {
+	return ctx.readState ?? getReadState(ctx.session);
+}
+/**
+* Canonical read-state key for a `(cwd, path)` pair.
+*
+* `ctx.execution.readFile(handle, path)` resolves the model-provided
+* path against `handle.cwd` before touching disk — so `src/App.tsx`,
+* `./src/App.tsx`, and `/abs/cwd/src/App.tsx` all read the **same**
+* bytes. The read-state map MUST mirror that resolution: without it,
+* a model that reads `src/App.tsx` and then edits `./src/App.tsx`
+* trips the `requireReadBeforeEdit` gate for a file it demonstrably
+* already saw (the gate's "has not been read in this session" message
+* fires on a stale key).
+*
+* `node:path`'s `resolve(cwd, path)` short-circuits when `path` is
+* already absolute, so absolute and relative shapes converge on the
+* same canonical form. We don't `realpath()` symlinks — the file IS
+* the path the model addressed, not the realpath behind it; the host's
+* execution context decides how to dereference.
+*/
+function readStateKey(cwd, path) {
+	return resolve(cwd, path);
 }
 /**
 * FNV-1a 32-bit hash, hex-encoded. Fast, non-cryptographic — we only need
@@ -147,6 +172,20 @@ function hashContent(text) {
 	}
 	return h.toString(16).padStart(8, "0");
 }
+const TOOL_DEDUP_STATE = /* @__PURE__ */ new WeakMap();
+/**
+* Get or lazily create the per-session tool-dedup map. Returns `undefined`
+* when no session is provided — middleware should treat that as "no dedup".
+*/
+function getToolDedupState(session) {
+	if (!session) return void 0;
+	let map = TOOL_DEDUP_STATE.get(session);
+	if (!map) {
+		map = /* @__PURE__ */ new Map();
+		TOOL_DEDUP_STATE.set(session, map);
+	}
+	return map;
+}
 //#endregion
 //#region src/dedup-tools.ts
 /**
@@ -480,6 +519,7 @@ function validateToolArgs(input, schema) {
 	};
 	let coerced;
 	const coercions = [];
+	let droppedItems;
 	for (const [key, value] of Object.entries(input)) {
 		const propSchema = properties[key];
 		if (!propSchema?.type) continue;
@@ -494,11 +534,138 @@ function validateToolArgs(input, schema) {
 			coerced[key] = outcome.value;
 			coercions.push(key);
 		}
+		const arrayValue = outcome.changed ? outcome.value : value;
+		if (propSchema.type === "array" && propSchema.items && Array.isArray(arrayValue)) {
+			const itemOutcome = validateArrayItems(arrayValue, propSchema);
+			if (itemOutcome.error) return {
+				valid: false,
+				error: `Field "${key}": ${itemOutcome.error}`
+			};
+			if (itemOutcome.changed || itemOutcome.dropped.length > 0 || itemOutcome.truncated) {
+				if (!coerced) coerced = { ...input };
+				coerced[key] = itemOutcome.items;
+				if (!coercions.includes(key)) coercions.push(key);
+			}
+			if (itemOutcome.dropped.length > 0) {
+				if (!droppedItems) droppedItems = {};
+				droppedItems[key] = itemOutcome.dropped;
+			}
+		}
 	}
 	return {
 		valid: true,
 		coercedInput: coerced ?? input,
-		coercions
+		coercions,
+		...droppedItems ? { droppedItems } : {}
+	};
+}
+function validateArrayItems(items, schema) {
+	if (schema.minItems !== void 0 && items.length < schema.minItems) return {
+		items,
+		changed: false,
+		truncated: false,
+		dropped: [],
+		error: `expected at least ${schema.minItems} item${schema.minItems === 1 ? "" : "s"}, got ${items.length}`
+	};
+	const itemSchema = schema.items;
+	if (!itemSchema) return {
+		items,
+		changed: false,
+		truncated: false,
+		dropped: []
+	};
+	const out = [];
+	const outOriginalIdx = [];
+	const dropped = [];
+	let changed = false;
+	for (let i = 0; i < items.length; i++) {
+		const item = items[i];
+		const v = validateOneItem(item, itemSchema);
+		if (v.dropped) {
+			dropped.push(i);
+			changed = true;
+			continue;
+		}
+		if (v.changed) changed = true;
+		out.push(v.value);
+		outOriginalIdx.push(i);
+	}
+	let truncated = false;
+	if (schema.maxItems !== void 0 && out.length > schema.maxItems) {
+		for (let i = schema.maxItems; i < out.length; i++) dropped.push(outOriginalIdx[i]);
+		out.length = schema.maxItems;
+		truncated = true;
+		changed = true;
+	}
+	dropped.sort((a, b) => a - b);
+	return {
+		items: out,
+		changed,
+		truncated,
+		dropped
+	};
+}
+function validateOneItem(item, schema) {
+	if (schema.type === "object") {
+		if (!item || typeof item !== "object" || Array.isArray(item)) return {
+			value: item,
+			changed: false,
+			dropped: true
+		};
+		const obj = item;
+		const required = schema.required ?? [];
+		for (const field of required) {
+			const v = obj[field];
+			if (v === void 0 || v === null) return {
+				value: item,
+				changed: false,
+				dropped: true
+			};
+		}
+		const properties = schema.properties ?? {};
+		let coercedItem;
+		for (const [key, value] of Object.entries(obj)) {
+			const subSchema = properties[key];
+			if (!subSchema?.type) continue;
+			if (value === void 0 || value === null) continue;
+			const outcome = coerceValue(value, subSchema);
+			if (outcome.error) return {
+				value: item,
+				changed: false,
+				dropped: true
+			};
+			if (outcome.changed) {
+				if (!coercedItem) coercedItem = { ...obj };
+				coercedItem[key] = outcome.value;
+			}
+		}
+		return coercedItem ? {
+			value: coercedItem,
+			changed: true,
+			dropped: false
+		} : {
+			value: item,
+			changed: false,
+			dropped: false
+		};
+	}
+	if (schema.type) {
+		const outcome = coerceValue(item, schema);
+		if (outcome.error) return {
+			value: item,
+			changed: false,
+			dropped: true
+		};
+		return {
+			value: outcome.value,
+			changed: outcome.changed,
+			dropped: false
+		};
+	}
+	return {
+		value: item,
+		changed: false,
+		dropped: false
 	};
 }
 function coerceValue(value, schema) {
@@ -628,6 +795,30 @@ function formatValue(value) {
 //#region src/loop.ts
 const IMAGE_OMITTED_MARKER = "[image omitted — model does not support vision]";
 /**
+* Canonical tool_result text emitted when a tool call is interrupted by the
+* user mid-flight (Esc / Ctrl-C / external `AbortSignal`). Mirrors Claude
+* Code's `INTERRUPT_MESSAGE_FOR_TOOL_USE` so downstream consumers can pattern
+* match a single string across both harnesses. Always paired with
+* `isError: true` on the wire — the model treats it as a failed call rather
+* than a successful tool response.
+*/
+const INTERRUPT_MESSAGE_FOR_TOOL_USE = "[Request interrupted by user for tool use]";
+/**
+* Canonical tool_result text emitted when a tool call is skipped because a
+* sibling sequential call errored or a steering message arrived between
+* iterations of {@link executeToolsSequential}. Distinguished from
+* {@link INTERRUPT_MESSAGE_FOR_TOOL_USE} so consumers can distinguish "user
+* cancelled" from "framework superseded".
+*/
+const TOOL_USE_SKIPPED_MESSAGE = "[Tool use skipped — superseded by user message]";
+/**
+* Canonical tool_result text emitted when the loop catches a sequential
+* sibling that threw and synthesizes follow-up results for the remaining
+* queued calls. Distinct from {@link TOOL_USE_SKIPPED_MESSAGE} so telemetry
+* can split "skipped by user steering" from "skipped after error".
+*/
+const TOOL_USE_AFTER_ERROR_MESSAGE = "[Tool use skipped — previous tool call in batch threw]";
+/**
 * Compute the effective thinking budget for a given run-relative turn, given
 * the configured decay schedule. Pure helper — exported for tests and so
 * downstream tooling can preview decay curves without spinning up the loop.
@@ -915,19 +1106,47 @@ function applyStaleReadElision(messages) {
 }
 /**
 * Drop read-state entries for paths whose reads got elided. Keys are
-* `${cwd}::${path}` (see `src/tools/read-file.ts`); we don't know the
-* cwd in this context, so we match by `::<path>` suffix. Safe because
-* paths inside the read-state map come from a single session bound to
-* one cwd in practice; an accidental cross-cwd collision would also
-* have to share an identical relative path, in which case force-fresh
-* is the correct behavior anyway.
+* canonical absolute paths produced by `readStateKey(cwd, path)` (see
+* `src/tools/read-state.ts`); the loop has `ctx.handle.cwd` in scope,
+* so we re-derive each elided path's canonical key and delete by
+* direct lookup. No suffix matching, no cross-cwd ambiguity.
+*
+* Resolves the map via `resolveReadStateMap` so a child agent running
+* with a parent's shared map (via `shareReadState`) invalidates the
+* shared entries too — otherwise a child's `read → edit → re-read`
+* would dedup-hit on the now-stale parent entry.
 */
-function invalidateReadStateForElidedPaths(session, elidedPaths) {
-	if (!session || elidedPaths.length === 0) return;
-	const readState = getReadState(session);
+function invalidateReadStateForElidedPaths(ctx, cwd, elidedPaths) {
+	if (elidedPaths.length === 0) return;
+	const readState = resolveReadStateMap(ctx);
 	if (!readState || readState.size === 0) return;
-	const suffixes = elidedPaths.map((p) => `::${p}`);
-	for (const key of [...readState.keys()]) if (suffixes.some((s) => key.endsWith(s))) readState.delete(key);
+	for (const p of elidedPaths) readState.delete(readStateKey(cwd, p));
+}
+/**
+* Run {@link ensureToolResultPairing} with the loop's hook + strict-mode
+* context plugged in. Centralized so the pre-send path and the schema-
+* enforcement path share identical telemetry + throw semantics.
+*
+* The captured `repairs` array is what `AgentToolPairingError` carries on
+* strict-mode throws, and it's what `pairing:repair` fires from. Hook
+* notifications run AFTER the pass completes so they don't interfere with
+* the synchronous walk — and we drop them on the floor in strict mode (the
+* throw is more informative than a fire-and-forget log).
+*/
+function applyPairingRepair(ctx, messages, turnId) {
+	const repairs = [];
+	const repaired = ensureToolResultPairing(messages, { onRepair: (repair) => repairs.push(repair) });
+	if (repairs.length === 0) return repaired;
+	if (ctx.strictToolPairing) throw new AgentToolPairingError({
+		message: `Tool pairing corruption detected (${repairs.length} repair${repairs.length === 1 ? "" : "s"}); strict mode is on so the request was not sent.`,
+		...ctx.providerName ? { provider: ctx.providerName } : {},
+		repairs
+	});
+	for (const repair of repairs) ctx.hooks.callHook("pairing:repair", {
+		...repair,
+		turnId
+	});
+	return repaired;
 }
 function sanitizeStoredToolResults(provider, messages) {
 	if (provider.meta.capabilities?.vision !== false) return messages;
@@ -1060,13 +1279,34 @@ function wrapProviderError(err, ctx) {
 		cause: err
 	});
 }
+/** Max bytes of provider error text inlined into the assistant turn placeholder. */
+const ERROR_PLACEHOLDER_MAX = 280;
+/**
+* Build the assistant-turn placeholder text when the provider throws before
+* streaming any output. Inlines the underlying error message (truncated and
+* stripped of stack-like newlines) so the persisted turn carries a useful
+* diagnostic — the human reading the transcript sees the failure mode
+* without having to attach a debugger, and `tool_search` schema rejections
+* become self-explanatory.
+*
+* The bracketed `[✗ Streaming failed: ...]` shape preserves the prior
+* format that hosts may pattern-match on while adding the new payload
+* suffix. Falls back to the original generic placeholder when no message
+* can be extracted.
+*/
+function buildStreamErrorPlaceholder(err) {
+	const raw = errorMessage(err).trim();
+	if (raw.length === 0) return "[✗ Streaming failed before any output.]";
+	const oneLine = raw.replace(/\s+/g, " ");
+	return `[✗ Streaming failed before any output: ${oneLine.length > ERROR_PLACEHOLDER_MAX ? `${oneLine.slice(0, ERROR_PLACEHOLDER_MAX - 1).trimEnd()}…` : oneLine}]`;
+}
 async function executeTurn(ctx, turn) {
 	const turnId = await ctx.generateTurnId();
 	let canonicalMessages = turnsToMessages(applyCompactSummaryCutoff(ctx.turns));
 	if (ctx.elideStaleReads === true) {
 		const elision = applyStaleReadElision(canonicalMessages);
 		canonicalMessages = elision.messages;
-		invalidateReadStateForElidedPaths(ctx.session, elision.elidedPaths);
+		invalidateReadStateForElidedPaths(ctx, ctx.handle.cwd, elision.elidedPaths);
 	}
 	const wireMessages = rewriteMessagesToWire(canonicalMessages, ctx.aliasMaps);
 	let sanitizedMessages = sanitizeStoredToolResults(ctx.provider, wireMessages);
@@ -1091,7 +1331,7 @@ async function executeTurn(ctx, turn) {
 	const transformCtx = { messages: streamOptions.messages };
 	await ctx.hooks.callHook("context:transform", transformCtx);
 	streamOptions.messages = transformCtx.messages;
-	streamOptions.messages = sanitizeOrphanedToolCalls(streamOptions.messages);
+	streamOptions.messages = applyPairingRepair(ctx, streamOptions.messages, turnId);
 	const systemCtx = {
 		system: streamOptions.system,
 		messages: streamOptions.messages,
@@ -1137,12 +1377,13 @@ async function executeTurn(ctx, turn) {
 			input: 0,
 			output: 0
 		};
+		const placeholderText = wasAborted ? "[⏹ Streaming was aborted.]" : buildStreamErrorPlaceholder(err);
 		const errorContent = currentText ? [{
 			type: "text",
 			text: currentText
 		}] : [{
 			type: "text",
-			text: wasAborted ? "[⏹ Streaming was aborted.]" : "[✗ Streaming failed before any output.]"
+			text: placeholderText
 		}];
 		const errorTurn = {
 			id: turnId,
@@ -1153,6 +1394,10 @@ async function executeTurn(ctx, turn) {
 			createdAt: Date.now()
 		};
 		ctx.turns.push(errorTurn);
+		if (!wasAborted) await ctx.hooks.callHook("stream:error", {
+			err,
+			turnId
+		});
 		await ctx.hooks.callHook("turn:after", {
 			turn,
 			turnId,
@@ -1205,7 +1450,7 @@ async function executeTurn(ctx, turn) {
 				description: "Return the final structured output matching the required schema.",
 				inputSchema: ctx.schema
 			};
-			const schemaMessages = sanitizeOrphanedToolCalls(rewriteMessagesToWire(turnsToMessages(applyCompactSummaryCutoff(ctx.turns)), ctx.aliasMaps));
+			const schemaMessages = applyPairingRepair(ctx, rewriteMessagesToWire(turnsToMessages(applyCompactSummaryCutoff(ctx.turns)), ctx.aliasMaps), turnId);
 			let schemaResult;
 			try {
 				schemaResult = await ctx.provider.stream({
@@ -1335,30 +1580,69 @@ function stripImagesForNonVision(provider, output) {
 	if (provider.meta.capabilities?.vision !== false) return output;
 	return output.map((b) => b.type === "image" ? IMAGE_OMITTED_MARKER : b.text).join("\n");
 }
+/**
+* Build the per-call base for every `tool:*` hook ctx (and the
+* matching shape for `mcp:tool:*`). Centralized so the `runId` /
+* `parentRunId` / `depth` identity fields land uniformly on every
+* event the loop fires — without one helper they drift across ~14
+* inline construction sites. The returned object IS the
+* {@link ToolHookContext} canonical shape; specialized hook payloads
+* (`gateCtx`, `transformCtx`, etc.) spread it and append their own
+* fields.
+*/
+function buildToolHookBase(ctx, turnId, callId, name, displayName, input) {
+	return {
+		turnId,
+		callId,
+		name,
+		displayName,
+		input,
+		...ctx.runId !== void 0 ? { runId: ctx.runId } : {},
+		...ctx.parentRunId !== void 0 ? { parentRunId: ctx.parentRunId } : {},
+		...typeof ctx.depth === "number" ? { depth: ctx.depth } : {}
+	};
+}
 async function executeSingleTool(ctx, call, turnId) {
 	const toolDef = ctx.tools[call.name];
 	const callId = call.id;
 	const displayName = toWireName(call.name, ctx.aliasMaps);
 	const runToolCounts = Object.freeze({ ...ctx.runToolCounts });
 	const gateCtx = {
-		turnId,
-		callId,
-		name: call.name,
-		displayName,
-		input: call.input,
+		...buildToolHookBase(ctx, turnId, callId, call.name, displayName, call.input),
 		block: false,
 		reason: "Tool execution was blocked",
 		runToolCounts
 	};
 	await ctx.hooks.callHook("tool:gate", gateCtx);
-	if (gateCtx.block) return { result: {
-		id: callId,
-		content: `Blocked: ${gateCtx.reason}`
-	} };
+	if (gateCtx.block) {
+		await fireDispatched(ctx, {
+			turnId,
+			callId,
+			name: call.name,
+			displayName,
+			input: gateCtx.input,
+			outcome: "gate-block",
+			reason: gateCtx.reason,
+			runToolCounts
+		});
+		return { result: {
+			id: callId,
+			content: `Blocked: ${gateCtx.reason}`,
+			isError: true
+		} };
+	}
 	ctx.runToolCounts[call.name] = (ctx.runToolCounts[call.name] ?? 0) + 1;
-	if (gateCtx.result !== void 0) return { result: {
-		id: callId,
-		content: await emitToolResult(ctx, {
+	if (gateCtx.result !== void 0) {
+		await fireDispatched(ctx, {
+			turnId,
+			callId,
+			name: call.name,
+			displayName,
+			input: gateCtx.input,
+			outcome: "gate-substitute",
+			runToolCounts
+		});
+		const emitted = await emitToolResult(ctx, {
 			turnId,
 			callId,
 			name: call.name,
@@ -1367,69 +1651,84 @@ async function executeSingleTool(ctx, call, turnId) {
 			output: gateCtx.result,
 			isError: false,
 			runToolCounts
-		})
-	} };
+		});
+		return { result: {
+			id: callId,
+			content: emitted.output,
+			...emitted.isError ? { isError: true } : {}
+		} };
+	}
 	let effectiveInput = gateCtx.input;
 	if (!toolDef) {
 		const unknownCtx = {
-			turnId,
-			callId,
-			name: call.name,
-			displayName,
-			input: effectiveInput,
+			...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
 			suppressError: false
 		};
 		await ctx.hooks.callHook("tool:unknown", unknownCtx);
 		const content = unknownCtx.result ?? `Tool error: Unknown tool: ${call.name}`;
+		const isError = unknownCtx.result === void 0;
 		if (!unknownCtx.suppressError) {
 			const err = /* @__PURE__ */ new Error(`Unknown tool: ${call.name}`);
 			await ctx.hooks.callHook("tool:error", {
-				turnId,
-				callId,
-				name: call.name,
-				displayName,
-				input: effectiveInput,
+				...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
 				error: err
 			});
 		}
+		await fireDispatched(ctx, {
+			turnId,
+			callId,
+			name: call.name,
+			displayName,
+			input: effectiveInput,
+			outcome: "unknown",
+			runToolCounts
+		});
 		return { result: {
 			id: callId,
-			content
+			content,
+			...isError ? { isError: true } : {}
 		} };
 	}
 	const validation = validateToolArgs(effectiveInput, toolDef.spec.inputSchema);
 	if (!validation.valid) {
 		await ctx.hooks.callHook("validation:reject", {
+			...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
+			reason: validation.error ?? "invalid input",
+			schema: toolDef.spec.inputSchema
+		});
+		await fireDispatched(ctx, {
 			turnId,
 			callId,
 			name: call.name,
 			displayName,
 			input: effectiveInput,
-			reason: validation.error ?? "invalid input",
-			schema: toolDef.spec.inputSchema
+			outcome: "invalid-input",
+			runToolCounts
 		});
 		return { result: {
 			id: callId,
-			content: `Validation error: ${validation.error}`
+			content: `Validation error: ${validation.error}`,
+			isError: true
 		} };
 	}
 	effectiveInput = validation.coercedInput ?? effectiveInput;
 	const coercions = validation.coercions && validation.coercions.length > 0 ? validation.coercions : void 0;
 	if (coercions) await ctx.hooks.callHook("validation:coerce", {
-		turnId,
-		callId,
-		name: call.name,
-		displayName,
-		input: effectiveInput,
+		...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
 		coercions,
 		schema: toolDef.spec.inputSchema
 	});
-	await ctx.hooks.callHook("tool:before", {
+	await fireDispatched(ctx, {
 		turnId,
 		callId,
 		name: call.name,
 		displayName,
 		input: effectiveInput,
+		outcome: "execute",
+		runToolCounts
+	});
+	await ctx.hooks.callHook("tool:before", {
+		...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
 		runToolCounts,
 		...coercions ? { coercions } : {}
 	});
@@ -1452,55 +1751,79 @@ async function executeSingleTool(ctx, call, turnId) {
 			turnId,
 			callId,
 			runId: ctx.runId,
+			...ctx.parentRunId !== void 0 ? { parentRunId: ctx.parentRunId } : {},
 			...ctx.session ? { session: ctx.session } : {},
+			...ctx.readState ? { readState: ctx.readState } : {},
 			...typeof ctx.depth === "number" ? { depth: ctx.depth } : {}
 		};
 		output = await toolDef.execute(effectiveInput, toolCtx);
 	} catch (err) {
 		const error = err instanceof Error ? err : new Error(String(err));
 		const errorCtx = {
-			turnId,
-			callId,
-			name: call.name,
-			displayName,
-			input: effectiveInput,
+			...buildToolHookBase(ctx, turnId, callId, call.name, displayName, effectiveInput),
 			error
 		};
 		await ctx.hooks.callHook("tool:error", errorCtx);
 		output = errorCtx.result ?? `Tool error: ${error.message}`;
 		isError = true;
 	}
+	const emitted = await emitToolResult(ctx, {
+		turnId,
+		callId,
+		name: call.name,
+		displayName,
+		input: effectiveInput,
+		output,
+		isError,
+		runToolCounts,
+		...coercions ? { coercions } : {}
+	});
 	return { result: {
 		id: callId,
-		content: await emitToolResult(ctx, {
-			turnId,
-			callId,
-			name: call.name,
-			displayName,
-			input: effectiveInput,
-			output,
-			isError,
-			runToolCounts,
-			...coercions ? { coercions } : {}
-		})
+		content: emitted.output,
+		...emitted.isError ? { isError: true } : {}
 	} };
 }
 /**
+* Fire `tool:dispatched` with the resolved path discriminator. Every code
+* path in {@link executeSingleTool} that produces a tool_result must call
+* this exactly once — that contract is what makes `tool:dispatched` ↔
+* `tool:after` a guaranteed symmetric pairing for live-event consumers
+* (the chat layer, SDK consumers reconstructing wire history from events,
+* tracing spans that want to record refused calls separately from
+* executed ones).
+*
+* Helper exists to centralize the optional-field plumbing for `reason`
+* (only set on `gate-block`) without sprinkling spread-conditional logic
+* across five call sites.
+*/
+async function fireDispatched(ctx, params) {
+	const { turnId, callId, name, displayName, input, outcome, reason, runToolCounts } = params;
+	await ctx.hooks.callHook("tool:dispatched", {
+		...buildToolHookBase(ctx, turnId, callId, name, displayName, input),
+		outcome,
+		runToolCounts,
+		...reason !== void 0 ? { reason } : {}
+	});
+}
+/**
 * Shared post-output emission: fire `tool:transform` (mutate-allowed), strip
 * images for non-vision providers, fire `tool:after`. Used by both the
 * gate-substitute (Z20) and post-execute paths so they stay byte-for-byte
 * identical from the consumer's perspective.
+*
+* Returns both the (possibly transformed) output and the final `isError`
+* flag — `tool:transform` listeners can flip the flag in either direction
+* (e.g. rewrite a structured error response to a graceful retry hint), and
+* the caller needs the post-transform value to populate `ToolResult.isError`
+* on the wire.
 */
 async function emitToolResult(ctx, params) {
 	const { turnId, callId, name, displayName, input, runToolCounts, coercions } = params;
 	let output = params.output;
 	let isError = params.isError;
 	const transformCtx = {
-		turnId,
-		callId,
-		name,
-		displayName,
-		input,
+		...buildToolHookBase(ctx, turnId, callId, name, displayName, input),
 		result: output,
 		isError,
 		outputBytes: toolOutputByteLength(output),
@@ -1525,17 +1848,16 @@ async function emitToolResult(ctx, params) {
 	}
 	output = stripImagesForNonVision(ctx.provider, output);
 	await ctx.hooks.callHook("tool:after", {
-		turnId,
-		callId,
-		name,
-		displayName,
-		input,
+		...buildToolHookBase(ctx, turnId, callId, name, displayName, input),
 		result: output,
 		outputBytes: toolOutputByteLength(output),
 		runToolCounts,
 		...coercions ? { coercions } : {}
 	});
-	return output;
+	return {
+		output,
+		isError
+	};
 }
 async function executeToolsSequential(ctx, toolCalls, turnId) {
 	const results = [];
@@ -1544,14 +1866,16 @@ async function executeToolsSequential(ctx, toolCalls, turnId) {
 		if (ctx.signal.aborted) {
 			for (let j = i; j < toolCalls.length; j++) results.push({
 				id: toolCalls[j].id,
-				content: "Aborted: run was cancelled"
+				content: INTERRUPT_MESSAGE_FOR_TOOL_USE,
+				isError: true
 			});
 			return results;
 		}
 		if (ctx.steeringQueue.length > 0) {
 			for (let j = i; j < toolCalls.length; j++) results.push({
 				id: toolCalls[j].id,
-				content: "Skipped: steering message received"
+				content: TOOL_USE_SKIPPED_MESSAGE,
+				isError: true
 			});
 			return results;
 		}
@@ -1561,11 +1885,13 @@ async function executeToolsSequential(ctx, toolCalls, turnId) {
 		} catch (err) {
 			results.push({
 				id: call.id,
-				content: `Error: ${errorMessage(err)}`
+				content: `Error: ${errorMessage(err)}`,
+				isError: true
 			});
 			for (let j = i + 1; j < toolCalls.length; j++) results.push({
 				id: toolCalls[j].id,
-				content: "Skipped: previous tool call threw"
+				content: TOOL_USE_AFTER_ERROR_MESSAGE,
+				isError: true
 			});
 			return results;
 		}
@@ -1576,9 +1902,12 @@ async function executeToolsParallel(ctx, toolCalls, turnId) {
 	const executions = toolCalls.map((call) => executeSingleTool(ctx, call, turnId));
 	return (await Promise.allSettled(executions)).map((s, i) => {
 		if (s.status === "fulfilled") return s.value.result;
+		const reason = s.reason;
+		const isAbort = ctx.signal.aborted || reason instanceof Error && reason.name === "AbortError";
 		return {
 			id: toolCalls[i].id,
-			content: `Error: ${s.reason instanceof Error ? s.reason.message : String(s.reason)}`
+			content: isAbort ? INTERRUPT_MESSAGE_FOR_TOOL_USE : `Error: ${reason instanceof Error ? reason.message : String(reason)}`,
+			isError: true
 		};
 	});
 }
@@ -2157,8 +2486,10 @@ const HOOK_EVENT_SET = new Set([
 	"stream:text",
 	"stream:end",
 	"stream:thinking",
+	"stream:error",
 	"oauth:refresh",
 	"tool:gate",
+	"tool:dispatched",
 	"tool:before",
 	"tool:after",
 	"tool:error",
@@ -2175,8 +2506,10 @@ const HOOK_EVENT_SET = new Set([
 	"child:stream:text",
 	"child:stream:thinking",
 	"child:stream:end",
+	"child:stream:error",
 	"child:tool:gate",
 	"child:mcp:tool:gate",
+	"child:tool:dispatched",
 	"child:tool:before",
 	"child:tool:after",
 	"child:tool:transform",
@@ -2205,6 +2538,7 @@ const HOOK_EVENT_SET = new Set([
 	"output",
 	"budget:exceeded",
 	"tool-budget:exceeded",
+	"pairing:repair",
 	"agent:abort",
 	"agent:done",
 	"session:start",
@@ -2224,6 +2558,16 @@ function isKnownHookEvent(event) {
 * loop from leaving the persisted session with an orphan tool_use — which
 * Anthropic rejects on resume.
 *
+* Each synthetic result carries the shared
+* {@link SYNTHETIC_TOOL_RESULT_PLACEHOLDER} text (so consumers can pattern-
+* match the same way they would on a live pre-send repair) and
+* `isError: true` so the model treats it as a failed call.
+*
+* Fires `pairing:repair` (mode `orphan-tool-use-append`) for each synthetic
+* result, mirroring the wire-level repair pass's observability so postmortem
+* dashboards see the same telemetry shape regardless of where the orphan
+* was detected.
+*
 * No-op when:
 * - The trailing turn isn't an assistant turn (already closed, or session
 *   ends with the seeded user prompt).
@@ -2231,7 +2575,7 @@ function isKnownHookEvent(event) {
 * - 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) {
+async function synthesizeMissingToolResults(turns, syntheticTurnId, runId, provider, hooks) {
 	if (turns.length === 0) return;
 	const last = turns[turns.length - 1];
 	if (last.role !== "assistant") return;
@@ -2244,7 +2588,8 @@ function synthesizeMissingToolResults(turns, syntheticTurnId, runId, provider) {
 	if (dangling.length === 0) return;
 	const results = dangling.map((id) => ({
 		id,
-		content: "Aborted: run failed before tool execution completed"
+		content: SYNTHETIC_TOOL_RESULT_PLACEHOLDER,
+		isError: true
 	}));
 	const msg = provider.toolResultsMessage(results);
 	turns.push({
@@ -2254,6 +2599,11 @@ function synthesizeMissingToolResults(turns, syntheticTurnId, runId, provider) {
 		content: msg.content,
 		createdAt: Date.now()
 	});
+	for (const callId of dangling) await hooks.callHook("pairing:repair", {
+		mode: "orphan-tool-use-append",
+		callId,
+		messageIndex: turns.length - 2
+	});
 }
 function resolveBehavior(agentBehavior, runBehavior) {
 	return {
@@ -2278,7 +2628,8 @@ function resolveBehavior(agentBehavior, runBehavior) {
 		toolSearch: runBehavior?.toolSearch ?? agentBehavior?.toolSearch,
 		persistThreshold: runBehavior?.persistThreshold ?? agentBehavior?.persistThreshold,
 		persistExcludeTools: runBehavior?.persistExcludeTools ?? agentBehavior?.persistExcludeTools,
-		persistDir: runBehavior?.persistDir ?? agentBehavior?.persistDir
+		persistDir: runBehavior?.persistDir ?? agentBehavior?.persistDir,
+		strictToolPairing: runBehavior?.strictToolPairing ?? agentBehavior?.strictToolPairing ?? false
 	};
 }
 /**
@@ -2366,7 +2717,7 @@ function buildSearchableCatalog(entries, options) {
 	}
 	const serverNames = [...byServer.keys()].sort();
 	const parts = [];
-	if (options.discoveryToolName) parts.push("The following tools are available but their input schemas are NOT loaded in your context.", `Call the \`${options.discoveryToolName}\` tool to load schemas before invoking them. Surfaced tools persist for the rest of the run.`, "");
+	if (options.discoveryToolName) parts.push("The following tools are available but their input schemas are NOT loaded in your context.", `Call the \`${options.discoveryToolName}\` tool to load schemas for any tool below that you have not already surfaced. Surfaced tools persist for the rest of the run.`, "");
 	parts.push("<searchable_tools>");
 	for (const server of serverNames) {
 		parts.push(`  <server name="${escapeXml(server)}">`);
@@ -2425,7 +2776,7 @@ function initialRunCounter(session) {
 	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 }) {
+function createAgent({ provider, name: agentName, system: agentSystem, tools: agentTools, toolAliases, behavior: agentBehavior, execution, mcpServers, session, readState: agentReadState, skills: agentSkills, mcpConnector, eager, hooks: initialHooks }) {
 	const hooks = createHooks();
 	const executionContext = execution ?? createProcessContext();
 	const sourceTools = agentTools ?? {};
@@ -2494,9 +2845,14 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 		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");
+		let resumeFilteredTurns;
+		if (hasSessionTurns) resumeFilteredTurns = filterUnresolvedToolUses(session.turns);
+		if (!options.prompt && resumeFilteredTurns) {
+			const lastTurn = resumeFilteredTurns.at(-1);
+			if (lastTurn && lastTurn.role !== "user") {
+				const detail = detectTurnInterruption(resumeFilteredTurns) === "completed" ? "last turn is a completed assistant message" : "last turn is mid-stream assistant content";
+				throw new Error(`cannot resume without prompt: ${detail}. Pass a prompt to agent.run({ prompt: … }).`);
+			}
 		}
 		let externalAbortListener;
 		const externalSignal = options.signal;
@@ -2561,7 +2917,7 @@ 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 { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch, persistThreshold, persistExcludeTools, persistDir } = resolvedBehavior;
+			const { toolExecution, maxTurns, maxTokens, thinkingBudget, schema, cache, toolOutputBudget, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, dedupTools, toolBudgets, elideStaleReads, toolDisclosure, toolSearch, persistThreshold, persistExcludeTools, persistDir, strictToolPairing } = 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 ? {
@@ -2626,7 +2982,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			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 filteredForRuntime = resumeFilteredTurns && resumed === session.turns ? resumeFilteredTurns : filterUnresolvedToolUses(resumed);
+				turns.push(...filteredForRuntime);
 			}
 			const runTurnStart = turns.length;
 			if (options.system) await hooks.callHook("system:before", { system: options.system });
@@ -2669,7 +3026,7 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 			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);
+				if (opts.failureFallback) await synthesizeMissingToolResults(turns, await session.generateTurnId?.() ?? crypto.randomUUID(), runId, provider, hooks);
 				const remaining = turns.slice(lastPersistedTurnCount);
 				if (remaining.length > 0) {
 					await session.appendTurns(remaining);
@@ -2735,6 +3092,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					maxTurns,
 					maxTokens,
 					...session ? { session } : {},
+					...agentReadState ? { readState: agentReadState } : {},
+					...options.parentRunId ? { parentRunId: options.parentRunId } : {},
 					depth: runDepth,
 					thinkingBudget,
 					schema,
@@ -2748,6 +3107,8 @@ function createAgent({ provider, name: agentName, system: agentSystem, tools: ag
 					...persistThreshold !== void 0 ? { persistThreshold } : {},
 					...persistExcludeTools !== void 0 ? { persistExcludeTools } : {},
 					...persistDir !== void 0 ? { persistDir } : {},
+					...strictToolPairing ? { strictToolPairing: true } : {},
+					providerName: provider.name,
 					runStartMs,
 					runToolCounts: {}
 				});
@@ -3296,12 +3657,14 @@ const edit = {
 		} catch {
 			return `Edit error: file not found: ${target}.${await suggestionFor(ctx.execution, ctx.handle, target)}`;
 		}
-		if (ctx.behavior?.requireReadBeforeEdit && ctx.session) {
-			const readState = getReadState(ctx.session);
-			const absKey = `${ctx.handle.cwd}::${target}`;
-			const prior = readState?.get(absKey);
-			if (!prior) return `Edit error: ${target} has not been read in this session. Call read_file first so the edit applies against the current contents.`;
-			if (prior.contentHash !== hashContent(original)) return `Edit error: ${target} has changed on disk since the last read. Re-read the file before editing.`;
+		if (ctx.behavior?.requireReadBeforeEdit) {
+			const readState = resolveReadStateMap(ctx);
+			if (readState) {
+				const absKey = readStateKey(ctx.handle.cwd, target);
+				const prior = readState.get(absKey);
+				if (!prior) return `Edit error: ${target} has not been read in this session. Call read_file first so the edit applies against the current contents. (Reads inside a \`spawn\` subagent with \`persist: false\` and without \`shareReadState: true\` do NOT propagate to the parent — re-read in the calling context.)`;
+				if (prior.contentHash !== hashContent(original)) return `Edit error: ${target} has changed on disk since the last read. Re-read the file before editing.`;
+			}
 		}
 		const match = resolveOldString(original, find);
 		if (!match) {
@@ -3314,11 +3677,11 @@ const edit = {
 		const updated = replaceAll ? original.split(actual).join(styledReplacement) : original.replace(actual, styledReplacement);
 		if (updated === original) return `Edit error: replacement produced no change in ${target}.`;
 		await ctx.execution.writeFile(ctx.handle, target, updated);
-		if (ctx.session) {
-			const readState = getReadState(ctx.session);
-			const absKey = `${ctx.handle.cwd}::${target}`;
-			const prior = readState?.get(absKey);
-			if (readState && prior) readState.set(absKey, {
+		const readState = resolveReadStateMap(ctx);
+		if (readState) {
+			const absKey = readStateKey(ctx.handle.cwd, target);
+			const prior = readState.get(absKey);
+			if (prior) readState.set(absKey, {
 				...prior,
 				contentHash: hashContent(updated),
 				mtimeMs: Date.now()
@@ -3757,12 +4120,14 @@ const multiEdit = {
 		} catch {
 			return `multi_edit error: file not found: ${target}.${await suggestionFor(ctx.execution, ctx.handle, target)}`;
 		}
-		if (ctx.behavior?.requireReadBeforeEdit && ctx.session) {
-			const readState = getReadState(ctx.session);
-			const absKey = `${ctx.handle.cwd}::${target}`;
-			const prior = readState?.get(absKey);
-			if (!prior) return `multi_edit error: ${target} has not been read in this session. Call read_file first so the edits apply against the current contents.`;
-			if (prior.contentHash !== hashContent(current)) return `multi_edit error: ${target} has changed on disk since the last read. Re-read the file before editing.`;
+		if (ctx.behavior?.requireReadBeforeEdit) {
+			const readState = resolveReadStateMap(ctx);
+			if (readState) {
+				const absKey = readStateKey(ctx.handle.cwd, target);
+				const prior = readState.get(absKey);
+				if (!prior) return `multi_edit error: ${target} has not been read in this session. Call read_file first so the edits apply against the current contents. (Reads inside a \`spawn\` subagent with \`persist: false\` and without \`shareReadState: true\` do NOT propagate to the parent — re-read in the calling context.)`;
+				if (prior.contentHash !== hashContent(current)) return `multi_edit error: ${target} has changed on disk since the last read. Re-read the file before editing.`;
+			}
 		}
 		let totalReplacements = 0;
 		for (let i = 0; i < steps.length; i++) {
@@ -3782,11 +4147,11 @@ const multiEdit = {
 			totalReplacements += occurrences;
 		}
 		await ctx.execution.writeFile(ctx.handle, target, current);
-		if (ctx.session) {
-			const readState = getReadState(ctx.session);
-			const absKey = `${ctx.handle.cwd}::${target}`;
-			const prior = readState?.get(absKey);
-			if (readState && prior) readState.set(absKey, {
+		const readState = resolveReadStateMap(ctx);
+		if (readState) {
+			const absKey = readStateKey(ctx.handle.cwd, target);
+			const prior = readState.get(absKey);
+			if (prior) readState.set(absKey, {
 				...prior,
 				contentHash: hashContent(current),
 				mtimeMs: Date.now()
@@ -3936,14 +4301,16 @@ const readFile$1 = {
 			return `File not found: ${path}.${await suggestionFor(ctx.execution, ctx.handle, path)}`;
 		}
 		const totalBytes = Buffer.byteLength(raw);
-		const readState = ctx.behavior?.dedupReads !== false ? getReadState(ctx.session) : void 0;
-		const absKey = `${ctx.handle.cwd}::${path}`;
+		const dedupEnabled = ctx.behavior?.dedupReads !== false;
+		const gateEnabled = ctx.behavior?.requireReadBeforeEdit === true;
+		const readState = dedupEnabled || gateEnabled ? resolveReadStateMap(ctx) : void 0;
+		const absKey = readStateKey(ctx.handle.cwd, path);
 		const offsetForKey = normalizeInteger(offset, 1);
 		const limitForKey = normalizeInteger(limit, DEFAULT_LINE_LIMIT);
 		const maxBytesForKey = normalizeInteger(maxBytes, DEFAULT_BYTE_CAP);
 		const showLineNumbers = typeof lineNumbers === "boolean" ? lineNumbers : ctx.behavior?.readLineNumbers ?? true;
 		const currentHash = readState ? hashContent(raw) : "";
-		if (readState) {
+		if (dedupEnabled && readState) {
 			const prior = readState.get(absKey);
 			if (prior && prior.contentHash === currentHash && prior.offset === offsetForKey && prior.limit === limitForKey && prior.maxBytes === maxBytesForKey && prior.lineNumbers === showLineNumbers) return `File ${path} unchanged since the previous read in this session — the prior result is still current.`;
 		}
@@ -4161,6 +4528,8 @@ const BUBBLED_EVENTS = [
 	"stream:text",
 	"stream:thinking",
 	"stream:end",
+	"stream:error",
+	"tool:dispatched",
 	"tool:before",
 	"tool:after",
 	"tool:error",
@@ -4175,6 +4544,8 @@ const CHILD_EVENT_NAME = {
 	"stream:text": "child:stream:text",
 	"stream:thinking": "child:stream:thinking",
 	"stream:end": "child:stream:end",
+	"stream:error": "child:stream:error",
+	"tool:dispatched": "child:tool:dispatched",
 	"tool:before": "child:tool:before",
 	"tool:after": "child:tool:after",
 	"tool:error": "child:tool:error",
@@ -4385,18 +4756,23 @@ function createSpawnTool(options = {}) {
 			let result = "";
 			let unbubble;
 			try {
-				const agent = createAgent({
+				const parentPreset = {
 					...ctx.name !== void 0 ? { name: ctx.name } : {},
 					...ctx.system !== void 0 ? { system: ctx.system } : {},
 					tools: ctx.tools,
 					...ctx.toolAliases !== void 0 ? { toolAliases: ctx.toolAliases } : {},
 					...ctx.mcpServers !== void 0 ? { mcpServers: ctx.mcpServers } : {},
 					...ctx.skills !== void 0 ? { skills: ctx.skills } : {},
-					...ctx.behavior !== void 0 ? { behavior: ctx.behavior } : {},
+					...ctx.behavior !== void 0 ? { behavior: ctx.behavior } : {}
+				};
+				const sharedReadState = options.shareReadState ? resolveReadStateMap(ctx) : void 0;
+				const agent = createAgent({
+					...parentPreset,
 					...options.preset,
 					provider: ctx.provider,
 					execution: ctx.execution,
-					...options.persist && ctx.session ? { session: ctx.session } : {}
+					...options.persist && ctx.session ? { session: ctx.session } : {},
+					...sharedReadState ? { readState: sharedReadState } : {}
 				});
 				if (forwardHooks) {
 					const unregisterEnricher = agent.hooks.hook("tool:before", async (toolCtx) => {
@@ -4571,6 +4947,6 @@ const writeFile$1 = {
 	}
 };
 //#endregion
-export { maybePersistToolResult as C, cleanupPersistedSession as S, getReadState as T, createSkillsReadTool as _, multiEdit as a, PERSISTENCE_PREVIEW_BYTES as b, grep as c, resolveOldString as d, styleReplacementForVia as f, createSkillsRunScriptTool as g, createSkillsUseTool as h, readFile$1 as i, glob as l, createToolSearchTool as m, createSpawnTool as n, listFiles as o, createAgent as p, shell as r, createInteractionTool as s, writeFile$1 as t, edit as u, validateToolArgs as v, resolvePersistDir as w, buildPersistedStub as x, PERSISTED_STUB_PREFIX as y };
+export { readStateKey as A, PERSISTENCE_PREVIEW_BYTES as C, resolvePersistDir as D, maybePersistToolResult as E, getReadState as O, PERSISTED_STUB_PREFIX as S, cleanupPersistedSession as T, createSkillsReadTool as _, multiEdit as a, TOOL_USE_SKIPPED_MESSAGE as b, grep as c, resolveOldString as d, styleReplacementForVia as f, createSkillsRunScriptTool as g, createSkillsUseTool as h, readFile$1 as i, resolveReadStateMap as j, hashContent as k, glob as l, createToolSearchTool as m, createSpawnTool as n, listFiles as o, createAgent as p, shell as r, createInteractionTool as s, writeFile$1 as t, edit as u, INTERRUPT_MESSAGE_FOR_TOOL_USE as v, buildPersistedStub as w, validateToolArgs as x, TOOL_USE_AFTER_ERROR_MESSAGE as y };
 
-//# sourceMappingURL=tools-CMVruxF0.js.map
+//# sourceMappingURL=tools-CCsL5SCO.js.map