zidane 6.2.23 → 6.2.26

package/dist/{agent-BSIMsEtD.js → agent--VPMZ0nT.js}

@@ -5,27 +5,28 @@ import { a as hydrateReadStateFromSessionAsync, c as resolveReadStateMap, n as g
 import { n as estimateTokens, r as utf8ByteLength } from "./utils-ngQzYzZD.js";
 import { t as buildContextBreakdown } from "./context-breakdown-Dzo25N45.js";
 import { a as formatDuration, c as previewLine, o as formatTaskStatus, s as formatTaskSummary } from "./format-BF745pLL.js";
-import { c as parseGitLsFiles, r as isOutputExceededMessage, s as GIT_LS_FILES_COMMAND } from "./output-cap-kBUHBlnq.js";
+import { i as parseGitLsFiles, r as GIT_LS_FILES_COMMAND } from "./glob-DluQFSw1.js";
 import { n as alwaysQuote, r as shellQuote } from "./exec-file-size-PXkr-MGA.js";
-import { r as createProcessContext, t as resolveDetachedTasksCapability } from "./contexts-A4ep-iJs.js";
+import { i as isOutputExceededMessage } from "./output-cap-DM1HrgIp.js";
+import { r as createProcessContext, t as resolveDetachedTasksCapability } from "./contexts-0rmrBhTK.js";
 import { i as AgentProviderError, l as errorMessage, m as toTypedError, n as AgentBudgetExceededError, o as AgentToolPairingError, t as AgentAbortedError, u as isAbortLikeError } from "./errors-DJUxZg9b.js";
-import { C as stripShellInterpolations, O as validateResourcePathReal, S as interpolateShellCommands, _ as lastLine, b as resolveSubdirRoot, d as installAllowedToolsGate, f as createSkillActivationState, g as fetchInstallSource, h as defaultWhich, j as projectUserPaths, l as buildCatalog, m as defaultExec, p as InstallSourceError, t as resolveSkills, v as parseInstallSource, x as escapeXml, y as resolveNpmVersion } from "./resolve-x5mlFtLX.js";
+import { C as stripShellInterpolations, O as validateResourcePathReal, S as interpolateShellCommands, _ as lastLine, b as resolveSubdirRoot, d as installAllowedToolsGate, f as createSkillActivationState, g as fetchInstallSource, h as defaultWhich, j as projectUserPaths, l as buildCatalog, m as defaultExec, p as InstallSourceError, t as resolveSkills, v as parseInstallSource, x as escapeXml, y as resolveNpmVersion } from "./resolve-BPTA1RpX.js";
 import { n as writeFileAtomicAsync, t as writeFileAtomic } from "./atomic-write-B7zr1ddF.js";
 import { r as createLogger, t as consoleSink } from "./logger-DBX9uYOw.js";
 import { n as reconcileImageMediaType } from "./media-sniff-Bn76JxAu.js";
 import { c as wrapDiscoveredMcpTools, i as nonOwningMcpView, n as connectMcpServers, r as deriveMcpToolMeta } from "./mcp-H6bqyM94.js";
-import { n as flattenTurns, r as formatTokenUsage, t as effectiveInputFromTurn } from "./stats-DAKBEKjc.js";
 import { C as canonicalizePrompt, S as buildPromptMessage } from "./openai-compat-pHI0kBWH.js";
 import { appendStaticSection, renderSystemForWire } from "./prompt.js";
 import { a as detectTurnInterruption, c as filterUnresolvedToolUses, d as remintDuplicateToolCallIds, f as resolveContentRefsInMessages, n as SYNTHETIC_TOOL_RESULT_PLACEHOLDER, o as ensureEndsWithUserMessage, s as ensureToolResultPairing } from "./messages-CvHfYB7f.js";
-import { a as getExtensionSessionState, c as withExtensionSession, n as currentExtensionSession, r as deleteExtensionSessionState, s as setExtensionSessionState } from "./session-Dbvz1ZUE.js";
+import { a as getExtensionSessionState, c as setExtensionSessionState, l as withExtensionSession, n as currentExtensionSession, r as deleteExtensionSessionState, s as resumeChainRunIds } from "./session-jLsc_kMH.js";
+import { n as flattenTurns, r as formatTokenUsage, t as effectiveInputFromTurn } from "./stats-DAKBEKjc.js";
 import { a as withInactivityTimeout, i as settleWithinTimeout, n as linkAbortSignal, o as withTimeout$1, r as resolveTimeoutMs, t as OperationTimeoutError } from "./timeout-BDetbuN6.js";
 import { createRequire } from "node:module";
 import { basename, delimiter, dirname, isAbsolute, join, resolve, sep } from "node:path";
 import { createHooks } from "hookable";
 import { Buffer } from "node:buffer";
 import { cpSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, writeFileSync } from "node:fs";
-import { readdir, rm, stat, unlink } from "node:fs/promises";
+import { copyFile, mkdir, readdir, rm, stat, unlink } from "node:fs/promises";
 import { pathToFileURL } from "node:url";
 import { homedir, tmpdir } from "node:os";
 import { createHash } from "node:crypto";
@@ -215,6 +216,7 @@ const DEFAULT_FAILED_MUTATIONS = 3;
 const DEFAULT_NOOP_MUTATIONS = 3;
 const DEFAULT_VALIDATION_REJECTS = 3;
 const DEFAULT_TOOL_ERRORS = 3;
+const DEFAULT_SINGLE_CALL_TURNS = 3;
 const DEFAULT_MAX_NUDGES$1 = 3;
 const DEFAULT_READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
 	"read_file",
@@ -228,6 +230,17 @@ const DEFAULT_READ_ONLY_TOOLS = /* @__PURE__ */ new Set([
 	"skills_read",
 	"todoread"
 ]);
+/**
+* Discovery chains are inherently sequential — each call's input needs the
+* prior result (`tool_search` → load → call, `skills_read` after `skills_use`)
+* and `todoread` is a singleton by nature. Their single-call turns are not
+* "unbatched", so they reset the streak instead of extending it.
+*/
+const SINGLE_CALL_EXEMPT_TOOLS = /* @__PURE__ */ new Set([
+	"tool_search",
+	"skills_read",
+	"todoread"
+]);
 function threshold(value, fallback) {
 	if (value === false) return false;
 	return clampPositiveInt(value, fallback);
@@ -239,6 +252,7 @@ function defaultMessage(kind) {
 		case "noopMutations": return "Several mutation calls produced no file changes. Check whether the requested state is already reached; if so, report that instead of issuing more edits.";
 		case "validationRejects": return "Several tool calls had invalid arguments. Re-check the advertised tool schema and emit one well-formed native tool call.";
 		case "toolErrors": return "Several tool calls errored. Pivot from repeating the failing call: inspect the error, adjust the input or approach, then continue with one concrete action.";
+		case "singleCallTurns": return "You are issuing one tool call per response. Independent read-only calls (file reads, searches, listings) have no dependencies between them — batch all of them into a single response instead of one per turn. Only sequence calls whose inputs depend on a previous result.";
 	}
 }
 function messageFor(config, kind, count) {
@@ -256,10 +270,12 @@ function installProgressNudges(hooks, config, deps) {
 	const noopMutations = threshold(resolvedConfig.noopMutations, DEFAULT_NOOP_MUTATIONS);
 	const validationRejects = threshold(resolvedConfig.validationRejects, DEFAULT_VALIDATION_REJECTS);
 	const toolErrors = threshold(resolvedConfig.toolErrors, DEFAULT_TOOL_ERRORS);
+	const singleCallTurns = resolvedConfig.singleCallTurns === void 0 ? false : threshold(resolvedConfig.singleCallTurns, DEFAULT_SINGLE_CALL_TURNS);
 	const readOnlyTools = /* @__PURE__ */ new Set([...resolvedConfig.readOnlyTools ?? DEFAULT_READ_ONLY_TOOLS]);
 	let nudgeCount = 0;
 	const fired = /* @__PURE__ */ new Set();
 	let consecutiveReadOnlyTurns = 0;
+	let consecutiveSingleCallTurns = 0;
 	let consecutiveFailedMutations = 0;
 	let consecutiveNoopMutations = 0;
 	let validationRejectCount = 0;
@@ -301,8 +317,17 @@ function installProgressNudges(hooks, config, deps) {
 		}),
 		hooks.hook("turn:after", (ctx) => {
 			const entries = Object.entries(ctx.toolCounts.turn).filter(([, count]) => count > 0);
-			if (entries.length === 0) return;
-			if (!entries.every(([tool]) => readOnlyTools.has(tool))) {
+			if (entries.length === 0) {
+				consecutiveSingleCallTurns = 0;
+				return;
+			}
+			const readOnly = entries.every(([tool]) => readOnlyTools.has(tool));
+			const totalCalls = entries.reduce((sum, [, count]) => sum + count, 0);
+			if (readOnly && totalCalls === 1 && !SINGLE_CALL_EXEMPT_TOOLS.has(entries[0][0])) {
+				consecutiveSingleCallTurns++;
+				maybeNudge("singleCallTurns", consecutiveSingleCallTurns, singleCallTurns);
+			} else consecutiveSingleCallTurns = 0;
+			if (!readOnly) {
 				consecutiveReadOnlyTurns = 0;
 				return;
 			}
@@ -3316,6 +3341,11 @@ function createInteractionTool(options) {
 function entryPath(entry) {
 	return typeof entry === "string" ? entry : entry.path;
 }
+/**
+* Entry ceiling — matches glob's default limit so a pathological
+* 100k-entry directory can't flood the context window.
+*/
+const MAX_ENTRIES = 1e3;
 const listFiles = {
 	isConcurrencySafe: true,
 	spec: {
@@ -3333,7 +3363,9 @@ const listFiles = {
 	async execute({ path }, ctx) {
 		const target = path || ".";
 		try {
-			return (await ctx.execution.listFiles(ctx.handle, target)).map(entryPath).join("\n") || "(empty directory)";
+			const entries = await ctx.execution.listFiles(ctx.handle, target);
+			if (entries.length > MAX_ENTRIES) return `${entries.slice(0, MAX_ENTRIES).map(entryPath).join("\n")}\n…(${entries.length - MAX_ENTRIES} more entries omitted; use glob with a narrower pattern)`;
+			return entries.map(entryPath).join("\n") || "(empty directory)";
 		} catch (err) {
 			ctx.reportOutcome?.("failed");
 			const message = errorMessage(err);
@@ -3964,6 +3996,8 @@ const readFile$1 = {
 		if (extMedia) {
 			const sizeCap = normalizeReadFileInteger(maxBytes, defaults.attachmentMaxBytes);
 			try {
+				const probed = await ctx.execution.fileSize?.(ctx.handle, path) ?? null;
+				if (probed !== null && sizeCap > 0 && probed > sizeCap) return `[image too large to inline: ${path}, ${probed} bytes (cap ${sizeCap}). Raise maxBytes, or use shell to inspect.]`;
 				const { base64, byteLength } = await readFileAsBase64(ctx.execution, ctx.handle, path);
 				if (sizeCap > 0 && byteLength > sizeCap) return `[image too large to inline: ${path}, ${byteLength} bytes (cap ${sizeCap}). Raise maxBytes, or use shell to inspect.]`;
 				const imgMedia = reconcileImageMediaType(extMedia, base64);
@@ -3984,6 +4018,8 @@ const readFile$1 = {
 		if (docMedia) {
 			const sizeCap = normalizeReadFileInteger(maxBytes, defaults.attachmentMaxBytes);
 			try {
+				const probed = await ctx.execution.fileSize?.(ctx.handle, path) ?? null;
+				if (probed !== null && sizeCap > 0 && probed > sizeCap) return `[document too large to attach: ${path}, ${probed} bytes (cap ${sizeCap}). Raise maxBytes, or use shell/read text extraction to inspect.]`;
 				const { base64, byteLength } = await readFileAsBase64(ctx.execution, ctx.handle, path);
 				if (sizeCap > 0 && byteLength > sizeCap) return `[document too large to attach: ${path}, ${byteLength} bytes (cap ${sizeCap}). Raise maxBytes, or use shell/read text extraction to inspect.]`;
 				if (docMedia === "application/pdf" && !isPdfBase64(base64)) return `[binary file: ${path}, ${byteLength} bytes; extension suggests PDF but file header does not start with %PDF-]`;
@@ -4838,6 +4874,7 @@ const BUBBLED_EVENTS = [
 	"stream:error",
 	"stream:server_tool_use",
 	"stream:server_tool_result",
+	"stream:retry",
 	"tool:dispatched",
 	"tool:before",
 	"tool:after",
@@ -4861,6 +4898,7 @@ const CHILD_EVENT_NAME = {
 	"stream:error": "child:stream:error",
 	"stream:server_tool_use": "child:stream:server_tool_use",
 	"stream:server_tool_result": "child:stream:server_tool_result",
+	"stream:retry": "child:stream:retry",
 	"tool:dispatched": "child:tool:dispatched",
 	"tool:before": "child:tool:before",
 	"tool:after": "child:tool:after",
@@ -4883,19 +4921,27 @@ function childRunsOf(session) {
 	return session.runs.filter((r) => (r.depth ?? 0) > 0);
 }
 /**
-* Human/model-facing list of this session's child runs, labeled the same
-* way `reserveChildLabel` numbers them (chronological order of depth > 0
-* runs). Rendered into resume-rejection messages so the model can
-* self-correct with a valid label.
+* Human/model-facing list of this session's child runs. Prefers the label
+* persisted at `startRun` (`SessionRun.label`) and falls back to positional
+* numbering for legacy sessions recorded before labels were stored.
+* Rendered into resume-rejection messages so the model can self-correct
+* with a valid label.
 */
 function describeChildRuns(session) {
 	const childRuns = childRunsOf(session);
 	if (childRuns.length === 0) return "No child runs exist in this session.";
-	return childRuns.map((r, i) => `- child-${i + 1} · ${r.status} · ${r.prompt.slice(0, 80)}`).join("\n");
+	return childRuns.map((r, i) => `- ${r.label ?? `child-${i + 1}`} · ${r.status} · ${r.prompt.slice(0, 80)}`).join("\n");
 }
 function reserveChildLabel(session) {
 	let counter = sessionChildCounters.get(session);
-	if (counter === void 0) counter = session.runs.filter((r) => (r.depth ?? 0) > 0).length;
+	if (counter === void 0) {
+		const childRuns = childRunsOf(session);
+		counter = childRuns.length;
+		for (const r of childRuns) {
+			const m = r.label ? /^child-(\d+)$/.exec(r.label) : null;
+			if (m) counter = Math.max(counter, Number(m[1]));
+		}
+	}
 	counter += 1;
 	sessionChildCounters.set(session, counter);
 	return `child-${counter}`;
@@ -5318,7 +5364,12 @@ function buildSpawnTool(options, state) {
 			const announcedModel = childModel ?? childProvider.meta.defaultModel;
 			let resumeRun;
 			let resumeLabel;
-			if (typeof input.resume === "string" && input.resume.trim() !== "") {
+			if (input.resume !== void 0 && input.resume !== null) {
+				if (typeof input.resume !== "string" || input.resume.trim() === "") return {
+					status: "rejected",
+					text: "",
+					message: `Cannot resume: invalid resume value ${JSON.stringify(input.resume)} — pass a child label like "child-2".`
+				};
 				const wanted = input.resume.trim();
 				if (!options.persist || !ctx.session) return {
 					status: "rejected",
@@ -5326,26 +5377,32 @@ function buildSpawnTool(options, state) {
 					message: "Cannot resume: resuming a sub-agent requires the spawn tool to be configured with persist: true and the parent to have a session — no prior child turns are stored here."
 				};
 				const childRuns = childRunsOf(ctx.session);
-				const labelMatch = /^child-(\d+)$/.exec(wanted);
-				const index = labelMatch ? Number(labelMatch[1]) - 1 : childRuns.findIndex((r) => r.id === wanted);
+				let index = childRuns.findIndex((r) => r.label === wanted);
+				if (index < 0) {
+					const labelMatch = /^child-(\d+)$/.exec(wanted);
+					const anyLabeled = childRuns.some((r) => r.label !== void 0);
+					index = labelMatch && !anyLabeled ? Number(labelMatch[1]) - 1 : childRuns.findIndex((r) => r.id === wanted);
+				}
 				const run = index >= 0 ? childRuns[index] : void 0;
 				if (!run) return {
 					status: "rejected",
 					text: "",
 					message: `Cannot resume: no child run matches "${wanted}". Child runs in this session:\n${describeChildRuns(ctx.session)}`
 				};
+				const runLabel = run.label ?? `child-${index + 1}`;
 				if (run.status === "running") return {
 					status: "rejected",
 					text: "",
-					message: `Cannot resume: child-${index + 1} is still running. Only terminal children (aborted / error / completed) can be resumed.`
+					message: `Cannot resume: ${runLabel} is still running. Only terminal children (aborted / error / completed) can be resumed.`
 				};
-				if (!ctx.session.turns.some((t) => t.runId === run.id)) return {
+				const chain = resumeChainRunIds(ctx.session.runs, run.id);
+				if (!ctx.session.turns.some((t) => t.runId !== void 0 && chain.has(t.runId))) return {
 					status: "rejected",
 					text: "",
-					message: `Cannot resume: child-${index + 1} has no persisted turns (it likely failed before producing anything). Spawn a fresh child with a full task instead.`
+					message: `Cannot resume: ${runLabel} has no persisted turns (it likely failed before producing anything). Spawn a fresh child with a full task instead.`
 				};
 				resumeRun = run;
-				resumeLabel = `child-${index + 1}`;
+				resumeLabel = runLabel;
 			}
 			const parentDepth = ctx.depth ?? 0;
 			const childDepth = parentDepth + 1;
@@ -5438,6 +5495,7 @@ function buildSpawnTool(options, state) {
 					signal: ctx.signal,
 					depth: childDepth,
 					...options.persist && ctx.runId ? { parentRunId: ctx.runId } : {},
+					...options.persist && ctx.session ? { runLabel: id } : {},
 					...resumeRun ? { resumeRunId: resumeRun.id } : {},
 					...propagatedTracing ? { tracingContext: propagatedTracing } : {}
 				});
@@ -9394,6 +9452,147 @@ async function persistElidedToolResults(messages, items, opts) {
 	});
 }
 /**
+* Subdirectory of the session persist dir holding blobs written by
+* {@link releaseReplacedTurnContent}. Deliberately separate from the
+* top-level `<callId>.txt` blobs: once a released stub round-trips into the
+* session store (`session.save()` is delete-all-and-reinsert), the blob is
+* the ONLY remaining copy of that content — it must never be LRU-evicted by
+* {@link enforcePersistDirCap}, whose sweep only scans top-level `*.txt`
+* files. Released blobs live and die with the session
+* ({@link cleanupPersistedSession} removes the dir recursively).
+*/
+const RELEASED_BLOB_SUBDIR = "released";
+/**
+* Post-compaction memory release — swap the in-memory bodies of turns a
+* compaction summary just replaced for recoverable `<persisted-output …>`
+* stubs, so a long-lived host process stops retaining tool output the model
+* can never see again (`applyCompactSummaryCutoff` elides these turns from
+* every future wire projection).
+*
+* MUTATES the passed turn objects in place — that is the point: the session's
+* `data.turns` is the single canonical in-memory copy, and releasing anywhere
+* else would leave it pinned. Only `tool_result` blocks with large string /
+* all-text outputs are touched (media already lives behind content refs);
+* everything else — prompts, assistant text, thinking — is kept verbatim.
+*
+* Durability contract: each released output is written to
+* `<persistDir>/released/<callId>.txt` first, so even if a host later
+* round-trips the stubbed turns to the session store, the content stays
+* retrievable from the stub's path. Blobs are always written HOST-side
+* (never through an execution context): the session store is host-local,
+* so its recovery copy must be too — a sandboxed context write would
+* strand the only durable copy inside an ephemeral container. A blob write
+* failure skips that block — the original stays in memory rather than
+* being lost.
+*
+* Opt-in via `autoCompact.releaseReplacedTurns`: hosts that need the lossless
+* inline transcript (SFT capture, exporters) keep the default-off behavior.
+*/
+async function releaseReplacedTurnContent(turns, replacedTurnIds, opts) {
+	const result = {
+		releasedBlocks: 0,
+		releasedBytes: 0
+	};
+	if (replacedTurnIds.size === 0 || !isAbsolute(opts.persistDir)) return result;
+	const minBytes = opts.minBytes ?? 2048;
+	const blobDir = join(opts.persistDir, RELEASED_BLOB_SUBDIR);
+	const replaced = turns.filter((t) => t.id !== void 0 && replacedTurnIds.has(t.id));
+	const toolNameByCallId = /* @__PURE__ */ new Map();
+	for (const turn of replaced) for (const block of turn.content) if (block.type === "tool_call") toolNameByCallId.set(block.id, block.name);
+	const callIdOccurrences = /* @__PURE__ */ new Map();
+	for (const turn of replaced) for (let i = 0; i < turn.content.length; i++) {
+		const block = turn.content[i];
+		if (block.type !== "tool_result") continue;
+		const ordinal = (callIdOccurrences.get(block.callId) ?? 0) + 1;
+		callIdOccurrences.set(block.callId, ordinal);
+		const text = textForPersistence(block.output);
+		if (text === null || text.startsWith("<persisted-output tool=\"")) continue;
+		const bytes = utf8ByteLength(text);
+		if (bytes < minBytes) continue;
+		if (!SAFE_CALL_ID.test(block.callId) || block.callId.includes("..")) continue;
+		const persistedPath = join(blobDir, ordinal === 1 ? `${block.callId}.txt` : `${block.callId}.${ordinal}.txt`);
+		let exists = false;
+		try {
+			exists = (await stat(persistedPath)).isFile();
+		} catch {
+			exists = false;
+		}
+		if (!exists) try {
+			await writeAtomic(persistedPath, text);
+		} catch {
+			continue;
+		}
+		turn.content[i] = {
+			...block,
+			output: buildPersistedStub({
+				toolName: toolNameByCallId.get(block.callId) ?? "tool",
+				originalBytes: bytes,
+				persistedPath,
+				output: text,
+				previewBytes: ELIDE_PERSIST_PREVIEW_BYTES
+			})
+		};
+		result.releasedBlocks++;
+		result.releasedBytes += bytes;
+	}
+	return result;
+}
+/**
+* Re-home `<persisted-output …>` stubs when turns are copied into a NEW
+* session (fork): released blob paths are per-session
+* (`resolvePersistDir` keys on the session id), so a fork that keeps the
+* origin's paths loses its content the moment the origin session is
+* deleted ({@link cleanupPersistedSession} removes the origin's blob dir).
+* Copies each referenced blob under `fromPersistDir` into the same
+* relative location under `toPersistDir` and rewrites the stub's `path`
+* attribute. Copy-on-write: input turns are never mutated (they are
+* usually shared with the origin session's live `data.turns`); a new turn
+* object is returned only where a stub was rewritten. A missing/uncopyable
+* blob leaves that stub pointing at the origin — no worse than before.
+*
+* Prefix matching happens on the XML-escaped attribute text: `escapeXml`
+* maps characters independently, so `escapeXml(a + b)` ===
+* `escapeXml(a) + escapeXml(b)` and a prefix match on escaped text is
+* exact. Blob filenames are `SAFE_CALL_ID`-constrained (`[\w.-]`), so the
+* relative remainder is escape-invariant.
+*/
+async function rehomePersistedStubs(turns, fromPersistDir, toPersistDir) {
+	if (!isAbsolute(fromPersistDir) || !isAbsolute(toPersistDir) || fromPersistDir === toPersistDir) return [...turns];
+	const fromPrefix = `path="${escapeXml(fromPersistDir)}/`;
+	const out = [];
+	for (const turn of turns) {
+		let content;
+		for (let i = 0; i < turn.content.length; i++) {
+			const block = turn.content[i];
+			if (block.type !== "tool_result" || typeof block.output !== "string" || !block.output.startsWith("<persisted-output tool=\"")) continue;
+			const start = block.output.indexOf(fromPrefix);
+			if (start === -1) continue;
+			const restStart = start + fromPrefix.length;
+			const end = block.output.indexOf("\"", restStart);
+			if (end === -1) continue;
+			const relative = block.output.slice(restStart, end);
+			if (relative.includes("..")) continue;
+			try {
+				const target = join(toPersistDir, relative);
+				await mkdir(dirname(target), { recursive: true });
+				await copyFile(join(fromPersistDir, relative), target);
+			} catch {
+				continue;
+			}
+			content ??= [...turn.content];
+			content[i] = {
+				...block,
+				output: `${block.output.slice(0, start)}path="${escapeXml(toPersistDir)}/${relative}${block.output.slice(end)}`
+			};
+		}
+		out.push(content ? {
+			...turn,
+			content
+		} : turn);
+	}
+	return out;
+}
+/**
 * Write-then-rename for atomicity — delegates to the shared
 * {@link writeFileAtomicAsync} helper (unique pid+counter tmp suffix,
 * fsync before rename, tmp cleanup on failure). Creates the parent
@@ -9748,6 +9947,24 @@ function applyCompactSummaryCutoff(turns) {
 const COMPACTION_STUB = "[…elided: older tool output trimmed to fit the context budget.]";
 const COMPACTION_STUB_BYTES = toolOutputByteLength(COMPACTION_STUB);
 const COMPACT_CHUNK_TURNS = 8;
+/**
+* Cross-turn memo for `toolOutputBudgetByteLength`, keyed on the tool_result
+* block object. The wire pipeline preserves block references for unchanged
+* blocks (sanitize/alias/elision copy only what they touch), so the same
+* block objects flow through the byte-accounting loops on every turn of a
+* run. Without the memo, tail compaction re-measures the ENTIRE transcript's
+* tool output each turn — O(total transcript bytes) per turn, O(n²) per run.
+* Blocks are immutable by pipeline convention; a transform that changes an
+* output produces a new object, which simply misses the memo once.
+*/
+const toolResultBudgetBytesMemo = /* @__PURE__ */ new WeakMap();
+function memoizedToolResultBudgetBytes(block) {
+	const hit = toolResultBudgetBytesMemo.get(block);
+	if (hit !== void 0) return hit;
+	const bytes = toolOutputBudgetByteLength(block.output);
+	toolResultBudgetBytesMemo.set(block, bytes);
+	return bytes;
+}
 function applyTailCompaction(messages, threshold, keepTurns, options) {
 	const elidedReadPaths = [];
 	const persistableElided = [];
@@ -9759,7 +9976,7 @@ function applyTailCompaction(messages, threshold, keepTurns, options) {
 		persistableElided
 	};
 	let totalBytes = 0;
-	for (const msg of messages) for (const block of msg.content) if (block.type === "tool_result") totalBytes += toolOutputBudgetByteLength(block.output);
+	for (const msg of messages) for (const block of msg.content) if (block.type === "tool_result") totalBytes += memoizedToolResultBudgetBytes(block);
 	if (totalBytes <= threshold) return {
 		messages,
 		elidedReadPaths,
@@ -9775,7 +9992,7 @@ function applyTailCompaction(messages, threshold, keepTurns, options) {
 	let keptBytes = 0;
 	let budgetCutoff = floorCutoff;
 	for (let i = messages.length - 1; i >= 0; i--) {
-		for (const block of messages[i].content) if (block.type === "tool_result") keptBytes += toolOutputBudgetByteLength(block.output);
+		for (const block of messages[i].content) if (block.type === "tool_result") keptBytes += memoizedToolResultBudgetBytes(block);
 		if (keptBytes > threshold) {
 			budgetCutoff = i + 1;
 			break;
@@ -10397,11 +10614,58 @@ async function runLoop(ctx) {
 		unregisterTtftTool();
 	}
 }
+/**
+* Per-run LRU for resolved content-ref payloads, keyed by `type:ref`.
+*
+* Refs are content-addressed (`attachment://<hash>` and persist-dir blobs are
+* immutable once written), so within a run the same ref always resolves to the
+* same bytes — but the wire pipeline re-resolves EVERY ref in the history on
+* EVERY turn (resolution runs before media age-out, which then discards most
+* of the resolved base64 again). Without this cache an image-heavy session
+* re-reads and re-base64s each attachment from disk once per turn, O(refs)
+* disk I/O per turn → O(turns × refs) per run.
+*
+* Keyed on the LoopContext via WeakMap so the cache dies with the run and no
+* cross-run staleness question arises. Byte-bounded (UTF-8 bytes, measured
+* once at insert — `.length` counts UTF-16 code units and would let the
+* budget retain up to 2× its nominal size on multi-byte text), evicting
+* oldest-first (Map insertion order; hits re-insert to refresh recency).
+*/
+const CONTENT_REF_CACHE_MAX_BYTES = 64 * 1024 * 1024;
+const contentRefCaches = /* @__PURE__ */ new WeakMap();
 async function resolveContentRefsForWire(ctx, messages) {
 	return resolveContentRefsInMessages(messages, { resolveContentRef: async (block) => {
+		const key = `${block.type}:${block.ref}`;
+		let cache = contentRefCaches.get(ctx);
+		if (!cache) {
+			cache = {
+				bytes: 0,
+				entries: /* @__PURE__ */ new Map()
+			};
+			contentRefCaches.set(ctx, cache);
+		}
+		const hit = cache.entries.get(key);
+		if (hit !== void 0) {
+			cache.entries.delete(key);
+			cache.entries.set(key, hit);
+			return { data: hit.data };
+		}
 		const hookCtx = { block };
 		await ctx.hooks.callHook("content-ref:resolve", hookCtx);
 		if (typeof hookCtx.data !== "string") throw new Error(`Content ref "${block.ref}" (${block.type}) was not resolved by a content-ref:resolve hook.`);
+		const dataBytes = Buffer.byteLength(hookCtx.data, "utf8");
+		if (dataBytes <= CONTENT_REF_CACHE_MAX_BYTES) {
+			cache.entries.set(key, {
+				data: hookCtx.data,
+				bytes: dataBytes
+			});
+			cache.bytes += dataBytes;
+			for (const [k, v] of cache.entries) {
+				if (cache.bytes <= CONTENT_REF_CACHE_MAX_BYTES) break;
+				cache.entries.delete(k);
+				cache.bytes -= v.bytes;
+			}
+		}
 		return { data: hookCtx.data };
 	} });
 }
@@ -10843,7 +11107,8 @@ function resolveAutoCompact(raw, opts = {}) {
 		restore: cfg.restore !== false,
 		maxFailures: typeof cfg.maxFailures === "number" && Number.isFinite(cfg.maxFailures) && cfg.maxFailures > 0 ? Math.floor(cfg.maxFailures) : DEFAULT_AUTO_COMPACT_MAX_FAILURES,
 		provider: cfg.provider ?? null,
-		model: typeof cfg.model === "string" && cfg.model.length > 0 ? cfg.model : null
+		model: typeof cfg.model === "string" && cfg.model.length > 0 ? cfg.model : null,
+		releaseReplacedTurns: cfg.releaseReplacedTurns === true
 	};
 }
 /**
@@ -10945,6 +11210,11 @@ 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 });
+		} catch (err) {
+			if (process.env.ZIDANE_DEBUG) process.stderr.write(`[zidane/loop] post-compact turn release failed: ${errorMessage(err)}\n`);
+		}
 		const absorbedIds = /* @__PURE__ */ new Set([...result.summarizedTurnIds, ...result.droppedDueToPtl]);
 		const onWireReads = new Set(readFilePathsInTurns(applyCompactSummaryCutoff(ctx.turns)));
 		markReadStateForElidedPaths(ctx, ctx.handle.cwd, readFilePathsInTurns(ctx.turns, absorbedIds).filter((p) => !onWireReads.has(p)));
@@ -11092,10 +11362,12 @@ async function executeTurn(ctx, turn, priorUsage) {
 	}
 	const wireMessages = rewriteMessagesToWire(canonicalMessages, ctx.aliasMaps);
 	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;
-		const { readPathByCallId, toolNameByCallId } = collectCallMaps(canonicalMessages);
+		const { readPathByCallId, toolNameByCallId } = callMaps();
 		const compacted = applyTailCompaction(sanitizedMessages, threshold, keep, {
 			readPathByCallId,
 			toolNameByCallId,
@@ -11113,7 +11385,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 		const threshold = typeof ctx.compactThreshold === "number" && ctx.compactThreshold > 0 ? ctx.compactThreshold : 131072;
 		const keep = typeof ctx.compactKeepTurns === "number" && ctx.compactKeepTurns >= 0 ? ctx.compactKeepTurns : 4;
 		let totalBytes = 0;
-		for (const msg of sanitizedMessages) for (const block of msg.content) if (block.type === "tool_result") totalBytes += toolOutputBudgetByteLength(block.output);
+		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, {
 				threshold,
@@ -11126,7 +11398,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 		}
 	}
 	if (typeof ctx.mediaKeepTurns === "number" && ctx.mediaKeepTurns >= 0 && ctx.tools.read_file) {
-		const { readPathByCallId } = collectCallMaps(canonicalMessages);
+		const { readPathByCallId } = callMaps();
 		const aged = applyMediaAgeout(sanitizedMessages, ctx.mediaKeepTurns, {
 			chunkTurns: COMPACT_CHUNK_TURNS,
 			readPathByCallId,
@@ -11256,6 +11528,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 					turnId,
 					attempt,
 					nextAttempt: attempt + 1,
+					maxAttempts: retryCfg.maxAttempts,
 					delayMs,
 					err: caught,
 					...meta
@@ -11271,7 +11544,7 @@ async function executeTurn(ctx, turn, priorUsage) {
 				}
 			}
 			if (!wasAborted && classified?.kind === "context_exceeded" && cleanSlate && overflowRecoveries < CONTEXT_OVERFLOW_KEEP_TURNS.length) {
-				const { readPathByCallId, toolNameByCallId } = collectCallMaps(canonicalMessages);
+				const { readPathByCallId, toolNameByCallId } = callMaps();
 				let recoveredMessages;
 				const elidedReadPaths = [];
 				for (let k = overflowRecoveries; k < CONTEXT_OVERFLOW_KEEP_TURNS.length; k++) {
@@ -12995,6 +13268,7 @@ const HOOK_EVENT_SET = /* @__PURE__ */ new Set([
 	"child:stream:server_tool_use",
 	"child:stream:server_tool_result",
 	"child:stream:error",
+	"child:stream:retry",
 	"child:tool:gate",
 	"child:mcp:tool:gate",
 	"child:tool:dispatched",
@@ -13474,10 +13748,10 @@ function installLazyDisclosureGate(hooks, lazyCanonicalNames, unlocked, discover
 * (`via: 'resume'`) for skills it newly activates. Shared by the run-start
 * resume rehydration and the mid-loop durable-replay gate below.
 */
-async function rehydrateActiveSkillsFromTurns(session, resolvedSkills, state, hooks) {
+async function rehydrateActiveSkillsFromTurns(turns, resolvedSkills, state, hooks) {
 	const skillsByName = new Map(resolvedSkills.map((s) => [s.name, s]));
 	const lastModeBySkill = /* @__PURE__ */ new Map();
-	for (const turn of session.turns) {
+	for (const turn of turns) {
 		if (turn.role !== "assistant") continue;
 		for (const block of turn.content) {
 			if (block.type !== "tool_call" || block.name !== "skills_use") continue;
@@ -13523,7 +13797,7 @@ function installSkillsActivationHydrationGate(hooks, deps) {
 		const skillName = typeof ctx.input?.name === "string" ? ctx.input.name : void 0;
 		if (!skillName || deps.state.isActive(skillName)) return;
 		try {
-			await rehydrateActiveSkillsFromTurns(session, resolvedSkills, deps.state, hooks);
+			await rehydrateActiveSkillsFromTurns(session.turns, resolvedSkills, deps.state, hooks);
 		} catch {}
 	});
 }
@@ -13941,7 +14215,8 @@ function createAgent(rawOptions) {
 		if (options.resumeRunId) {
 			if (!session) throw new Error("resumeRunId requires a session (the prior run's turns live there)");
 			if (!options.prompt) throw new Error("resumeRunId requires a prompt — pass the continuation instruction");
-			if (!session.turns.some((t) => t.runId === options.resumeRunId)) throw new Error(`resumeRunId "${options.resumeRunId}" has no persisted turns in this session — nothing to resume`);
+			const chain = resumeChainRunIds(session.runs, options.resumeRunId);
+			if (!session.turns.some((t) => t.runId !== void 0 && chain.has(t.runId))) throw new Error(`resumeRunId "${options.resumeRunId}" has no persisted turns in this session — nothing to resume`);
 		}
 		const clock = options.clock ?? agentClock ?? DEFAULT_AGENT_CLOCK;
 		let externalAbortListener;
@@ -13963,7 +14238,8 @@ function createAgent(rawOptions) {
 			session?.startRun(runId, promptLabel, {
 				...options.parentRunId ? { parentRunId: options.parentRunId } : {},
 				depth: typeof options.depth === "number" ? options.depth : 0,
-				...options.resumeRunId ? { resumedFromRunId: options.resumeRunId } : {}
+				...options.resumeRunId ? { resumedFromRunId: options.resumeRunId } : {},
+				...options.runLabel ? { label: options.runLabel } : {}
 			});
 			const sessionRun = session?.runs.find((r) => r.id === runId);
 			if (sessionRun) sessionRun.startedAt = runStartedAt;
@@ -14022,7 +14298,14 @@ function createAgent(rawOptions) {
 					});
 				}
 			});
-			if (resolvedSkills && session && session.turns.length > 0 && skillActivationState.active().length === 0) await rehydrateActiveSkillsFromTurns(session, resolvedSkills, skillActivationState, hooks);
+			if (resolvedSkills && session && session.turns.length > 0 && skillActivationState.active().length === 0) {
+				let rehydrationTurns = session.turns;
+				if (options.resumeRunId) {
+					const chain = resumeChainRunIds(session.runs, options.resumeRunId);
+					rehydrationTurns = session.turns.filter((t) => t.runId !== void 0 && chain.has(t.runId));
+				}
+				await rehydrateActiveSkillsFromTurns(rehydrationTurns, resolvedSkills, skillActivationState, hooks);
+			}
 			const thinking = options.thinking ?? "off";
 			const model = targets[0].model;
 			if (runProvider.meta?.clearsContextServerSide) resolvedBehavior.dedupReads = false;
@@ -14191,8 +14474,10 @@ 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) seededTurns = filterUnresolvedToolUses(session.turns.filter((t) => t.runId === options.resumeRunId));
-			else if (isResume) {
+			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);
@@ -15066,6 +15351,6 @@ function createAgent(rawOptions) {
 	};
 }
 //#endregion
-export { composeExtensionPreset as $, discoverExtensions as $t, ANCHOR_PREVIEW_MAX_CHARS as A, createInteractionTool as At, ExtensionInstallError as B, ensureKeybindingsFile as Bt, NO_TOOLS_PREAMBLE as C, readFile$1 as Ct, buildFullCompactPrompt as D, formatModelLine as Dt, buildFromCompactPrompt as E, createModelSearchTool as Et, truncateHeadForPtlRetry as F, resolveStorageDirs as Ft, readExtensionInstallProvenance as G, mergeKeybindings as Gt, installExtensionFromSpec as H, groupBindings as Ht, CompactInvalidInputError as I, DEFAULT_KEYBINDINGS as It, createExtensionHud as J, readKeybindingsRaw as Jt, removeInstalledExtension as K, parseBindingSpec as Kt, CompactPromptTooLongError as L, KEYBINDING_DEFS as Lt, sliceForCompaction as M, glob as Mt, stripImagesFromTurns as N, edit as Nt, buildTailCompactPrompt as O, matchModelEntries as Ot, summaryToTurn as P, validateToolArgs as Pt, buildExtensionRegistry as Q, defaultExtensionScanPaths as Qt, EMPTY_EXTENSION_REGISTRY as R, KEYBINDING_DEF_BY_ACTION as Rt, BASE_INSTRUCTIONS as S, tailTruncate as St, buildCompactPrompt as T, multiEdit as Tt, listExtensionCandidates as U, keybindingsPath as Ut, fetchExtensionSource as V, formatBindingForDisplay as Vt, parseExtensionInstallSource as W, matchesBinding as Wt, discoverAndBuildExtensionRegistry as X, stripJsonComments as Xt, registerExtensionHostModules as Y, resolveExtensionKeybindings as Yt, buildExtensionPreset as Z, ENTRY_CANDIDATES as Zt, buildPostCompactAttachments as _, defaultRepeatGuardNormalize as _n, createSkillsRunScriptTool as _t, SHELL_CASCADE_CANCEL_MESSAGE as a, clampExtensionConfigNumber as an, createWorkspaceSurface as at, selectRecentFiles as b, stableStringify as bn, createShellTool as bt, applyCompactSummaryCutoff as c, isValidExtensionConfigValue as cn, basicTools as ct, buildPersistedStub as d, sanitizeExtensionConfigActionPatch as dn, WAIT_TASK_TIMED_OUT_PREFIX as dt, inlineLoadedExtension as en, disposeExtensionRegistry as et, cleanupPersistedSession as f, toWireConfigSchema as fn, waitTask as ft, resolveTasksDir as g, shouldAutoCompact as gn, createSkillsUseTool as gt, resolvePersistDir as h, effectiveContextWindow as hn, isSpawnTool as ht, INTERRUPT_MESSAGE_FOR_TOOL_USE as i, defineExtension as in, createExtensionHostRuntimeBridge as it, anchorPreviewFor as j, grep as jt, buildUpToCompactPrompt as k, listFiles as kt, PERSISTED_STUB_PREFIX as l, resolveExtensionConfig as ln, basic_default as lt, resolveMcpWarningsDir as m, OUTPUT_RESERVE_TOKENS as mn, createSpawnTool as mt, normalizeProviders as n, parseExtensionScanPathEnv as nn, mergeContributions as nt, TOOL_USE_CANCELLED_MESSAGE as o, coerceExtensionConfigInput as on, composePresets as ot, maybePersistToolResult as p, AUTO_COMPACT_MIN_GROWTH_FRACTION as pn, createToolSearchTool as pt, updateInstalledExtension as q, readKeybindings as qt, resolveModelTargets as r, scanExtensionDirectories as rn, partitionExtensionCatalog as rt, TOOL_USE_SKIPPED_MESSAGE as s, isValidExtensionConfigItem as sn, definePreset as st, createAgent as t, isExtensionDefinition as tn, filterExtensionRegistry as tt, PERSISTENCE_PREVIEW_BYTES as u, resolveExtensionConfigValue as un, writeFile$1 as ut, selectFilesFromReadState as v, defaultRepeatGuardTracked as vn, createSkillsReadTool as vt, TRAILER as w, looksBinary as wt, compactConversation as x, shell as xt, selectFilesFromSession as y, normalizeShellCommand as yn, shellKill as yt, createExtensionPromptBridge as z, KEYBINDING_KEY_COL_WIDTH as zt };
+export { buildExtensionRegistry as $, defaultExtensionScanPaths as $t, buildUpToCompactPrompt as A, listFiles as At, createExtensionPromptBridge as B, KEYBINDING_KEY_COL_WIDTH as Bt, BASE_INSTRUCTIONS as C, tailTruncate as Ct, buildFromCompactPrompt as D, createModelSearchTool as Dt, buildCompactPrompt as E, multiEdit as Et, summaryToTurn as F, validateToolArgs as Ft, parseExtensionInstallSource as G, matchesBinding as Gt, fetchExtensionSource as H, formatBindingForDisplay as Ht, truncateHeadForPtlRetry as I, resolveStorageDirs as It, updateInstalledExtension as J, readKeybindings as Jt, readExtensionInstallProvenance as K, mergeKeybindings as Kt, CompactInvalidInputError as L, DEFAULT_KEYBINDINGS as Lt, anchorPreviewFor as M, grep as Mt, sliceForCompaction as N, glob as Nt, buildFullCompactPrompt as O, formatModelLine as Ot, stripImagesFromTurns as P, edit as Pt, buildExtensionPreset as Q, ENTRY_CANDIDATES as Qt, CompactPromptTooLongError as R, KEYBINDING_DEFS as Rt, compactConversation as S, shell as St, TRAILER as T, looksBinary as Tt, installExtensionFromSpec as U, groupBindings as Ut, ExtensionInstallError as V, ensureKeybindingsFile as Vt, listExtensionCandidates as W, keybindingsPath as Wt, registerExtensionHostModules as X, resolveExtensionKeybindings as Xt, createExtensionHud as Y, readKeybindingsRaw as Yt, discoverAndBuildExtensionRegistry as Z, stripJsonComments as Zt, resolveTasksDir as _, shouldAutoCompact as _n, createSkillsUseTool as _t, SHELL_CASCADE_CANCEL_MESSAGE as a, defineExtension as an, createExtensionHostRuntimeBridge as at, selectFilesFromSession as b, normalizeShellCommand as bn, shellKill as bt, applyCompactSummaryCutoff as c, isValidExtensionConfigItem as cn, definePreset as ct, buildPersistedStub as d, resolveExtensionConfigValue as dn, writeFile$1 as dt, discoverExtensions as en, composeExtensionPreset as et, cleanupPersistedSession as f, sanitizeExtensionConfigActionPatch as fn, WAIT_TASK_TIMED_OUT_PREFIX as ft, resolvePersistDir as g, effectiveContextWindow as gn, isSpawnTool as gt, resolveMcpWarningsDir as h, OUTPUT_RESERVE_TOKENS as hn, createSpawnTool as ht, INTERRUPT_MESSAGE_FOR_TOOL_USE as i, scanExtensionDirectories as in, partitionExtensionCatalog as it, ANCHOR_PREVIEW_MAX_CHARS as j, createInteractionTool as jt, buildTailCompactPrompt as k, matchModelEntries as kt, PERSISTED_STUB_PREFIX as l, isValidExtensionConfigValue as ln, basicTools as lt, rehomePersistedStubs as m, AUTO_COMPACT_MIN_GROWTH_FRACTION as mn, createToolSearchTool as mt, normalizeProviders as n, isExtensionDefinition as nn, filterExtensionRegistry as nt, TOOL_USE_CANCELLED_MESSAGE as o, clampExtensionConfigNumber as on, createWorkspaceSurface as ot, maybePersistToolResult as p, toWireConfigSchema as pn, waitTask as pt, removeInstalledExtension as q, parseBindingSpec as qt, resolveModelTargets as r, parseExtensionScanPathEnv as rn, mergeContributions as rt, TOOL_USE_SKIPPED_MESSAGE as s, coerceExtensionConfigInput as sn, composePresets as st, createAgent as t, inlineLoadedExtension as tn, disposeExtensionRegistry as tt, PERSISTENCE_PREVIEW_BYTES as u, resolveExtensionConfig as un, basic_default as ut, buildPostCompactAttachments as v, defaultRepeatGuardNormalize as vn, createSkillsRunScriptTool as vt, NO_TOOLS_PREAMBLE as w, readFile$1 as wt, selectRecentFiles as x, stableStringify as xn, createShellTool as xt, selectFilesFromReadState as y, defaultRepeatGuardTracked as yn, createSkillsReadTool as yt, EMPTY_EXTENSION_REGISTRY as z, KEYBINDING_DEF_BY_ACTION as zt };
 
-//# sourceMappingURL=agent-BSIMsEtD.js.map
+//# sourceMappingURL=agent--VPMZ0nT.js.map