zidane 6.5.1 → 6.5.3

package/dist/{agent-BVNkC1h4.js → agent-8kfGIDb_.js}

@@ -1,6 +1,6 @@
 import { B as rewriteMessagesToWire, H as toWireName, I as augmentMcpDoubleUnderscoreAliases, L as buildAliasMaps, M as buildPromptMessage, N as canonicalizePrompt, R as buildSanitizedWireAliases, V as toCanonicalName, z as rewriteContentToCanonical } from "./openai-compat-CnHeo4Lz.js";
 import { a as isWireTurn, c as toolOutputByteLength, i as documentBlockMarker, l as toolResultToText, o as sanitizeToolResultMetadata, s as toolOutputBudgetByteLength, t as DEFAULT_AGENT_CLOCK } from "./types-BIarq1qE.js";
-import { a as styleReplacementForVia, i as stripLineNumberPrefixes, n as describeVia, r as resolveOldString, t as buildContextBreakdown } from "./context-breakdown-BLF10tOO.js";
+import { a as stripLineNumberPrefixes, i as resolveOldString, n as buildContextBreakdown, o as styleReplacementForVia, r as describeVia, t as buildContextSegments } from "./context-segments-1mcqSCM3.js";
 import { n as estimateTokens, r as utf8ByteLength } from "./utils-ngQzYzZD.js";
 import { a as formatDuration, c as previewLine, o as formatTaskStatus, s as formatTaskSummary } from "./format-BF745pLL.js";
 import { i as parseGitLsFiles, r as GIT_LS_FILES_COMMAND } from "./glob-DluQFSw1.js";
@@ -13,7 +13,7 @@ import { n as writeFileAtomicAsync, t as writeFileAtomic } from "./atomic-write-
 import { p as resolveStorageDirs, r as loadAgentPlugin } from "./plugins-2PMTVcp-.js";
 import { r as createLogger, t as consoleSink } from "./logger-DBX9uYOw.js";
 import { n as reconcileImageMediaType } from "./media-sniff-UKijEaiQ.js";
-import { f as wrapDiscoveredMcpTools, i as deriveMcpToolMeta, n as connectMcpServers, s as nonOwningMcpView } from "./mcp-C6IkXNOS.js";
+import { f as wrapDiscoveredMcpTools, i as deriveMcpToolMeta, n as connectMcpServers, s as nonOwningMcpView } from "./mcp-D9fqOQo5.js";
 import { appendStaticSection, renderSystemForWire } from "./prompt.js";
 import { a as detectTurnInterruption, c as ensureToolResultPairing, l as filterUnresolvedToolUses, m as resolveContentRefsInMessages, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, p as remintDuplicateToolCallIds, s as ensureEndsWithUserMessage } from "./messages-C_H9soi5.js";
 import { a as getExtensionSessionState, c as setExtensionSessionState, l as withExtensionSession, n as currentExtensionSession, r as deleteExtensionSessionState, s as resumeChainRunIds } from "./session-VpLrNaFQ.js";
@@ -10542,6 +10542,134 @@ function textForPersistence(output) {
 	return parts.join("\n");
 }
 //#endregion
+//#region src/loop-recovery.ts
+/**
+* Operation labels used by the provider-stream watchdogs.
+*
+* Single source of truth for the strings so `withTimeout` callers and the
+* failure classifier can never drift: the classifier matches on exactly the
+* label the watchdog emits.
+*/
+const PROVIDER_WATCHDOG_OPERATIONS = {
+	"first response": "provider first response",
+	"total stream": "provider total stream",
+	"stream inactivity": "provider stream inactivity"
+};
+/** Watchdog operation names that count as provider-stream failures. */
+const PROVIDER_WATCHDOG_OPERATION_SET = new Set(Object.values(PROVIDER_WATCHDOG_OPERATIONS));
+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
+	};
+}
+/**
+* Classify a failed stream attempt.
+*
+* Retry eligibility covers two sources: an error the provider's own classifier
+* marked retryable, and a provider-stream watchdog timeout. The latter is
+* retryable BY CONSTRUCTION for the first-response watchdog — zero observable
+* events arrived, so re-issuing is at least as safe as the mid-stream
+* `overloaded_error` retries the classifier opts into. The total-stream and
+* inactivity watchdogs ride the same carve-out but lean on `cleanSlate` for
+* their safety.
+*
+* Fallback excludes two classifications:
+* - `context_exceeded` — owned by overflow recovery; the transcript is the
+*   problem, not the provider.
+* - `tool_pairing_corruption` — transcript-level corruption fails identically
+*   on every provider.
+*
+* Everything else (rate limit, overload, 5xx, auth/billing, even unclassified
+* network failures) is provider-side: a sibling target may well succeed, and a
+* genuinely broken request just exhausts the chain and surfaces the last error.
+*/
+function assessStreamFailure(input) {
+	const { err, runAborted, classifyError, progress, attempt, retry, hasNextTarget } = input;
+	const wasAborted = runAborted || err instanceof Error && err.name === "AbortError";
+	const classified = !wasAborted ? classifyError?.(err) ?? null : null;
+	const cleanSlate = progress.text === "" && progress.thinking === "" && !progress.serverToolActivity;
+	const isRetryable = classified?.kind === "provider_error" && classified.retryable === true;
+	const isStreamWatchdogTimeout = !wasAborted && err instanceof OperationTimeoutError && PROVIDER_WATCHDOG_OPERATION_SET.has(err.operation);
+	const canRetry = !wasAborted && (isRetryable || isStreamWatchdogTimeout) && cleanSlate && attempt < retry.maxAttempts;
+	const retryAfterMs = canRetry ? extractRetryAfterMs(err) : void 0;
+	return {
+		wasAborted,
+		classified,
+		cleanSlate,
+		retryAfterMs,
+		canRetry,
+		preferFallbackOverRetry: retryAfterMs !== void 0 && retryAfterMs > 15e3 && hasNextTarget,
+		canRecoverOverflow: !wasAborted && classified?.kind === "context_exceeded" && cleanSlate,
+		canFallback: !wasAborted && cleanSlate && hasNextTarget && classified?.kind !== "context_exceeded" && classified?.kind !== "tool_pairing_corruption"
+	};
+}
+/**
+* Backoff delay for the next attempt.
+*
+* A server-declared `retry-after` wins (capped at `maxDelayMs`); otherwise
+* full-jitter exponential backoff — a uniform draw from `[0, capped)` rather
+* than a fixed `capped`, so a fleet of clients retrying the same overloaded
+* endpoint spreads out instead of stampeding in lockstep.
+*/
+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;
+	}
+}
+//#endregion
 //#region src/loop.ts
 const DEFAULT_PROVIDER_STREAM_START_TIMEOUT_MS = 300 * 1e3;
 const DEFAULT_PROVIDER_STREAM_TIMEOUT_MS = 1800 * 1e3;
@@ -10553,7 +10681,7 @@ const DEFAULT_PROVIDER_STREAM_TIMEOUT_MS = 1800 * 1e3;
 */
 const DEFAULT_HOOK_TIMEOUT_MS = 300 * 1e3;
 function hookTimeoutMsFor(ctx) {
-	return resolveTimeoutMs(ctx.hookTimeoutMs, DEFAULT_HOOK_TIMEOUT_MS);
+	return resolveTimeoutMs(ctx.behavior.hookTimeoutMs, DEFAULT_HOOK_TIMEOUT_MS);
 }
 /**
 * Dispatch an already-invoked hook promise under {@link LoopContext.hookTimeoutMs},
@@ -11349,12 +11477,12 @@ 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({
+	if (ctx.behavior.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
 	});
-	const rawLimit = ctx.maxPairingRepairsPerTurn;
+	const rawLimit = ctx.behavior.maxPairingRepairsPerTurn;
 	const limit = typeof rawLimit === "number" && Number.isFinite(rawLimit) && rawLimit > 0 ? rawLimit : Number.POSITIVE_INFINITY;
 	if (repairs.length > limit) throw new AgentToolPairingError({
 		message: `Pairing-repair storm: ${repairs.length} repairs in a single turn (limit ${limit}). The transcript is systematically corrupt (likely duplicate tool_use ids from the provider); continuing would loop without forward progress.`,
@@ -11420,19 +11548,19 @@ async function runLoop(ctx) {
 	let totalCacheCreation = 0;
 	const turnUsages = [];
 	const startTime = Date.now();
-	const maxTurns = ctx.maxTurns ?? Number.POSITIVE_INFINITY;
+	const maxTurns = ctx.behavior.maxTurns ?? Number.POSITIVE_INFINITY;
 	let turnsCompleted = 0;
-	const pauseCap = ctx.maxConsecutivePauseTurns ?? 0;
+	const pauseCap = ctx.behavior.maxConsecutivePauseTurns ?? 0;
 	let consecutiveEmptyPauseTurns = 0;
-	const maxConsecutiveLengthResumes = ctx.maxConsecutiveLengthResumes ?? 8;
+	const maxConsecutiveLengthResumes = ctx.behavior.maxConsecutiveLengthResumes ?? 8;
 	let consecutiveLengthResumes = 0;
 	const maxConsecutiveEmptyLengthResumes = 2;
 	let consecutiveEmptyLengthResumes = 0;
-	const maxConsecutiveRefusalResumes = ctx.maxConsecutiveRefusalResumes ?? 3;
+	const maxConsecutiveRefusalResumes = ctx.behavior.maxConsecutiveRefusalResumes ?? 3;
 	let consecutiveRefusalResumes = 0;
-	const wallDeadlineActive = typeof ctx.maxWallMs === "number" && Number.isFinite(ctx.maxWallMs) && ctx.maxWallMs > 0;
+	const wallDeadlineActive = typeof ctx.behavior.maxWallMs === "number" && Number.isFinite(ctx.behavior.maxWallMs) && ctx.behavior.maxWallMs > 0;
 	const wallStartMs = wallDeadlineActive ? await ctx.clock.now() : 0;
-	const maxTurnsWarnAt = Number.isFinite(maxTurns) && typeof ctx.maxTurnsWarning === "number" && Number.isFinite(ctx.maxTurnsWarning) && ctx.maxTurnsWarning > 0 && ctx.maxTurnsWarning < maxTurns ? Math.floor(ctx.maxTurnsWarning) : void 0;
+	const maxTurnsWarnAt = Number.isFinite(maxTurns) && typeof ctx.behavior.maxTurnsWarning === "number" && Number.isFinite(ctx.behavior.maxTurnsWarning) && ctx.behavior.maxTurnsWarning > 0 && ctx.behavior.maxTurnsWarning < maxTurns ? Math.floor(ctx.behavior.maxTurnsWarning) : void 0;
 	let maxTurnsWarned = false;
 	const ttft = { mark: void 0 };
 	const markTtft = () => {
@@ -11504,9 +11632,9 @@ async function runLoop(ctx) {
 				break;
 			}
 			const breach = checkRunBudget({
-				maxCostUsd: ctx.maxCostUsd,
-				maxTotalTokens: ctx.maxTotalTokens,
-				maxWallMs: ctx.maxWallMs,
+				maxCostUsd: ctx.behavior.maxCostUsd,
+				maxTotalTokens: ctx.behavior.maxTotalTokens,
+				maxWallMs: ctx.behavior.maxWallMs,
 				cost: turnUsages.reduce((s, t) => s + (t.cost ?? 0), 0),
 				tokens: totalIn + totalOut,
 				elapsedMs: wallDeadlineActive ? await ctx.clock.now() - wallStartMs : 0
@@ -11542,7 +11670,7 @@ async function runLoop(ctx) {
 			if (!result.ended && !maxTurnsWarned && maxTurnsWarnAt !== void 0 && maxTurns - (turn + 1) <= maxTurnsWarnAt) {
 				maxTurnsWarned = true;
 				const remaining = maxTurns - (turn + 1);
-				const warning = formatMaxTurnsWarning(ctx.maxTurnsWarningMessage, {
+				const warning = formatMaxTurnsWarning(ctx.behavior.maxTurnsWarningMessage, {
 					remaining,
 					maxTurns
 				});
@@ -11584,7 +11712,7 @@ async function runLoop(ctx) {
 			}
 		}
 		let exhaustedOutput;
-		if (ctx.schema && !ctx.signal.aborted && turnsCompleted > 0) {
+		if (ctx.behavior.schema && !ctx.signal.aborted && turnsCompleted > 0) {
 			const enforcement = await enforceSchemaOutput(ctx, ctx.clock.randomUUID());
 			exhaustedOutput = enforcement.output;
 			totalIn += enforcement.usage.input;
@@ -11715,7 +11843,7 @@ async function enforceSchemaOutput(ctx, turnId) {
 	const outputSpec = {
 		name: "__output__",
 		description: "Return the final structured output matching the required schema.",
-		inputSchema: ctx.schema
+		inputSchema: ctx.behavior.schema
 	};
 	const schemaMessages = ensureEndsWithUserMessage(applyPairingRepair(ctx, rewriteMessagesToWire(await resolveContentRefsForWire(ctx, turnsToMessages(applyCompactSummaryCutoff(ctx.turns))), ctx.aliasMaps), turnId), ctx.provider);
 	let schemaResult;
@@ -11725,8 +11853,8 @@ async function enforceSchemaOutput(ctx, turnId) {
 			system: ctx.system,
 			tools: ctx.provider.formatTools([outputSpec]),
 			messages: schemaMessages,
-			maxTokens: ctx.maxTokens,
-			...ctx.modelCatalog ? { modelCatalog: ctx.modelCatalog } : {},
+			maxTokens: ctx.behavior.maxTokens,
+			...ctx.behavior.modelCatalog ? { modelCatalog: ctx.behavior.modelCatalog } : {},
 			toolChoice: {
 				type: "tool",
 				name: "__output__"
@@ -11743,7 +11871,7 @@ async function enforceSchemaOutput(ctx, turnId) {
 	const output = schemaResult.toolCalls.find((tc) => tc.name === "__output__")?.input;
 	if (output) await ctx.hooks.callHook("output", {
 		output,
-		schema: ctx.schema
+		schema: ctx.behavior.schema
 	});
 	const schemaTurn = {
 		id: ctx.clock.randomUUID(),
@@ -11820,17 +11948,11 @@ function wrapProviderError(err, ctx) {
 * classifier so the retry carve-out can't silently detach from the errors
 * it targets when a label is renamed.
 */
-const PROVIDER_WATCHDOG_OPERATIONS = {
-	"first response": "provider first response",
-	"total stream": "provider total stream",
-	"stream inactivity": "provider stream inactivity"
-};
-const PROVIDER_WATCHDOG_OPERATION_SET = new Set(Object.values(PROVIDER_WATCHDOG_OPERATIONS));
 function providerWatchdogTimeouts(ctx) {
 	return {
-		startTimeoutMs: resolveTimeoutMs(ctx.providerStreamStartTimeoutMs, DEFAULT_PROVIDER_STREAM_START_TIMEOUT_MS, ctx.maxWallMs),
-		totalTimeoutMs: resolveTimeoutMs(ctx.providerStreamTimeoutMs, DEFAULT_PROVIDER_STREAM_TIMEOUT_MS, ctx.maxWallMs),
-		idleTimeoutMs: resolveTimeoutMs(ctx.providerStreamIdleTimeoutMs, 0, ctx.maxWallMs)
+		startTimeoutMs: resolveTimeoutMs(ctx.behavior.providerStreamStartTimeoutMs, DEFAULT_PROVIDER_STREAM_START_TIMEOUT_MS, ctx.behavior.maxWallMs),
+		totalTimeoutMs: resolveTimeoutMs(ctx.behavior.providerStreamTimeoutMs, DEFAULT_PROVIDER_STREAM_TIMEOUT_MS, ctx.behavior.maxWallMs),
+		idleTimeoutMs: resolveTimeoutMs(ctx.behavior.providerStreamIdleTimeoutMs, 0, ctx.behavior.maxWallMs)
 	};
 }
 function stripInvalidAnthropicThinking(content) {
@@ -12140,11 +12262,6 @@ 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
-};
 /**
 * First-response watchdog cap for RETRY attempts (attempt ≥ 2). The first
 * attempt gets the full `providerStreamStartTimeoutMs` window (large-prompt
@@ -12277,7 +12394,7 @@ async function maybeAutoCompact(ctx, turn, lastTurnUsage, state) {
 			keepTurns: cfg.keepTurns,
 			signal: ctx.signal,
 			onProgress,
-			...ctx.providerStreamTimeoutMs !== void 0 ? { providerStreamTimeoutMs: ctx.providerStreamTimeoutMs } : {}
+			...ctx.behavior.providerStreamTimeoutMs !== void 0 ? { providerStreamTimeoutMs: ctx.behavior.providerStreamTimeoutMs } : {}
 		});
 		const summaryTurn = summaryToTurn({
 			summary: result.summary,
@@ -12310,8 +12427,8 @@ async function maybeAutoCompact(ctx, turn, lastTurnUsage, state) {
 		}
 		ctx.turns.push(summaryTurn, ...restorationTurns);
 		await ctx.persistTurns?.();
-		if (cfg.releaseReplacedTurns && ctx.persistDir && result.summarizedTurnIds.length > 0) try {
-			await releaseReplacedTurnContent(ctx.turns, new Set(result.summarizedTurnIds), { persistDir: ctx.persistDir });
+		if (cfg.releaseReplacedTurns && ctx.behavior.persistDir && result.summarizedTurnIds.length > 0) try {
+			await releaseReplacedTurnContent(ctx.turns, new Set(result.summarizedTurnIds), { persistDir: ctx.behavior.persistDir });
 		} catch (err) {
 			if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/loop] post-compact turn release failed: ${errorMessage(err)}\n`);
 		}
@@ -12348,87 +12465,6 @@ async function maybeAutoCompact(ctx, turn, lastTurnUsage, state) {
 	}
 }
 /**
-* 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).
-*/
-/**
-* Server-declared `retry-after` above this is treated as "not a transient
-* blip" by the fallback machinery: burst rate limits announce seconds,
-* quota/usage exhaustion announces minutes-to-hours. A run holding more
-* fallback targets fails over immediately instead of burning its retry
-* budget against a wall that won't move within the wait window; a
-* single-target run still waits (capped at `maxDelayMs`) because waiting
-* is its only option.
-*/
-const LONG_RETRY_AFTER_FALLBACK_MS = 15e3;
-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
@@ -12451,11 +12487,60 @@ function abortableSleep(ms, signal) {
 		signal.addEventListener("abort", onAbort, { once: true });
 	});
 }
+/**
+* Advance the run to the next provider+model target and rebind the prepared
+* request to it.
+*
+* Caller contract: only invoke when `assessStreamFailure` returned
+* `canFallback` — that verdict guarantees an untried target exists, so the
+* index arithmetic here needs no bounds check of its own.
+*
+* Run-sticky: `activeTargetIndex` only advances, so later turns of this run
+* stay on the fallback target. The next `run()` resolves a fresh target list
+* starting from the primary.
+*/
+async function advanceToFallbackTarget(ctx, streamOptions, turnId, err) {
+	const targets = ctx.targets;
+	const fromIndex = ctx.activeTargetIndex ?? 0;
+	const nextIndex = fromIndex + 1;
+	const from = targets[fromIndex];
+	const to = targets[nextIndex];
+	ctx.activeTargetIndex = nextIndex;
+	ctx.provider = to.provider;
+	ctx.model = to.model;
+	ctx.providerName = to.provider.name;
+	if (ctx.rebuildFormattedTools) ctx.formattedTools = ctx.rebuildFormattedTools(to.provider);
+	(ctx.targetFailures ??= []).push({
+		provider: from.provider.name,
+		model: from.model,
+		err
+	});
+	if (ctx.autoCompact) {
+		const nextWindow = to.contextWindow ?? (ctx.autoCompact.contextWindowFromProviderMeta ? to.provider.meta.contextWindow : void 0);
+		if (nextWindow !== void 0 && Number.isFinite(nextWindow) && nextWindow > 0) ctx.autoCompact.contextWindow = nextWindow;
+	}
+	streamOptions.model = to.model;
+	streamOptions.tools = ctx.formattedTools;
+	streamOptions.messages = sanitizeStoredToolResults(to.provider, streamOptions.messages);
+	await settledHook(ctx, "hook model:fallback", ctx.hooks.callHook("model:fallback", {
+		turnId,
+		from: {
+			provider: from.provider.name,
+			model: from.model
+		},
+		to: {
+			provider: to.provider.name,
+			model: to.model
+		},
+		targetIndex: nextIndex,
+		err
+	}));
+}
 async function executeTurn(ctx, turn, priorUsage) {
 	const turnId = ctx.clock.randomUUID();
 	let canonicalMessages = turnsToMessages(applyCompactSummaryCutoff(ctx.turns));
 	canonicalMessages = await resolveContentRefsForWire(ctx, canonicalMessages);
-	if (ctx.elideStaleReads === true || ctx.elideStaleReads === "stub") {
+	if (ctx.behavior.elideStaleReads === true || ctx.behavior.elideStaleReads === "stub") {
 		/**
 		* Deliberately UNQUANTIZED, unlike tail compaction and media age-out below.
 		*
@@ -12483,30 +12568,30 @@ async function executeTurn(ctx, turn, priorUsage) {
 	let sanitizedMessages = sanitizeStoredToolResults(ctx.provider, wireMessages);
 	let callMapsMemo;
 	const callMaps = () => callMapsMemo ??= collectCallMaps(canonicalMessages);
-	if (ctx.compactStrategy === "tail") {
-		const threshold = typeof ctx.compactThreshold === "number" && ctx.compactThreshold > 0 ? ctx.compactThreshold : 131072;
-		const keep = typeof ctx.compactKeepTurns === "number" && ctx.compactKeepTurns >= 0 ? ctx.compactKeepTurns : 4;
+	if (ctx.behavior.compactStrategy === "tail") {
+		const threshold = typeof ctx.behavior.compactThreshold === "number" && ctx.behavior.compactThreshold > 0 ? ctx.behavior.compactThreshold : 131072;
+		const keep = typeof ctx.behavior.compactKeepTurns === "number" && ctx.behavior.compactKeepTurns >= 0 ? ctx.behavior.compactKeepTurns : 4;
 		const { readPathByCallId, toolNameByCallId } = callMaps();
 		const compacted = applyTailCompaction(sanitizedMessages, threshold, keep, {
 			readPathByCallId,
 			toolNameByCallId,
 			chunkTurns: 8,
-			persistElideMinBytes: ctx.persistDir ? PERSISTENCE_PREVIEW_BYTES : 0
+			persistElideMinBytes: ctx.behavior.persistDir ? PERSISTENCE_PREVIEW_BYTES : 0
 		});
 		sanitizedMessages = compacted.messages;
 		markReadStateForElidedPaths(ctx, ctx.handle.cwd, compacted.elidedReadPaths);
-		if (ctx.persistDir && compacted.persistableElided.length > 0) sanitizedMessages = await persistElidedToolResults(sanitizedMessages, compacted.persistableElided, {
-			persistDir: ctx.persistDir,
-			maxBytes: ctx.persistMaxBytes,
+		if (ctx.behavior.persistDir && compacted.persistableElided.length > 0) sanitizedMessages = await persistElidedToolResults(sanitizedMessages, compacted.persistableElided, {
+			persistDir: ctx.behavior.persistDir,
+			maxBytes: ctx.behavior.persistMaxBytes,
 			writeBlob: executionBlobWriter(ctx)
 		});
-	} 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;
+	} else if (typeof ctx.behavior.compactStrategy === "function") {
+		const threshold = typeof ctx.behavior.compactThreshold === "number" && ctx.behavior.compactThreshold > 0 ? ctx.behavior.compactThreshold : 131072;
+		const keep = typeof ctx.behavior.compactKeepTurns === "number" && ctx.behavior.compactKeepTurns >= 0 ? ctx.behavior.compactKeepTurns : 4;
 		let totalBytes = 0;
 		for (const msg of sanitizedMessages) for (const block of msg.content) if (block.type === "tool_result") totalBytes += memoizedToolResultBudgetBytes(block);
 		try {
-			const compacted = await ctx.compactStrategy(sanitizedMessages, {
+			const compacted = await ctx.behavior.compactStrategy(sanitizedMessages, {
 				threshold,
 				keepTurns: keep,
 				totalBytes
@@ -12516,9 +12601,9 @@ async function executeTurn(ctx, turn, priorUsage) {
 			console.error("[zidane] compactStrategy function threw:", err);
 		}
 	}
-	if (typeof ctx.mediaKeepTurns === "number" && ctx.mediaKeepTurns >= 0 && ctx.tools.read_file) {
+	if (typeof ctx.behavior.mediaKeepTurns === "number" && ctx.behavior.mediaKeepTurns >= 0 && ctx.tools.read_file) {
 		const { readPathByCallId } = callMaps();
-		const aged = applyMediaAgeout(sanitizedMessages, ctx.mediaKeepTurns, {
+		const aged = applyMediaAgeout(sanitizedMessages, ctx.behavior.mediaKeepTurns, {
 			chunkTurns: 8,
 			readPathByCallId,
 			readFileToolName: toWireName("read_file", ctx.aliasMaps),
@@ -12527,22 +12612,22 @@ async function executeTurn(ctx, turn, priorUsage) {
 		sanitizedMessages = aged.messages;
 		markReadStateForElidedPaths(ctx, ctx.handle.cwd, aged.elidedReadPaths);
 	}
-	const effectiveThinkingBudget = ctx.thinking === "adaptive" && ctx.provider.meta.capabilities?.adaptiveBudgetIsEnvelope === true ? ctx.thinkingBudget : applyThinkingDecay(ctx.thinkingBudget, ctx.thinkingDecay, turn + 1);
+	const effectiveThinkingBudget = ctx.thinking === "adaptive" && ctx.provider.meta.capabilities?.adaptiveBudgetIsEnvelope === true ? ctx.behavior.thinkingBudget : applyThinkingDecay(ctx.behavior.thinkingBudget, ctx.behavior.thinkingDecay, turn + 1);
 	const formattedTools = ctx.rebuildFormattedTools ? ctx.rebuildFormattedTools(ctx.provider) : ctx.formattedTools;
 	const streamOptions = {
 		model: ctx.model,
 		system: ctx.system,
 		tools: formattedTools,
 		messages: sanitizedMessages,
-		maxTokens: ctx.maxTokens,
-		...ctx.modelCatalog ? { modelCatalog: ctx.modelCatalog } : {},
+		maxTokens: ctx.behavior.maxTokens,
+		...ctx.behavior.modelCatalog ? { modelCatalog: ctx.behavior.modelCatalog } : {},
 		thinking: ctx.thinking,
 		thinkingBudget: effectiveThinkingBudget,
-		...ctx.taskBudget !== void 0 ? { taskBudget: ctx.taskBudget } : {},
-		...ctx.effortHint !== void 0 ? { effortHint: ctx.effortHint } : {},
+		...ctx.behavior.taskBudget !== void 0 ? { taskBudget: ctx.behavior.taskBudget } : {},
+		...ctx.behavior.effortHint !== void 0 ? { effortHint: ctx.behavior.effortHint } : {},
 		...ctx.modelOptions ? { modelOptions: ctx.modelOptions } : {},
-		cache: ctx.cache ?? true,
-		...ctx.cacheTtl !== void 0 ? { cacheTtl: ctx.cacheTtl } : {},
+		cache: ctx.behavior.cache ?? true,
+		...ctx.behavior.cacheTtl !== void 0 ? { cacheTtl: ctx.behavior.cacheTtl } : {},
 		signal: ctx.signal
 	};
 	const transformCtx = { messages: streamOptions.messages };
@@ -12585,7 +12670,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 			if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/loop] stream hook handler threw: ${errorMessage(err)}\n`);
 		});
 	};
-	const retryCfg = resolveRetryConfig(ctx.retry);
+	const retryCfg = resolveRetryConfig(ctx.behavior.retry);
 	let result;
 	let attempt = 0;
 	let overflowRecoveries = 0;
@@ -12641,17 +12726,23 @@ async function executeTurn(ctx, turn, priorUsage) {
 			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;
-			const cleanSlate = currentText === "" && currentThinking === "" && !serverToolActivity;
-			const isStreamWatchdogTimeout = !wasAborted && caught instanceof OperationTimeoutError && PROVIDER_WATCHDOG_OPERATION_SET.has(caught.operation);
-			const canRetry = !wasAborted && (isRetryable || isStreamWatchdogTimeout) && cleanSlate && attempt < retryCfg.maxAttempts;
-			const retryAfterMs = canRetry ? extractRetryAfterMs(caught) : void 0;
-			const hasNextTarget = ctx.targets !== void 0 && (ctx.activeTargetIndex ?? 0) + 1 < ctx.targets.length;
-			if (canRetry && !(retryAfterMs !== void 0 && retryAfterMs > LONG_RETRY_AFTER_FALLBACK_MS && hasNextTarget)) {
+			const failure = assessStreamFailure({
+				err: caught,
+				runAborted: ctx.signal.aborted,
+				classifyError: ctx.provider.classifyError?.bind(ctx.provider),
+				progress: {
+					text: currentText,
+					thinking: currentThinking,
+					serverToolActivity
+				},
+				attempt,
+				retry: retryCfg,
+				hasNextTarget: ctx.targets !== void 0 && (ctx.activeTargetIndex ?? 0) + 1 < ctx.targets.length
+			});
+			let wasAborted = failure.wasAborted;
+			if (failure.canRetry && !failure.preferFallbackOverRetry) {
 				const meta = extractStreamErrorMeta(caught);
-				const delayMs = computeRetryDelayMs(attempt, retryCfg, retryAfterMs);
+				const delayMs = computeRetryDelayMs(attempt, retryCfg, failure.retryAfterMs);
 				await settledHook(ctx, "hook stream:retry", ctx.hooks.callHook("stream:retry", {
 					turnId,
 					attempt,
@@ -12671,7 +12762,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 					wasAborted = true;
 				}
 			}
-			if (!wasAborted && classified?.kind === "context_exceeded" && cleanSlate && overflowRecoveries < CONTEXT_OVERFLOW_KEEP_TURNS.length) {
+			if (!wasAborted && failure.canRecoverOverflow && overflowRecoveries < CONTEXT_OVERFLOW_KEEP_TURNS.length) {
 				const { readPathByCallId, toolNameByCallId } = callMaps();
 				let recoveredMessages;
 				const elidedReadPaths = [];
@@ -12708,45 +12799,10 @@ async function executeTurn(ctx, turn, priorUsage) {
 					continue;
 				}
 			}
-			if (!wasAborted && cleanSlate && ctx.targets && classified?.kind !== "context_exceeded" && classified?.kind !== "tool_pairing_corruption") {
-				const fromIndex = ctx.activeTargetIndex ?? 0;
-				const nextIndex = fromIndex + 1;
-				if (nextIndex < ctx.targets.length) {
-					const from = ctx.targets[fromIndex];
-					const to = ctx.targets[nextIndex];
-					ctx.activeTargetIndex = nextIndex;
-					ctx.provider = to.provider;
-					ctx.model = to.model;
-					ctx.providerName = to.provider.name;
-					if (ctx.rebuildFormattedTools) ctx.formattedTools = ctx.rebuildFormattedTools(to.provider);
-					(ctx.targetFailures ??= []).push({
-						provider: from.provider.name,
-						model: from.model,
-						err: caught
-					});
-					if (ctx.autoCompact) {
-						const nextWindow = to.contextWindow ?? (ctx.autoCompact.contextWindowFromProviderMeta ? to.provider.meta.contextWindow : void 0);
-						if (typeof nextWindow === "number" && Number.isFinite(nextWindow) && nextWindow > 0) ctx.autoCompact.contextWindow = nextWindow;
-					}
-					streamOptions.model = to.model;
-					streamOptions.tools = ctx.formattedTools;
-					streamOptions.messages = sanitizeStoredToolResults(to.provider, streamOptions.messages);
-					attempt = 0;
-					await settledHook(ctx, "hook model:fallback", ctx.hooks.callHook("model:fallback", {
-						turnId,
-						from: {
-							provider: from.provider.name,
-							model: from.model
-						},
-						to: {
-							provider: to.provider.name,
-							model: to.model
-						},
-						targetIndex: nextIndex,
-						err: caught
-					}));
-					continue;
-				}
+			if (!wasAborted && failure.canFallback) {
+				await advanceToFallbackTarget(ctx, streamOptions, turnId, caught);
+				attempt = 0;
+				continue;
 			}
 			await streamHookChain;
 			const errorUsage = {
@@ -12801,7 +12857,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 		name: toCanonicalName(tc.name, ctx.aliasMaps)
 	}));
 	let canonicalContent = rewriteContentToCanonical(result.assistantMessage?.content ?? [], ctx.aliasMaps);
-	if (canonicalToolCalls.length > 0 && !ctx.strictToolPairing) {
+	if (canonicalToolCalls.length > 0 && !ctx.behavior.strictToolPairing) {
 		const priorIds = /* @__PURE__ */ new Set();
 		for (const t of ctx.turns) for (const block of t.content) if (block.type === "tool_call") priorIds.add(block.id);
 		const reminted = remintDuplicateToolCallIds(canonicalToolCalls, canonicalContent, priorIds);
@@ -12843,7 +12899,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 		},
 		cumulativeUsage: buildCumulativeUsage(priorUsage, result.usage)
 	}));
-	if (ctx.resumeOnMaxTokens && (ctx.maxConsecutiveLengthResumes ?? 8) > 0 && result.usage.finishReason === "length" && canonicalToolCalls.length === 0 && !ctx.signal.aborted) {
+	if (ctx.behavior.resumeOnMaxTokens && (ctx.behavior.maxConsecutiveLengthResumes ?? 8) > 0 && result.usage.finishReason === "length" && canonicalToolCalls.length === 0 && !ctx.signal.aborted) {
 		const continueMsg = ctx.provider.userMessage("Please continue.");
 		ctx.turns.push({
 			id: await ctx.generateTurnId(),
@@ -12860,7 +12916,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 			...currentText.length === 0 ? { lengthEmpty: true } : {}
 		};
 	}
-	if (result.usage.finishReason === "content-filter" && canonicalToolCalls.length === 0 && !ctx.signal.aborted && (ctx.maxConsecutiveRefusalResumes ?? 3) > 0) {
+	if (result.usage.finishReason === "content-filter" && canonicalToolCalls.length === 0 && !ctx.signal.aborted && (ctx.behavior.maxConsecutiveRefusalResumes ?? 3) > 0) {
 		const continueMsg = ctx.provider.userMessage("The previous response was interrupted by the provider (refusal stop). Please continue with the task.");
 		ctx.turns.push({
 			id: await ctx.generateTurnId(),
@@ -12878,7 +12934,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 		};
 	}
 	if (result.done) {
-		if (ctx.schema && !ctx.signal.aborted) {
+		if (ctx.behavior.schema && !ctx.signal.aborted) {
 			const enforcement = await enforceSchemaOutput(ctx, turnId);
 			const sumOptional = (a, b) => ({
 				has: a !== void 0 || b !== void 0,
@@ -12927,7 +12983,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 		};
 	}
 	const toolResults = await executeToolBatch(ctx, canonicalToolCalls, turnId);
-	if (ctx.elideStaleReads === "notice") appendStaleReadNotices(ctx.turns, canonicalToolCalls, toolResults);
+	if (ctx.behavior.elideStaleReads === "notice") appendStaleReadNotices(ctx.turns, canonicalToolCalls, toolResults);
 	const toolResultMsg = ctx.provider.toolResultsMessage(toolResults);
 	const toolResultsTurn = {
 		id: ctx.clock.randomUUID(),
@@ -12943,8 +12999,8 @@ async function executeTurn(ctx, turn, priorUsage) {
 		message: toolResultsTurn,
 		results: toolResults
 	}));
-	if (typeof ctx.toolOutputBudget === "number" && ctx.toolOutputBudget > 0) {
-		const excludeSet = ctx.toolOutputBudgetExcludeTools && ctx.toolOutputBudgetExcludeTools.length > 0 ? new Set(ctx.toolOutputBudgetExcludeTools) : void 0;
+	if (typeof ctx.behavior.toolOutputBudget === "number" && ctx.behavior.toolOutputBudget > 0) {
+		const excludeSet = ctx.behavior.toolOutputBudgetExcludeTools && ctx.behavior.toolOutputBudgetExcludeTools.length > 0 ? new Set(ctx.behavior.toolOutputBudgetExcludeTools) : void 0;
 		const nameById = excludeSet ? new Map(canonicalToolCalls.map((c) => [c.id, c.name])) : void 0;
 		const totalBytes = toolResults.reduce((sum, r) => {
 			if (excludeSet && nameById) {
@@ -12953,8 +13009,8 @@ async function executeTurn(ctx, turn, priorUsage) {
 			}
 			return sum + toolOutputBudgetByteLength(r.content);
 		}, 0);
-		if (totalBytes > ctx.toolOutputBudget) {
-			const warning = `[Tool output budget exceeded: ${totalBytes} text-equivalent bytes returned in this turn (cap: ${ctx.toolOutputBudget}). Summarize the salient findings before calling more tools.]`;
+		if (totalBytes > ctx.behavior.toolOutputBudget) {
+			const warning = `[Tool output budget exceeded: ${totalBytes} text-equivalent bytes returned in this turn (cap: ${ctx.behavior.toolOutputBudget}). Summarize the salient findings before calling more tools.]`;
 			const userMsg = ctx.provider.userMessage(warning);
 			ctx.turns.push({
 				id: await ctx.generateTurnId(),
@@ -12967,7 +13023,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 				turn,
 				turnId,
 				bytes: totalBytes,
-				budget: ctx.toolOutputBudget
+				budget: ctx.behavior.toolOutputBudget
 			});
 		}
 	}
@@ -13042,7 +13098,7 @@ function sanitizeToolOutputForProvider(provider, output) {
 * Empty object when the agent has no live connection.
 */
 function mcpConnectionFor(ctx) {
-	const connection = ctx.agentMcpConnection?.();
+	const connection = ctx.inheritance.mcpConnection?.();
 	if (!connection) return {};
 	return { mcpConnection: nonOwningMcpView(connection) };
 }
@@ -13265,14 +13321,14 @@ async function runSingleToolDispatch(ctx, call, turnId, fixed) {
 			execution: ctx.execution,
 			handle: ctx.handle,
 			hooks: ctx.hooks,
-			tools: ctx.agentTools,
-			...ctx.agentName !== void 0 ? { name: ctx.agentName } : {},
-			...ctx.agentSystem !== void 0 ? { system: ctx.agentSystem } : {},
-			...ctx.agentToolAliases !== void 0 ? { toolAliases: ctx.agentToolAliases } : {},
-			...ctx.agentMcpServers !== void 0 ? { mcpServers: ctx.agentMcpServers } : {},
+			tools: ctx.inheritance.tools,
+			...ctx.inheritance.name !== void 0 ? { name: ctx.inheritance.name } : {},
+			...ctx.inheritance.system !== void 0 ? { system: ctx.inheritance.system } : {},
+			...ctx.inheritance.toolAliases !== void 0 ? { toolAliases: ctx.inheritance.toolAliases } : {},
+			...ctx.inheritance.mcpServers !== void 0 ? { mcpServers: ctx.inheritance.mcpServers } : {},
 			...mcpConnectionFor(ctx),
-			...ctx.agentSkills !== void 0 ? { skills: ctx.agentSkills } : {},
-			...ctx.agentBehavior !== void 0 ? { behavior: ctx.agentBehavior } : {},
+			...ctx.inheritance.skills !== void 0 ? { skills: ctx.inheritance.skills } : {},
+			behavior: ctx.behavior,
 			turnId,
 			callId,
 			runId: ctx.runId,
@@ -13335,7 +13391,7 @@ async function runSingleToolDispatch(ctx, call, turnId, fixed) {
 			isError = true;
 		} else {
 			const error = err instanceof Error ? err : new Error(String(err));
-			if (ctx.shouldRethrowToolError?.(error)) {
+			if (ctx.behavior.shouldRethrowToolError?.(error)) {
 				ctx.toolState?.discard(callId);
 				throw error;
 			}
@@ -13493,8 +13549,8 @@ async function emitToolResult(ctx, params) {
 	const metadata = sanitizedMetadata.metadata;
 	if (sanitizedMetadata.warnings.length > 0 && process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/loop] sanitized tool metadata for ${name}/${callId}: ${sanitizedMetadata.warnings.join("; ")}\n`);
 	const finalOutcome = isError && outcome && outcome !== "failed" ? "failed" : outcome;
-	const threshold = ctx.persistThreshold;
-	const persistDir = ctx.persistDir;
+	const threshold = ctx.behavior.persistThreshold;
+	const persistDir = ctx.behavior.persistDir;
 	if (threshold && threshold > 0 && persistDir) {
 		const outcome = await maybePersistToolResult({
 			toolName: name,
@@ -13502,8 +13558,8 @@ async function emitToolResult(ctx, params) {
 			output,
 			threshold,
 			persistDir,
-			...ctx.persistExcludeTools ? { excludeTools: ctx.persistExcludeTools } : {},
-			...typeof ctx.persistMaxBytes === "number" ? { maxBytes: ctx.persistMaxBytes } : {},
+			...ctx.behavior.persistExcludeTools ? { excludeTools: ctx.behavior.persistExcludeTools } : {},
+			...typeof ctx.behavior.persistMaxBytes === "number" ? { maxBytes: ctx.behavior.persistMaxBytes } : {},
 			writeBlob: executionBlobWriter(ctx)
 		});
 		if (outcome.kind === "persisted") output = outcome.output;
@@ -13593,13 +13649,12 @@ function resolveConcurrencySafe(def, input) {
 * AND carries the shell-cascade signal — siblings see one signal source.
 */
 async function executeToolBatch(ctx, toolCalls, turnId) {
-	if (ctx.toolBatchExecutor) return executeCustomToolBatch(ctx, toolCalls, turnId, ctx.toolBatchExecutor);
+	if (ctx.behavior.toolBatchExecutor && !ctx.suppressBatchExecutor) return executeCustomToolBatch(ctx, toolCalls, turnId, ctx.behavior.toolBatchExecutor);
 	return executeNativeToolBatch(ctx, toolCalls, turnId);
 }
-async function executeCustomToolBatch(ctx, toolCalls, turnId, executor) {
-	if (toolCalls.length === 0) return [];
+function createToolBatchHarness(ctx, toolCalls, turnId, options = {}) {
 	const N = toolCalls.length;
-	const maxConcurrent = Math.max(1, ctx.maxConcurrentTools ?? DEFAULT_MAX_CONCURRENT_TOOLS);
+	const maxConcurrent = Math.max(1, ctx.behavior.maxConcurrentTools ?? DEFAULT_MAX_CONCURRENT_TOOLS);
 	const safe = Array.from({ length: N });
 	for (let i = 0; i < N; i++) safe[i] = resolveConcurrencySafe(ctx.tools[toolCalls[i].name], toolCalls[i].input);
 	const siblingAbort = new AbortController();
@@ -13612,14 +13667,20 @@ async function executeCustomToolBatch(ctx, toolCalls, turnId, executor) {
 	const childCtx = {
 		...ctx,
 		signal: siblingAbort.signal,
-		toolBatchExecutor: void 0
+		...options.suppressBatchExecutor ? { suppressBatchExecutor: true } : {}
 	};
+	/**
+	* Distinguish a shell-cascade kill from a user-issued abort so the model sees
+	* actionable text. When BOTH the parent signal and the sibling signal are
+	* aborted, the parent wins — user-issued aborts take precedence (the model is
+	* being interrupted by the human, not by a sibling's failure).
+	*/
 	const cancelMessage = () => {
 		if (ctx.signal.aborted) return INTERRUPT_MESSAGE_FOR_TOOL_USE;
 		if (siblingAbort.signal.reason === SHELL_CASCADE_REASON) return SHELL_CASCADE_CANCEL_MESSAGE;
 		return INTERRUPT_MESSAGE_FOR_TOOL_USE;
 	};
-	const execute = async (index) => {
+	const settle = async (index) => {
 		const call = toolCalls[index];
 		try {
 			const { result } = await executeSingleTool(childCtx, call, turnId);
@@ -13627,7 +13688,7 @@ async function executeCustomToolBatch(ctx, toolCalls, turnId, executor) {
 			if (result.isError && !isUserCancel && call.name === SHELL_TOOL_NAME && !siblingAbort.signal.aborted) siblingAbort.abort(SHELL_CASCADE_REASON);
 			return result;
 		} catch (err) {
-			if (ctx.shouldRethrowToolError?.(err)) throw err;
+			if (ctx.behavior.shouldRethrowToolError?.(err)) throw err;
 			const isAbort = siblingAbort.signal.aborted || ctx.signal.aborted || err instanceof Error && err.name === "AbortError";
 			return {
 				id: call.id,
@@ -13636,6 +13697,25 @@ async function executeCustomToolBatch(ctx, toolCalls, turnId, executor) {
 			};
 		}
 	};
+	return {
+		childCtx,
+		siblingAbort,
+		safe,
+		maxConcurrent,
+		cancelMessage,
+		settle,
+		dispose: () => {
+			if (parentAbortListener) {
+				ctx.signal.removeEventListener("abort", parentAbortListener);
+				parentAbortListener = void 0;
+			}
+		}
+	};
+}
+async function executeCustomToolBatch(ctx, toolCalls, turnId, executor) {
+	if (toolCalls.length === 0) return [];
+	const harness = createToolBatchHarness(ctx, toolCalls, turnId, { suppressBatchExecutor: true });
+	const { childCtx, siblingAbort, safe, maxConcurrent, cancelMessage } = harness;
 	const executeDurable = async (indices, all) => {
 		const starts = [];
 		const results = /* @__PURE__ */ new Map();
@@ -13700,7 +13780,7 @@ async function executeCustomToolBatch(ctx, toolCalls, turnId, executor) {
 		signal: ctx.signal,
 		steeringQueue: ctx.steeringQueue,
 		isConcurrencySafe: (index) => safe[index] === true,
-		execute,
+		execute: harness.settle,
 		canExecuteDurably: (index) => typeof ctx.tools[toolCalls[index].name]?.durableExecute === "function",
 		executeDurable,
 		interruptedResult: (index) => ({
@@ -13714,7 +13794,7 @@ async function executeCustomToolBatch(ctx, toolCalls, turnId, executor) {
 			isError: true
 		})
 	};
-	const timeoutMs = typeof ctx.toolBatchTimeoutMs === "number" && Number.isFinite(ctx.toolBatchTimeoutMs) && ctx.toolBatchTimeoutMs > 0 ? ctx.toolBatchTimeoutMs : 0;
+	const timeoutMs = typeof ctx.behavior.toolBatchTimeoutMs === "number" && Number.isFinite(ctx.behavior.toolBatchTimeoutMs) && ctx.behavior.toolBatchTimeoutMs > 0 ? ctx.behavior.toolBatchTimeoutMs : 0;
 	try {
 		if (timeoutMs <= 0) return await executor(executionCtx);
 		return await withTimeout$1(executor(executionCtx), {
@@ -13731,7 +13811,7 @@ async function executeCustomToolBatch(ctx, toolCalls, turnId, executor) {
 			isError: true
 		}));
 	} finally {
-		if (parentAbortListener) ctx.signal.removeEventListener("abort", parentAbortListener);
+		harness.dispose();
 	}
 }
 async function startDurableToolExecution(ctx, call, turnId, index) {
@@ -13866,14 +13946,14 @@ async function startDurableToolExecution(ctx, call, turnId, index) {
 		execution: ctx.execution,
 		handle: ctx.handle,
 		hooks: ctx.hooks,
-		tools: ctx.agentTools,
-		...ctx.agentName !== void 0 ? { name: ctx.agentName } : {},
-		...ctx.agentSystem !== void 0 ? { system: ctx.agentSystem } : {},
-		...ctx.agentToolAliases !== void 0 ? { toolAliases: ctx.agentToolAliases } : {},
-		...ctx.agentMcpServers !== void 0 ? { mcpServers: ctx.agentMcpServers } : {},
+		tools: ctx.inheritance.tools,
+		...ctx.inheritance.name !== void 0 ? { name: ctx.inheritance.name } : {},
+		...ctx.inheritance.system !== void 0 ? { system: ctx.inheritance.system } : {},
+		...ctx.inheritance.toolAliases !== void 0 ? { toolAliases: ctx.inheritance.toolAliases } : {},
+		...ctx.inheritance.mcpServers !== void 0 ? { mcpServers: ctx.inheritance.mcpServers } : {},
 		...mcpConnectionFor(ctx),
-		...ctx.agentSkills !== void 0 ? { skills: ctx.agentSkills } : {},
-		...ctx.agentBehavior !== void 0 ? { behavior: ctx.agentBehavior } : {},
+		...ctx.inheritance.skills !== void 0 ? { skills: ctx.inheritance.skills } : {},
+		behavior: ctx.behavior,
 		turnId,
 		callId,
 		runId: ctx.runId,
@@ -13930,7 +14010,7 @@ async function completeDurableToolExecution(ctx, start, output) {
 	};
 }
 async function failDurableToolExecution(ctx, start, err, cancelMessage) {
-	if (ctx.shouldRethrowToolError?.(err)) {
+	if (ctx.behavior.shouldRethrowToolError?.(err)) {
 		ctx.toolState?.discard(start.callId);
 		throw err;
 	}
@@ -14013,49 +14093,14 @@ function errorFromSerializedFailure(failure) {
 async function executeNativeToolBatch(ctx, toolCalls, turnId) {
 	if (toolCalls.length === 0) return [];
 	const N = toolCalls.length;
-	const maxConcurrent = Math.max(1, ctx.maxConcurrentTools ?? DEFAULT_MAX_CONCURRENT_TOOLS);
 	const results = Array.from({ length: N });
-	const safe = Array.from({ length: N });
-	for (let i = 0; i < N; i++) safe[i] = resolveConcurrencySafe(ctx.tools[toolCalls[i].name], toolCalls[i].input);
-	const siblingAbort = new AbortController();
-	let parentAbortListener;
-	if (ctx.signal.aborted) siblingAbort.abort(ctx.signal.reason ?? "parent-aborted");
-	else {
-		parentAbortListener = () => siblingAbort.abort(ctx.signal.reason ?? "parent-aborted");
-		ctx.signal.addEventListener("abort", parentAbortListener, { once: true });
-	}
-	const childCtx = {
-		...ctx,
-		signal: siblingAbort.signal
-	};
+	const harness = createToolBatchHarness(ctx, toolCalls, turnId);
+	const { safe, maxConcurrent } = harness;
 	/** Indices currently in flight. Tracked for fleet-safety + cap checks. */
 	const inFlight = /* @__PURE__ */ new Map();
-	/**
-	* Distinguish a shell-cascade kill from a user-issued abort so the
-	* model sees actionable text. When BOTH the parent signal and the
-	* sibling signal are aborted, the parent wins — user-issued aborts
-	* take precedence (the model is being interrupted by the human, not
-	* by a sibling's failure).
-	*/
-	const cancelMessage = () => {
-		if (ctx.signal.aborted) return INTERRUPT_MESSAGE_FOR_TOOL_USE;
-		if (siblingAbort.signal.reason === SHELL_CASCADE_REASON) return SHELL_CASCADE_CANCEL_MESSAGE;
-		return INTERRUPT_MESSAGE_FOR_TOOL_USE;
-	};
 	const dispatch = (index) => {
-		const call = toolCalls[index];
-		return executeSingleTool(childCtx, call, turnId).then(({ result }) => {
+		return harness.settle(index).then((result) => {
 			results[index] = result;
-			const isUserCancel = typeof result.content === "string" && result.content === "[Tool call cancelled by user]";
-			if (result.isError && !isUserCancel && call.name === SHELL_TOOL_NAME && !siblingAbort.signal.aborted) siblingAbort.abort(SHELL_CASCADE_REASON);
-		}, (err) => {
-			if (ctx.shouldRethrowToolError?.(err)) throw err;
-			const isAbort = siblingAbort.signal.aborted || ctx.signal.aborted || err instanceof Error && err.name === "AbortError";
-			results[index] = {
-				id: call.id,
-				content: isAbort ? cancelMessage() : `Error: ${errorMessage(err)}`,
-				isError: true
-			};
 		}).finally(() => {
 			inFlight.delete(index);
 		});
@@ -14115,7 +14160,7 @@ async function executeNativeToolBatch(ctx, toolCalls, turnId) {
 		await drain();
 		return results;
 	} finally {
-		if (parentAbortListener) ctx.signal.removeEventListener("abort", parentAbortListener);
+		harness.dispose();
 	}
 }
 //#endregion
@@ -15076,6 +15121,257 @@ function buildMcpToolNameSeparatorAliases(mcpToolNames, servers, separator) {
 	return Object.keys(aliases).length > 0 ? aliases : void 0;
 }
 /**
+* Partition the registry into eager vs lazy buckets and build the per-run
+* unlock bookkeeping the loop reads when rebuilding the wire-level tool list.
+*
+* Native (non-MCP) tools are always eager; `tool_search` itself must be eager
+* too (the discovery path can't gate on its own surfacing). The `unlocked` set
+* seeds with every eager canonical tool name and grows as the model surfaces
+* lazy tools through `tool_search`.
+*
+* Aliases are passed through so lazy entries carry their wire-level display
+* name — what the catalog and `tool_search` results show to the model — while
+* keeping the canonical name on the entry for unlock-set membership and
+* dispatch-map lookup.
+*/
+function buildRunDisclosureState(input) {
+	const { tools: baseTools, mcpToolNames, mcpServers, toolDisclosure, toolSearch, toolAliases, hasRunToolOverride } = input;
+	const disclosure = partitionToolDisclosure(baseTools, mcpToolNames, mcpServers, toolDisclosure, toolAliases);
+	const unlocked = new Set(disclosure.eagerCanonicalNames);
+	const initialUnlocked = new Set(disclosure.eagerCanonicalNames);
+	const dynamicUnlockOrder = [];
+	const dynamicUnlockSeen = /* @__PURE__ */ new Set();
+	const recordUnlock = (canonical) => {
+		if (initialUnlocked.has(canonical)) return;
+		if (dynamicUnlockSeen.has(canonical)) return;
+		dynamicUnlockSeen.add(canonical);
+		unlocked.add(canonical);
+		dynamicUnlockOrder.push(canonical);
+	};
+	const hostDefinedToolSearch = !!baseTools.tool_search;
+	const injectedToolSearch = !hasRunToolOverride && (toolDisclosure === "lazy" || disclosure.lazyEntries.length > 0) && toolSearch?.tool !== false && !hostDefinedToolSearch;
+	let tools = baseTools;
+	if (injectedToolSearch) {
+		const toolSearchTool = createToolSearchTool({
+			catalog: disclosure.lazyEntries,
+			unlocked,
+			addUnlock: recordUnlock,
+			...toolSearch?.limit !== void 0 ? { defaultLimit: toolSearch.limit } : {}
+		});
+		tools = {
+			...baseTools,
+			[toolSearchTool.spec.name]: toolSearchTool
+		};
+		unlocked.add(toolSearchTool.spec.name);
+		initialUnlocked.add(toolSearchTool.spec.name);
+	}
+	return {
+		disclosure,
+		unlocked,
+		initialUnlocked,
+		dynamicUnlockOrder,
+		recordUnlock,
+		tools,
+		injectedToolSearch,
+		hostDefinedToolSearch
+	};
+}
+/**
+* Choose the prior turns a run starts from, or `undefined` for a fresh start.
+*
+* Two resume flavors:
+*   - `resumeRunId` (child-run resume): seed ONLY the referenced prior run's
+*     lineage. Used by the spawn tool to continue a stopped/failed subagent —
+*     the parent's conversation (and every other child's) stays invisible,
+*     mirroring how a fresh child starts from just its task prompt. Allowed
+*     WITH `parentRunId` set (unlike a full-session resume).
+*   - full-session resume: the historical top-level path, on re-runs
+*     (`runs > 0`) or promptless runs (session turns already contain the user
+*     message). **Excluded for child agents**: when the spawn tool runs with
+*     `persist: true`, the child shares the parent's session for *storage* but
+*     its conversation must start fresh from the task prompt. Otherwise the
+*     child would pull in the parent's in-flight assistant turn — including the
+*     parent's pending `spawn` tool_use — and every provider (Anthropic loudly,
+*     OpenAI implicitly) rejects a history where a `tool_use` lacks its
+*     matching `tool_result`.
+*/
+function selectSeedTurns(input) {
+	const { session, options, resumeFilteredTurns } = input;
+	if (options.resumeRunId && session) {
+		const chain = resumeChainRunIds(session.runs, options.resumeRunId);
+		return filterUnresolvedToolUses(session.turns.filter((t) => t.runId !== void 0 && chain.has(t.runId)));
+	}
+	if (!(session && session.turns.length > 0 && (session.runs.length > 0 || !options.prompt) && !options.parentRunId && !options.resumeRunId)) return void 0;
+	const childRunIds = childRunIdSet(session);
+	const resumed = childRunIds.size === 0 ? session.turns : session.turns.filter((t) => !t.runId || !childRunIds.has(t.runId));
+	return resumeFilteredTurns && resumed === session.turns ? resumeFilteredTurns : filterUnresolvedToolUses(resumed);
+}
+/**
+* Replay every resolved `tool_search` from a resumed history into the per-run
+* `unlocked` set.
+*
+* Without this seeding a resumed conversation shows the model "These tools are
+* now callable" in the prior tool_result, but the next turn's `formattedTools`
+* and the `tool:gate` hook still treat the tools as locked — every subsequent
+* `tool_use` is rejected with "load via tool_search first", which the model
+* can't recover from without a fresh `tool_search` round-trip.
+*
+* Only replays calls whose result the model actually consumed: a `tool_call`
+* without a matching successful `tool_result` is either an unresolved pair
+* `filterUnresolvedToolUses` already stripped or a structural error — either
+* way, unlocking from it would be speculative.
+*/
+function replayToolSearchUnlocks(seededTurns, lazyEntries, unlocked, limit, recordUnlock) {
+	const resolvedCallIds = /* @__PURE__ */ new Set();
+	for (const turn of seededTurns) for (const block of turn.content) if (block.type === "tool_result" && !block.isError) resolvedCallIds.add(block.callId);
+	for (const turn of seededTurns) for (const block of turn.content) {
+		if (block.type !== "tool_call") continue;
+		if (block.name !== "tool_search") continue;
+		if (!resolvedCallIds.has(block.id)) continue;
+		applyToolSearchToUnlocked(lazyEntries, block.input, unlocked, limit, recordUnlock);
+	}
+}
+/**
+* Reconcile + drain pending background-task notifications.
+*
+* Each exit becomes a `<task-notification>` text block prepended to the user
+* turn so the model sees task completions on its very next prompt, without
+* polling. Two sources, merged by taskId:
+*
+*   1. PUSH — the agent-scoped queue populated by `background:exit` since the
+*      last `run()` (in-process contexts fire `onExit`).
+*   2. PULL — a `listBackground` sweep for terminated tasks the model hasn't
+*      been told about. This is what makes remote / durable contexts work:
+*      they have no legal way to push from a timer into the host (journal
+*      rules), so the loop polls at the run boundary instead.
+*      `endedAt - startedAt` reproduces `durationMs` without depending on
+*      sweep timing.
+*
+* The `background:reconcile` hook fires on the merged list INSIDE the run()
+* await chain — the journalable seam for durable hosts (see the hook's doc).
+* Entries suppressed earlier (`shell_kill`, `read_file`, `wait_task`) are
+* absent from both sources via the `notified` latch. See
+* `docs/RUN_IN_BACKGROUND.md` §Completion notification.
+*
+* Durable hosts wrap the live `listBackground` poll in `journalReconcile` so it
+* records as one journaled side effect (replay returns the recorded snapshot,
+* keeping `exits.length` — and therefore the conditional hook's journal
+* position — stable across attempts). Everything downstream of the snapshot is
+* pure over journaled / replayed inputs (session-turn acks, duration
+* derivation), so journaling the poll is enough to make the whole reconcile
+* deterministic.
+*/
+async function drainTaskNotifications(input) {
+	const { state, executionContext, executionHandle, behavior, journalReconcile, session, turns, hooks } = input;
+	const reconciled = new Map(state.pending);
+	state.pending.clear();
+	if (executionContext.listBackground && executionHandle && typeof behavior.tasksDir === "string" && behavior.tasksDir.length > 0) try {
+		const listBackground = executionContext.listBackground;
+		const handle = executionHandle;
+		const entries = journalReconcile ? await 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" || state.notified.has(entry.taskId) || reconciled.has(entry.taskId)) continue;
+			if (acks) {
+				if (acks.taskIds.has(entry.taskId)) continue;
+				const readAt = acks.outputPaths.get(resolve(entry.outputPath));
+				if (readAt !== void 0 && entry.endedAt !== void 0 && readAt >= entry.endedAt + READ_ACK_CLOCK_SKEW_MARGIN_MS) continue;
+			}
+			reconciled.set(entry.taskId, {
+				taskId: entry.taskId,
+				status: entry.status,
+				exitCode: entry.exitCode ?? 0,
+				...entry.signal ? { signal: entry.signal } : {},
+				outputPath: entry.outputPath,
+				durationMs: Math.max(0, (entry.endedAt ?? entry.startedAt) - entry.startedAt),
+				command: entry.command
+			});
+		}
+	} catch (err) {
+		if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/agent] background reconcile failed: ${err instanceof Error ? err.message : String(err)}\n`);
+	}
+	const reconcileCtx = { exits: [...reconciled.values()] };
+	if (reconcileCtx.exits.length > 0) await hooks.callHook("background:reconcile", reconcileCtx);
+	for (const taskId of reconciled.keys()) {
+		state.notified.add(taskId);
+		state.pendingStalls.delete(taskId);
+	}
+	const drained = [];
+	for (const notif of reconcileCtx.exits) drained.push({
+		type: "text",
+		text: renderTaskNotificationXml(notif)
+	});
+	if (state.pendingStalls.size > 0) {
+		for (const stall of state.pendingStalls.values()) drained.push({
+			type: "text",
+			text: renderTaskStallXml(stall)
+		});
+		state.pendingStalls.clear();
+	}
+	return drained;
+}
+/**
+* Assemble the tool registry a single run advertises.
+*
+* Pipeline: resolve the base set (run override > agent + MCP) → derive the
+* wire-name aliases → inject the skills tools → apply extension catalog
+* transforms → index by spec name → rewrite the built-in `shell` for this
+* run's capabilities.
+*/
+function buildRunToolRegistry(input) {
+	const { runOverrideTools, sourceTools, mcpConnection, mcpServers, mcpToolNameSeparator, toolAliases, resolvedSkills, skillsConfig, skillActivationState, hooks, toolCatalogTransforms, executionContext, behavior } = input;
+	const runBaseTools = runOverrideTools !== void 0 ? runOverrideTools : mcpConnection ? {
+		...sourceTools,
+		...mcpConnection.tools
+	} : sourceTools;
+	const mcpToolNames = runOverrideTools === void 0 && mcpConnection ? new Set(Object.keys(mcpConnection.tools)) : /* @__PURE__ */ new Set();
+	const generatedMcpToolAliases = buildMcpToolNameSeparatorAliases(mcpToolNames, mcpServers, mcpToolNameSeparator);
+	const baseToolAliases = generatedMcpToolAliases ? {
+		...generatedMcpToolAliases,
+		...toolAliases ?? {}
+	} : toolAliases;
+	const sanitizedWireAliases = buildSanitizedWireAliases(mcpToolNames, baseToolAliases);
+	const effectiveToolAliases = sanitizedWireAliases ? {
+		...baseToolAliases ?? {},
+		...sanitizedWireAliases
+	} : baseToolAliases;
+	const transformedToolCatalog = applyToolCatalogTransforms(runOverrideTools === void 0 && !!resolvedSkills && resolvedSkills.length > 0 && skillsConfig?.tool !== false ? {
+		skills_use: createSkillsUseTool({
+			catalog: resolvedSkills,
+			state: skillActivationState,
+			hooks,
+			allowShellInterpolation: skillsConfig?.allowShellInterpolation,
+			approveShellInterpolation: skillsConfig?.approveShellInterpolation
+		}),
+		skills_read: createSkillsReadTool({
+			catalog: resolvedSkills,
+			state: skillActivationState
+		}),
+		skills_run_script: createSkillsRunScriptTool({
+			catalog: resolvedSkills,
+			state: skillActivationState,
+			scriptTimeoutMs: skillsConfig?.scriptTimeoutMs
+		}),
+		...runBaseTools
+	} : runBaseTools, toolCatalogTransforms, "run", mcpToolNames);
+	const tools = {};
+	for (const tool of Object.values(transformedToolCatalog)) tools[tool.spec.name] = tool;
+	if (tools.shell === shell) {
+		const detachedTasks = resolveDetachedTasksCapability(executionContext);
+		const bgDisabled = behavior.disableBackgroundTasks === true || behavior.disableBackgroundTasks === "non-durable" && detachedTasks !== "durable";
+		tools.shell = createShellTool({
+			allowBackground: typeof behavior.tasksDir === "string" && behavior.tasksDir.length > 0 && !bgDisabled && detachedTasks !== "none",
+			registeredCanonicals: new Set(Object.keys(tools)),
+			...effectiveToolAliases ? { toolAliases: effectiveToolAliases } : {}
+		});
+	}
+	return {
+		tools,
+		mcpToolNames,
+		toolAliases: effectiveToolAliases
+	};
+}
+/**
 * Partition a tool registry into eager and lazy buckets.
 *
 * Native + skill tools always end up in the eager bucket — only MCP tools
@@ -15656,6 +15952,7 @@ function createAgent(rawOptions) {
 		const externalSignal = options.signal;
 		running = true;
 		toolCancels.clearPending();
+		const perRunUnregisters = [];
 		try {
 			abortController = new AbortController();
 			idlePromise = new Promise((resolve) => {
@@ -15702,10 +15999,9 @@ function createAgent(rawOptions) {
 				externalSignal.addEventListener("abort", externalAbortListener, { once: true });
 			}
 			const childrenStats = [];
-			const unregisterSpawnHook = hooks.hook("spawn:complete", (ctx) => {
+			perRunUnregisters.push(hooks.hook("spawn:complete", (ctx) => {
 				childrenStats.push(ctx);
-			});
-			const perRunUnregisters = [];
+			}));
 			if (options.hooks) for (const [event, handler] of Object.entries(options.hooks)) {
 				if (!isKnownHookEvent(event)) throw new Error(`Unknown hook event "${event}" passed to run(). See AgentHooks for valid events.`);
 				const handlerList = Array.isArray(handler) ? handler : [handler];
@@ -15741,86 +16037,37 @@ function createAgent(rawOptions) {
 			}
 			const thinking = options.thinking ?? "off";
 			const model = targets[0].model;
-			if (runProvider.meta?.clearsContextServerSide) resolvedBehavior.dedupReads = false;
-			const { maxConcurrentTools, toolBatchExecutor, toolBatchTimeoutMs, shouldRethrowToolError, maxTurns, maxTurnsWarning, maxTurnsWarningMessage, maxCostUsd, maxTotalTokens, maxWallMs, providerStreamStartTimeoutMs, providerStreamTimeoutMs, providerStreamIdleTimeoutMs, maxTokens, modelCatalog, retry, thinkingBudget, taskBudget, effortHint, thinkingOverrunPolicy, modelOptions: behaviorModelOptions, schema, cache, cacheTtl, toolOutputBudget, toolOutputBudgetExcludeTools, compactStrategy, compactThreshold, compactKeepTurns, thinkingDecay, writeFileExistingPolicy, textToolCallRescue, unknownToolRecovery, progressNudges, dedupTools, toolBudgets, repeatGuard, elideStaleReads, mediaKeepTurns, autoCompact, toolDisclosure, mcpToolNameSeparator, toolSearch, surfaceMcpInstructions, persistThreshold, persistExcludeTools, persistDir, persistMaxBytes, strictToolPairing, maxPairingRepairsPerTurn, maxConsecutivePauseTurns, maxConsecutiveRefusalResumes, resumeOnMaxTokens, maxConsecutiveLengthResumes, persistTurns } = resolvedBehavior;
+			if (runProvider.meta.clearsContextServerSide) resolvedBehavior.dedupReads = false;
+			Object.freeze(resolvedBehavior);
+			const { thinkingOverrunPolicy, thinkingBudget, modelOptions: behaviorModelOptions, compactKeepTurns, writeFileExistingPolicy, textToolCallRescue, unknownToolRecovery, progressNudges, dedupTools, toolBudgets, repeatGuard, autoCompact, toolDisclosure, mcpToolNameSeparator, toolSearch, surfaceMcpInstructions, persistTurns } = resolvedBehavior;
 			const modelOptions = options.modelOptions ?? behaviorModelOptions;
 			let system = options.system || agentSystem || "You are a helpful assistant.";
 			const baseSystemForBreakdown = renderSystemForWire(system);
 			if (skillsCatalog) system = appendStaticSection(system, skillsCatalog);
-			const runBaseTools = options.tools !== void 0 ? options.tools : mcpConnection ? {
-				...sourceTools,
-				...mcpConnection.tools
-			} : sourceTools;
-			const mcpToolNames = options.tools === void 0 && mcpConnection ? new Set(Object.keys(mcpConnection.tools)) : /* @__PURE__ */ new Set();
-			const generatedMcpToolAliases = buildMcpToolNameSeparatorAliases(mcpToolNames, mcpServers, mcpToolNameSeparator);
-			const baseToolAliases = generatedMcpToolAliases ? {
-				...generatedMcpToolAliases,
-				...toolAliases ?? {}
-			} : toolAliases;
-			const sanitizedWireAliases = buildSanitizedWireAliases(mcpToolNames, baseToolAliases);
-			const effectiveToolAliases = sanitizedWireAliases ? {
-				...baseToolAliases ?? {},
-				...sanitizedWireAliases
-			} : baseToolAliases;
-			const transformedToolCatalog = applyToolCatalogTransforms(options.tools === void 0 && !!resolvedSkills && resolvedSkills.length > 0 && skillsConfig?.tool !== false ? {
-				skills_use: createSkillsUseTool({
-					catalog: resolvedSkills,
-					state: skillActivationState,
-					hooks,
-					allowShellInterpolation: skillsConfig?.allowShellInterpolation,
-					approveShellInterpolation: skillsConfig?.approveShellInterpolation
-				}),
-				skills_read: createSkillsReadTool({
-					catalog: resolvedSkills,
-					state: skillActivationState
-				}),
-				skills_run_script: createSkillsRunScriptTool({
-					catalog: resolvedSkills,
-					state: skillActivationState,
-					scriptTimeoutMs: skillsConfig?.scriptTimeoutMs
-				}),
-				...runBaseTools
-			} : runBaseTools, toolCatalogTransforms, "run", mcpToolNames);
-			const toolsPreSearch = {};
-			for (const tool of Object.values(transformedToolCatalog)) toolsPreSearch[tool.spec.name] = tool;
-			if (toolsPreSearch.shell === shell) {
-				const detachedTasks = resolveDetachedTasksCapability(executionContext);
-				const bgDisabled = resolvedBehavior?.disableBackgroundTasks === true || resolvedBehavior?.disableBackgroundTasks === "non-durable" && detachedTasks !== "durable";
-				toolsPreSearch.shell = createShellTool({
-					allowBackground: typeof resolvedBehavior?.tasksDir === "string" && resolvedBehavior.tasksDir.length > 0 && !bgDisabled && detachedTasks !== "none",
-					registeredCanonicals: new Set(Object.keys(toolsPreSearch)),
-					...effectiveToolAliases ? { toolAliases: effectiveToolAliases } : {}
-				});
-			}
-			const disclosure = partitionToolDisclosure(toolsPreSearch, mcpToolNames, mcpServers, toolDisclosure, effectiveToolAliases);
-			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 = options.tools === void 0 && (toolDisclosure === "lazy" || disclosure.lazyEntries.length > 0) && toolSearch?.tool !== false && !hostDefinedToolSearch;
-			let tools = toolsPreSearch;
-			if (shouldInjectToolSearch) {
-				const toolSearchTool = createToolSearchTool({
-					catalog: disclosure.lazyEntries,
-					unlocked,
-					addUnlock: recordDynamicUnlock,
-					...toolSearch?.limit !== void 0 ? { defaultLimit: toolSearch.limit } : {}
-				});
-				tools = {
-					...toolsPreSearch,
-					[toolSearchTool.spec.name]: toolSearchTool
-				};
-				unlocked.add(toolSearchTool.spec.name);
-				initialUnlocked.add(toolSearchTool.spec.name);
-			}
+			const { tools: toolsPreSearch, mcpToolNames, toolAliases: effectiveToolAliases } = buildRunToolRegistry({
+				runOverrideTools: options.tools,
+				sourceTools,
+				mcpConnection,
+				mcpServers,
+				mcpToolNameSeparator,
+				toolAliases,
+				resolvedSkills,
+				skillsConfig,
+				skillActivationState,
+				hooks,
+				toolCatalogTransforms,
+				executionContext,
+				behavior: resolvedBehavior
+			});
+			const { disclosure, unlocked, initialUnlocked, dynamicUnlockOrder, recordUnlock: recordDynamicUnlock, tools, injectedToolSearch: shouldInjectToolSearch, hostDefinedToolSearch } = buildRunDisclosureState({
+				tools: toolsPreSearch,
+				mcpToolNames,
+				mcpServers,
+				toolDisclosure,
+				toolSearch,
+				toolAliases: effectiveToolAliases,
+				hasRunToolOverride: options.tools !== void 0
+			});
 			const discoveryToolName = shouldInjectToolSearch ? "tool_search" : hostDefinedToolSearch ? effectiveToolAliases?.tool_search ?? "tool_search" : null;
 			let searchableCatalogText;
 			if (disclosure.lazyEntries.length > 0) {
@@ -15905,76 +16152,31 @@ function createAgent(rawOptions) {
 				});
 			}
 			const turns = [];
-			const isResume = session && session.turns.length > 0 && (session.runs.length > 0 || !options.prompt) && !options.parentRunId && !options.resumeRunId;
-			let seededTurns;
-			if (options.resumeRunId && session) {
-				const chain = resumeChainRunIds(session.runs, options.resumeRunId);
-				seededTurns = filterUnresolvedToolUses(session.turns.filter((t) => t.runId !== void 0 && chain.has(t.runId)));
-			} else if (isResume) {
-				const childRunIds = childRunIdSet(session);
-				const resumed = childRunIds.size === 0 ? session.turns : session.turns.filter((t) => !t.runId || !childRunIds.has(t.runId));
-				seededTurns = resumeFilteredTurns && resumed === session.turns ? resumeFilteredTurns : filterUnresolvedToolUses(resumed);
-			}
+			const seededTurns = selectSeedTurns({
+				session,
+				options,
+				resumeFilteredTurns
+			});
 			if (seededTurns) {
 				turns.push(...seededTurns);
-				if (shouldInjectToolSearch && disclosure.lazyEntries.length > 0) {
-					const resolvedCallIds = /* @__PURE__ */ new Set();
-					for (const turn of seededTurns) for (const block of turn.content) if (block.type === "tool_result" && !block.isError) resolvedCallIds.add(block.callId);
-					for (const turn of seededTurns) for (const block of turn.content) {
-						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, recordDynamicUnlock);
-					}
-				}
+				if (shouldInjectToolSearch && disclosure.lazyEntries.length > 0) replayToolSearchUnlocks(seededTurns, disclosure.lazyEntries, unlocked, toolSearch?.limit, recordDynamicUnlock);
 			}
 			const runTurnStart = turns.length;
 			if (options.system) await hooks.callHook("system:before", { system: options.system });
-			const reconciled = new Map(pendingTaskNotifications);
-			pendingTaskNotifications.clear();
-			if (executionContext.listBackground && executionHandle && typeof resolvedBehavior?.tasksDir === "string" && resolvedBehavior.tasksDir.length > 0) try {
-				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;
-					if (acks) {
-						if (acks.taskIds.has(entry.taskId)) continue;
-						const readAt = acks.outputPaths.get(resolve(entry.outputPath));
-						if (readAt !== void 0 && entry.endedAt !== void 0 && readAt >= entry.endedAt + READ_ACK_CLOCK_SKEW_MARGIN_MS) continue;
-					}
-					reconciled.set(entry.taskId, {
-						taskId: entry.taskId,
-						status: entry.status,
-						exitCode: entry.exitCode ?? 0,
-						...entry.signal ? { signal: entry.signal } : {},
-						outputPath: entry.outputPath,
-						durationMs: Math.max(0, (entry.endedAt ?? entry.startedAt) - entry.startedAt),
-						command: entry.command
-					});
-				}
-			} catch (err) {
-				if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/agent] background reconcile failed: ${err instanceof Error ? err.message : String(err)}\n`);
-			}
-			const reconcileCtx = { exits: [...reconciled.values()] };
-			if (reconcileCtx.exits.length > 0) await hooks.callHook("background:reconcile", reconcileCtx);
-			for (const taskId of reconciled.keys()) {
-				notifiedTaskIds.add(taskId);
-				pendingStallNotifications.delete(taskId);
-			}
-			const drainedNotifications = [];
-			for (const notif of reconcileCtx.exits) drainedNotifications.push({
-				type: "text",
-				text: renderTaskNotificationXml(notif)
+			const drainedNotifications = await drainTaskNotifications({
+				state: {
+					pending: pendingTaskNotifications,
+					pendingStalls: pendingStallNotifications,
+					notified: notifiedTaskIds
+				},
+				executionContext,
+				executionHandle,
+				behavior: resolvedBehavior,
+				journalReconcile: options.journalReconcile,
+				session,
+				turns,
+				hooks
 			});
-			if (pendingStallNotifications.size > 0) {
-				for (const stall of pendingStallNotifications.values()) drainedNotifications.push({
-					type: "text",
-					text: renderTaskStallXml(stall)
-				});
-				pendingStallNotifications.clear();
-			}
 			let lastPersistedTurnCount = turns.length;
 			const promptParts = canonicalizePrompt(options.prompt);
 			if (promptParts || drainedNotifications.length > 0) {
@@ -16021,8 +16223,10 @@ function createAgent(rawOptions) {
 				});
 			}
 			const perTurnSync = session && persistTurns !== false;
-			const unregisterTurnSync = perTurnSync ? hooks.hook("turn:after", persistPendingTurns) : void 0;
-			const unregisterToolResultsSync = perTurnSync ? hooks.hook("tool-results:after", persistPendingTurns) : void 0;
+			if (perTurnSync) {
+				perRunUnregisters.push(hooks.hook("turn:after", persistPendingTurns));
+				perRunUnregisters.push(hooks.hook("tool-results:after", persistPendingTurns));
+			}
 			async function flushTurns(opts = {}) {
 				if (!session) return;
 				if (opts.failureFallback) {
@@ -16067,7 +16271,7 @@ function createAgent(rawOptions) {
 				const run = session?.runs.find((r) => r.id === runId);
 				if (run) run.endedAt = await clock.now();
 			}
-			const uninstallAllowedToolsGate = installAllowedToolsGate(hooks, skillActivationState);
+			perRunUnregisters.push(installAllowedToolsGate(hooks, skillActivationState));
 			const getExecutionHandle = () => executionHandle ?? void 0;
 			perRunUnregisters.push(installWriteFileExistingPolicy(hooks, writeFileExistingPolicy, {
 				execution: executionContext,
@@ -16078,10 +16282,10 @@ function createAgent(rawOptions) {
 				advertisedToolNames,
 				enqueueNudge: (message) => nonInterruptingNudgeQueue.push(message)
 			}));
-			const uninstallToolBudgets = installToolBudgetsGate(hooks, () => toolBudgets, (msg) => nonInterruptingNudgeQueue.push(msg));
-			const uninstallRepeatGuard = installRepeatGuard(hooks, () => repeatGuard, () => abortController?.abort());
-			const uninstallDedupTools = installDedupToolsGate(hooks, () => dedupTools, () => session ?? void 0);
-			const uninstallLazyDisclosureHydration = installLazyDisclosureHydrationGate(hooks, {
+			perRunUnregisters.push(installToolBudgetsGate(hooks, () => toolBudgets, (msg) => nonInterruptingNudgeQueue.push(msg)));
+			perRunUnregisters.push(installRepeatGuard(hooks, () => repeatGuard, () => abortController?.abort()));
+			perRunUnregisters.push(installDedupToolsGate(hooks, () => dedupTools, () => session ?? void 0));
+			perRunUnregisters.push(installLazyDisclosureHydrationGate(hooks, {
 				enabled: shouldInjectToolSearch && disclosure.lazyEntries.length > 0,
 				session: session ?? void 0,
 				lazyCanonicalNames: disclosure.lazyCanonicalNames,
@@ -16089,20 +16293,20 @@ function createAgent(rawOptions) {
 				unlocked,
 				recordUnlock: recordDynamicUnlock,
 				defaultLimit: toolSearch?.limit
-			});
-			const uninstallLazyDisclosureGate = installLazyDisclosureGate(hooks, disclosure.lazyCanonicalNames, unlocked, discoveryToolName);
-			const uninstallReadBeforeEditHydration = installReadBeforeEditHydrationGate(hooks, resolvedBehavior.requireReadBeforeEdit === true, {
+			}));
+			perRunUnregisters.push(installLazyDisclosureGate(hooks, disclosure.lazyCanonicalNames, unlocked, discoveryToolName));
+			perRunUnregisters.push(installReadBeforeEditHydrationGate(hooks, resolvedBehavior.requireReadBeforeEdit === true, {
 				session: session ?? void 0,
 				getHandle: () => executionHandle,
 				execution: executionContext,
 				aliasMaps,
 				defaultLineNumbers: resolvedBehavior.readLineNumbers ?? true
-			});
-			const uninstallSkillsActivationHydration = installSkillsActivationHydrationGate(hooks, {
+			}));
+			perRunUnregisters.push(installSkillsActivationHydrationGate(hooks, {
 				session: session ?? void 0,
 				getResolvedSkills: () => resolvedSkills,
 				state: skillActivationState
-			});
+			}));
 			perRunUnregisters.push(installThinkingOverrunPolicy(hooks, thinkingOverrunPolicy, {
 				baseBudget: thinkingBudget,
 				enqueueNudge: (message) => nonInterruptingNudgeQueue.push(message)
@@ -16121,25 +16325,100 @@ function createAgent(rawOptions) {
 				turnUsage: []
 			};
 			const wallStartMs = Date.now();
-			const providerContextWindow = typeof runProvider.meta.contextWindow === "number" ? runProvider.meta.contextWindow : void 0;
+			const providerContextWindow = runProvider.meta.contextWindow;
 			const resolvedAutoCompact = resolveAutoCompact(autoCompact, {
 				...providerContextWindow !== void 0 ? { fallbackContextWindow: providerContextWindow } : {},
 				...compactKeepTurns !== void 0 ? { compactKeepTurns } : {}
 			});
+			/**
+			* Loop-view stats synthesized from the live usage mirror.
+			*
+			* Used by every exit that did NOT get a clean `AgentStats` back from
+			* `runLoop` (mid-stream abort, budget breach, hard failure): the mirror
+			* carries the usage of every turn that completed before the throw, so the
+			* persisted record and `agent:done` report real spend instead of zeros.
+			* Wall time comes from `wallStartMs` (a real clock) rather than the
+			* possibly-journaled `runStartedAt`, matching `runLoop`'s own accounting.
+			*/
+			function mirroredLoopStats() {
+				return {
+					totalIn: usageMirror.totalIn,
+					totalOut: usageMirror.totalOut,
+					totalCacheRead: usageMirror.totalCacheRead,
+					totalCacheCreation: usageMirror.totalCacheCreation,
+					turns: usageMirror.turns,
+					elapsed: Date.now() - wallStartMs,
+					turnUsage: usageMirror.turnUsage,
+					...usageMirror.cost > 0 ? { cost: usageMirror.cost } : {}
+				};
+			}
+			/**
+			* The single exit path for a run. Every terminal branch — completed,
+			* clean-break abort, mid-stream abort, budget breach, hard error — routes
+			* through here so all five report identically: children folded into the
+			* returned totals, session ledger written from the loop-only view, run row
+			* stamped, `session:end` fired, then `agent:done` with the final stats.
+			*
+			* Callers that must propagate an error still `throw` after awaiting this;
+			* the finalization itself is outcome-independent.
+			*/
+			async function finishRun(disposition) {
+				const { kind, loopStats, parentCost } = disposition;
+				let childrenIn = 0;
+				let childrenOut = 0;
+				let childrenCost = 0;
+				let childrenCacheRead = 0;
+				let childrenCacheCreation = 0;
+				for (const c of childrenStats) {
+					childrenIn += c.stats.totalIn;
+					childrenOut += c.stats.totalOut;
+					childrenCost += c.stats.cost ?? 0;
+					childrenCacheRead += c.stats.totalCacheRead;
+					childrenCacheCreation += c.stats.totalCacheCreation;
+				}
+				const cumulativeCost = parentCost + childrenCost;
+				const finalStats = {
+					...loopStats,
+					totalIn: loopStats.totalIn + childrenIn,
+					totalOut: loopStats.totalOut + childrenOut,
+					totalCacheRead: loopStats.totalCacheRead + childrenCacheRead,
+					totalCacheCreation: loopStats.totalCacheCreation + childrenCacheCreation,
+					...cumulativeCost > 0 ? { cost: cumulativeCost } : {},
+					children: childrenStats.length > 0 ? childrenStats : void 0
+				};
+				if (session) {
+					const ledger = {
+						turns: loopStats.turns,
+						tokensIn: loopStats.totalIn,
+						tokensOut: loopStats.totalOut,
+						turnUsage: loopStats.turnUsage,
+						...parentCost > 0 ? { cost: parentCost } : {}
+					};
+					if (disposition.kind === "completed") session.completeRun(runId, ledger);
+					else if (disposition.kind === "aborted") session.abortRun(runId, ledger);
+					else session.errorRun(runId, disposition.failure, ledger);
+				}
+				await stampSessionRunEnd();
+				await finalizeSession(kind);
+				await settleWithinTimeout("hook agent:done", hooks.callHook("agent:done", finalStats), hookTimeoutMs);
+				return finalStats;
+			}
 			try {
 				await toolStateController.hydrate();
 				const stats = await runLoop({
 					provider: runProvider,
 					targets,
 					hooks,
-					agentName,
-					agentSystem,
-					agentTools: sourceTools,
-					agentToolAliases: effectiveToolAliases,
-					agentMcpServers: allMcpServers.length > 0 ? allMcpServers : void 0,
-					agentMcpConnection: () => mcpConnection,
-					agentSkills,
-					agentBehavior: resolvedBehavior,
+					behavior: resolvedBehavior,
+					inheritance: {
+						...agentName !== void 0 ? { name: agentName } : {},
+						...agentSystem !== void 0 ? { system: agentSystem } : {},
+						tools: sourceTools,
+						...effectiveToolAliases !== void 0 ? { toolAliases: effectiveToolAliases } : {},
+						...allMcpServers.length > 0 ? { mcpServers: allMcpServers } : {},
+						mcpConnection: () => mcpConnection,
+						...agentSkills !== void 0 ? { skills: agentSkills } : {}
+					},
 					tools,
 					formattedTools,
 					rebuildFormattedTools: buildFormattedTools,
@@ -16147,10 +16426,6 @@ function createAgent(rawOptions) {
 					model,
 					system,
 					thinking,
-					...maxConcurrentTools !== void 0 ? { maxConcurrentTools } : {},
-					...toolBatchExecutor !== void 0 ? { toolBatchExecutor } : {},
-					...toolBatchTimeoutMs !== void 0 ? { toolBatchTimeoutMs } : {},
-					...shouldRethrowToolError !== void 0 ? { shouldRethrowToolError } : {},
 					signal: abortController.signal,
 					execution: executionContext,
 					handle: executionHandle,
@@ -16161,53 +16436,16 @@ function createAgent(rawOptions) {
 					runId,
 					generateTurnId: mintTurnId,
 					clock,
-					maxTurns,
-					...maxTurnsWarning !== void 0 ? { maxTurnsWarning } : {},
-					...maxTurnsWarningMessage !== void 0 ? { maxTurnsWarningMessage } : {},
-					...maxCostUsd !== void 0 ? { maxCostUsd } : {},
-					...maxTotalTokens !== void 0 ? { maxTotalTokens } : {},
-					...maxWallMs !== void 0 ? { maxWallMs } : {},
-					...providerStreamStartTimeoutMs !== void 0 ? { providerStreamStartTimeoutMs } : {},
-					...providerStreamTimeoutMs !== void 0 ? { providerStreamTimeoutMs } : {},
-					...providerStreamIdleTimeoutMs !== void 0 ? { providerStreamIdleTimeoutMs } : {},
-					...resolvedBehavior.hookTimeoutMs !== void 0 ? { hookTimeoutMs: resolvedBehavior.hookTimeoutMs } : {},
-					...retry !== void 0 ? { retry } : {},
-					maxTokens,
-					...modelCatalog !== void 0 ? { modelCatalog } : {},
+					...modelOptions ? { modelOptions } : {},
+					...resolvedAutoCompact ? { autoCompact: resolvedAutoCompact } : {},
 					...session ? { session } : {},
 					...agentReadState ? { readState: agentReadState } : {},
 					toolState: toolStateController,
 					...options.parentRunId ? { parentRunId: options.parentRunId } : {},
 					...options.parentCallId ? { parentCallId: options.parentCallId } : {},
 					depth: runDepth,
-					thinkingBudget,
-					...taskBudget !== void 0 ? { taskBudget } : {},
-					...effortHint !== void 0 ? { effortHint } : {},
-					...modelOptions ? { modelOptions } : {},
-					schema,
-					cache,
-					...cacheTtl !== void 0 ? { cacheTtl } : {},
-					toolOutputBudget,
-					...toolOutputBudgetExcludeTools !== void 0 ? { toolOutputBudgetExcludeTools } : {},
-					compactStrategy,
-					compactThreshold,
-					compactKeepTurns,
-					...elideStaleReads !== void 0 ? { elideStaleReads } : {},
-					...mediaKeepTurns !== void 0 ? { mediaKeepTurns } : {},
-					...resolvedAutoCompact ? { autoCompact: resolvedAutoCompact } : {},
 					...perTurnSync ? { persistTurns: persistPendingTurns } : {},
 					getActiveSkills: () => skillActivationState.active(),
-					...thinkingDecay !== void 0 ? { thinkingDecay } : {},
-					...persistThreshold !== void 0 ? { persistThreshold } : {},
-					...persistExcludeTools !== void 0 ? { persistExcludeTools } : {},
-					...persistDir !== void 0 ? { persistDir } : {},
-					...persistMaxBytes !== void 0 ? { persistMaxBytes } : {},
-					...strictToolPairing ? { strictToolPairing: true } : {},
-					...maxPairingRepairsPerTurn !== void 0 ? { maxPairingRepairsPerTurn } : {},
-					...maxConsecutivePauseTurns !== void 0 ? { maxConsecutivePauseTurns } : {},
-					...maxConsecutiveRefusalResumes !== void 0 ? { maxConsecutiveRefusalResumes } : {},
-					...resumeOnMaxTokens !== void 0 ? { resumeOnMaxTokens } : {},
-					...maxConsecutiveLengthResumes !== void 0 ? { maxConsecutiveLengthResumes } : {},
 					providerName: runProvider.name,
 					runStartMs,
 					runToolCounts: {},
@@ -16215,53 +16453,12 @@ function createAgent(rawOptions) {
 					usageMirror
 				});
 				const parentTurnCost = stats.turnUsage?.reduce((sum, t) => sum + (t.cost ?? 0), 0) ?? 0;
-				let childrenIn = 0;
-				let childrenOut = 0;
-				let childrenCost = 0;
-				let childrenCacheRead = 0;
-				let childrenCacheCreation = 0;
-				for (const c of childrenStats) {
-					childrenIn += c.stats.totalIn;
-					childrenOut += c.stats.totalOut;
-					childrenCost += c.stats.cost ?? 0;
-					childrenCacheRead += c.stats.totalCacheRead;
-					childrenCacheCreation += c.stats.totalCacheCreation;
-				}
-				const cumulativeCost = parentTurnCost + childrenCost;
-				const finalStats = {
-					...stats,
-					totalIn: stats.totalIn + childrenIn,
-					totalOut: stats.totalOut + childrenOut,
-					totalCacheRead: stats.totalCacheRead + childrenCacheRead,
-					totalCacheCreation: stats.totalCacheCreation + childrenCacheCreation,
-					...cumulativeCost > 0 ? { cost: cumulativeCost } : {},
-					children: childrenStats.length > 0 ? childrenStats : void 0
-				};
 				await flushTurns();
-				if (abortController.signal.aborted) {
-					session?.abortRun(runId, {
-						turns: stats.turns,
-						tokensIn: stats.totalIn,
-						tokensOut: stats.totalOut,
-						turnUsage: stats.turnUsage,
-						cost: parentTurnCost > 0 ? parentTurnCost : void 0
-					});
-					await stampSessionRunEnd();
-					await finalizeSession("aborted");
-					await settleWithinTimeout("hook agent:done", hooks.callHook("agent:done", finalStats), hookTimeoutMs);
-					return finalStats;
-				}
-				session?.completeRun(runId, {
-					turns: stats.turns,
-					tokensIn: stats.totalIn,
-					tokensOut: stats.totalOut,
-					turnUsage: stats.turnUsage,
-					cost: parentTurnCost > 0 ? parentTurnCost : void 0
+				return await finishRun({
+					kind: abortController.signal.aborted ? "aborted" : "completed",
+					loopStats: stats,
+					parentCost: parentTurnCost
 				});
-				await stampSessionRunEnd();
-				await finalizeSession("completed");
-				await settleWithinTimeout("hook agent:done", hooks.callHook("agent:done", finalStats), hookTimeoutMs);
-				return finalStats;
 			} catch (err) {
 				await flushTurns({ failureFallback: true });
 				if (abortController.signal.aborted) {
@@ -16270,84 +16467,39 @@ function createAgent(rawOptions) {
 						...runId ? { runId } : {},
 						...typeof abortReason === "string" && abortReason.length > 0 ? { reason: abortReason } : {}
 					});
-					session?.abortRun(runId, {
-						turns: usageMirror.turns,
-						tokensIn: usageMirror.totalIn,
-						tokensOut: usageMirror.totalOut,
-						turnUsage: usageMirror.turnUsage,
-						cost: usageMirror.cost > 0 ? usageMirror.cost : void 0
+					return await finishRun({
+						kind: "aborted",
+						loopStats: mirroredLoopStats(),
+						parentCost: usageMirror.cost
 					});
-					await stampSessionRunEnd();
-					await finalizeSession("aborted");
-					const stats = {
-						totalIn: usageMirror.totalIn,
-						totalOut: usageMirror.totalOut,
-						totalCacheRead: usageMirror.totalCacheRead,
-						totalCacheCreation: usageMirror.totalCacheCreation,
-						turns: usageMirror.turns,
-						elapsed: Date.now() - wallStartMs,
-						turnUsage: usageMirror.turnUsage,
-						...usageMirror.cost > 0 ? { cost: usageMirror.cost } : {}
-					};
-					await settleWithinTimeout("hook agent:done", hooks.callHook("agent:done", stats), hookTimeoutMs);
-					return stats;
 				}
 				if (err instanceof AgentBudgetExceededError) {
-					session?.abortRun(runId, {
-						turns: usageMirror.turns,
-						tokensIn: usageMirror.totalIn,
-						tokensOut: usageMirror.totalOut,
-						turnUsage: usageMirror.turnUsage,
-						cost: usageMirror.cost > 0 ? usageMirror.cost : void 0
+					await finishRun({
+						kind: "aborted",
+						loopStats: mirroredLoopStats(),
+						parentCost: usageMirror.cost
 					});
-					await stampSessionRunEnd();
-					await finalizeSession("aborted");
-					await settleWithinTimeout("hook agent:done", hooks.callHook("agent:done", {
-						totalIn: usageMirror.totalIn,
-						totalOut: usageMirror.totalOut,
-						totalCacheRead: usageMirror.totalCacheRead,
-						totalCacheCreation: usageMirror.totalCacheCreation,
-						turns: usageMirror.turns,
-						elapsed: Date.now() - wallStartMs,
-						turnUsage: usageMirror.turnUsage,
-						...usageMirror.cost > 0 ? { cost: usageMirror.cost } : {}
-					}), hookTimeoutMs);
 					throw err;
 				}
-				session?.errorRun(runId, errorMessage(err));
-				await stampSessionRunEnd();
-				await finalizeSession("error");
-				await settleWithinTimeout("hook agent:done", hooks.callHook("agent:done", {
-					totalIn: usageMirror.totalIn,
-					totalOut: usageMirror.totalOut,
-					totalCacheRead: usageMirror.totalCacheRead,
-					totalCacheCreation: usageMirror.totalCacheCreation,
-					turns: usageMirror.turns,
-					elapsed: Date.now() - wallStartMs,
-					turnUsage: usageMirror.turnUsage,
-					...usageMirror.cost > 0 ? { cost: usageMirror.cost } : {}
-				}), hookTimeoutMs);
+				await finishRun({
+					kind: "error",
+					loopStats: mirroredLoopStats(),
+					parentCost: usageMirror.cost,
+					failure: errorMessage(err)
+				});
 				throw err;
 			} finally {
 				await deactivateAllSkills();
-				uninstallAllowedToolsGate();
-				uninstallDedupTools();
-				uninstallRepeatGuard();
-				uninstallToolBudgets();
-				uninstallLazyDisclosureHydration();
-				uninstallLazyDisclosureGate();
-				uninstallReadBeforeEditHydration();
-				uninstallSkillsActivationHydration();
-				unregisterSpawnHook();
-				unregisterTurnSync?.();
-				unregisterToolResultsSync?.();
 				for (const unregister of perRunUnregisters) unregister();
+				perRunUnregisters.length = 0;
 				steeringQueue.length = 0;
 				nonInterruptingNudgeQueue.length = 0;
 				followUpQueue.length = 0;
 				resetRunScope();
 			}
 		} finally {
+			for (const unregister of perRunUnregisters) unregister();
+			perRunUnregisters.length = 0;
 			resetRunScope();
 			if (externalSignal && externalAbortListener) externalSignal.removeEventListener("abort", externalAbortListener);
 		}
@@ -16680,6 +16832,22 @@ function createAgent(rawOptions) {
 			wireTools
 		});
 	}
+	async function getContextSegments(opts) {
+		if (destroyed) return null;
+		const assembly = lastContextAssembly ?? await buildPreRunAssembly();
+		if (!assembly) return null;
+		const rulesBlock = opts?.rulesBlock ?? assembly.rulesBlock;
+		return buildContextSegments({
+			system: assembly.system,
+			baseSystem: assembly.baseSystem,
+			...rulesBlock ? { rulesBlock } : {},
+			...opts?.rulesFiles?.length ? { rulesFiles: opts.rulesFiles } : {},
+			...opts?.systemPath !== void 0 ? { systemPath: opts.systemPath } : {},
+			...assembly.skillsCatalog ? { skillsCatalog: assembly.skillsCatalog } : {},
+			...assembly.mcpInstructions ? { mcpInstructions: assembly.mcpInstructions } : {},
+			...assembly.subagentDefs ? { subagentDefs: assembly.subagentDefs } : {}
+		});
+	}
 	async function getContextBreakdown(opts) {
 		if (destroyed) return null;
 		const assembly = lastContextAssembly ?? await buildPreRunAssembly(opts?.model);
@@ -16793,10 +16961,11 @@ function createAgent(rawOptions) {
 		},
 		meta: Object.freeze({ ...provider.meta }),
 		getContextBreakdown,
+		getContextSegments,
 		[Symbol.asyncDispose]: destroy
 	};
 }
 //#endregion
 export { installExtensionFromSpec as $, groupBindings as $t, selectFilesFromSession as A, defaultRepeatGuardNormalize as An, createSkillsReadTool as At, buildUpToCompactPrompt as B, matchModelEntries as Bt, resolveLegacySessionDir as C, resolveExtensionConfigValue as Cn, waitTask as Ct, resolveTasksDir as D, OUTPUT_RESERVE_TOKENS as Dn, reserveChildLabel as Dt, resolveSessionDir as E, AUTO_COMPACT_MIN_GROWTH_FRACTION as En, isSpawnTool as Et, TRAILER as F, hashContent as Fn, readFile$1 as Ft, summaryToTurn as G, edit as Gt, anchorPreviewFor as H, createInteractionTool as Ht, buildCompactPrompt as I, hydrateReadStateFromSession as In, looksBinary as It, CompactPromptTooLongError as J, KEYBINDING_DEFS as Jt, truncateHeadForPtlRetry as K, validateToolArgs as Kt, buildFromCompactPrompt as L, hydrateReadStateFromSessionAsync as Ln, multiEdit as Lt, compactConversation as M, normalizeShellCommand as Mn, createShellTool as Mt, BASE_INSTRUCTIONS as N, stableStringify as Nn, shell as Nt, buildPostCompactAttachments as O, effectiveContextWindow as On, createSkillsUseTool as Ot, NO_TOOLS_PREAMBLE as P, getReadState as Pn, tailTruncate as Pt, fetchExtensionSource as Q, formatBindingForDisplay as Qt, buildFullCompactPrompt as R, readStateKey as Rn, createModelSearchTool as Rt, resolveLegacyPersistDir as S, resolveExtensionConfig as Sn, WAIT_TASK_TIMED_OUT_PREFIX as St, resolvePersistDir as T, toWireConfigSchema as Tn, createSpawnTool as Tt, sliceForCompaction as U, grep as Ut, ANCHOR_PREVIEW_MAX_CHARS as V, listFiles as Vt, stripImagesFromTurns as W, glob as Wt, createExtensionPromptBridge as X, KEYBINDING_KEY_COL_WIDTH as Xt, EMPTY_EXTENSION_REGISTRY as Y, KEYBINDING_DEF_BY_ACTION as Yt, ExtensionInstallError as Z, ensureKeybindingsFile as Zt, buildPersistedStub as _, defineExtension as _n, composePresets as _t, stagedToolState as a, readKeybindingsRaw as an, createExtensionHud as at, migrateSessionArtifactDirs as b, isValidExtensionConfigItem as bn, basic_default as bt, INTERRUPT_MESSAGE_FOR_TOOL_USE as c, registerExtensionHostModules as cn, buildExtensionRegistry as ct, TOOL_USE_SKIPPED_MESSAGE as d, discoverExtensions as dn, filterExtensionRegistry as dt, keybindingsPath as en, listExtensionCandidates as et, applyCompactSummaryCutoff as f, inlineLoadedExtension as fn, filterRegistryPlugins as ft, PERSISTENCE_PREVIEW_BYTES as g, createDebugLog as gn, createWorkspaceSurface as gt, PERSISTED_STUB_PREFIX as h, scanExtensionDirectories as hn, createExtensionHostRuntimeBridge as ht, isToolStateOps as i, readKeybindings as in, updateInstalledExtension as it, selectRecentFiles as j, defaultRepeatGuardTracked as jn, shellKill as jt, selectFilesFromReadState as k, shouldAutoCompact as kn, createSkillsRunScriptTool as kt, SHELL_CASCADE_CANCEL_MESSAGE as l, ENTRY_CANDIDATES as ln, composeExtensionPreset as lt, renderStaleReadNotice as m, parseExtensionScanPathEnv as mn, partitionExtensionCatalog as mt, DEFAULT_MAX_VALUE_BYTES as n, mergeKeybindings as nn, readExtensionInstallProvenance as nt, normalizeProviders as o, resolveExtensionKeybindings as on, discoverAndBuildExtensionRegistry as ot, collectNewlyStaleReadPaths as p, isExtensionDefinition as pn, mergeContributions as pt, CompactInvalidInputError as q, DEFAULT_KEYBINDINGS as qt, createToolStateController as r, parseBindingSpec as rn, removeInstalledExtension as rt, resolveModelTargets as s, stripJsonComments as sn, buildExtensionPreset as st, createAgent as t, matchesBinding as tn, parseExtensionInstallSource as tt, TOOL_USE_CANCELLED_MESSAGE as u, defaultExtensionScanPaths as un, disposeExtensionRegistry as ut, cleanupPersistedSession as v, clampExtensionConfigNumber as vn, definePreset as vt, resolveMcpWarningsDir as w, sanitizeExtensionConfigActionPatch as wn, createToolSearchTool as wt, rehomePersistedStubs as x, isValidExtensionConfigValue as xn, writeFile$1 as xt, maybePersistToolResult as y, coerceExtensionConfigInput as yn, basicTools as yt, buildTailCompactPrompt as z, resolveReadStateMap as zn, formatModelLine as zt };
 
-//# sourceMappingURL=agent-BVNkC1h4.js.map
+//# sourceMappingURL=agent-8kfGIDb_.js.map