better-dsh 0.2.2-c → 0.2.3-b

package/lib/index.js

@@ -2556,15 +2556,15 @@ const here = path.dirname(fileURLToPath(import.meta.url));
 /** `require` anchored at this module — used to dlopen absolute `.node` paths. */
 const requireHere = createRequire(import.meta.url);
 /**
-* Locate the leaf package directory: first via `require.resolve` from
-* `fromDir` (honors the usual node_modules walk), then via an explicit
-* node_modules-walk upward from `fromDir`. Returns `undefined` when absent.
+* Locate the leaf package directory with an explicit node_modules-walk upward
+* from `fromDir` — the ONLY mechanism. `require.resolve` is deliberately not
+* used here: its fallback through the process global paths (which include the
+* pnpm virtual-store hoist root `.pnpm/node_modules`) can resolve the leaf
+* package from ANY anchor, defeating the anchor-bounded contract this loader
+* guarantees for its degradation tests and unsupported-platform probes.
+* Returns `undefined` when absent.
 */
 function findPackageDir(packageName, fromDir) {
-	try {
-		const manifest = createRequire(path.join(fromDir, "noop.js")).resolve(`${packageName}/package.json`);
-		return path.dirname(manifest);
-	} catch {}
 	let dir = fromDir;
 	for (;;) {
 		const candidate = path.join(dir, "node_modules", packageName);
@@ -5166,7 +5166,7 @@ async function renderRoster(family, descendants, agents) {
 /** One child's last activity: its live log's last event, else its persisted one. */
 async function lastActivityOf(rawId, family) {
 	const live = family.sessions.get(SessionId(rawId));
-	if (live !== void 0) return lastEventTime(live.events);
+	if (live !== void 0) return lastEventTime(live.snapshotEvents());
 	const inspection = await family.sessionPersistence.inspect(SessionId(rawId));
 	return inspection === void 0 ? "-" : lastEventTime(inspection.events);
 }
@@ -5941,7 +5941,7 @@ function createGrepTool(deps) {
 const MAX_BYTES = 100 * 1024 * 1024;
 const MAX_READ_LINE_BYTES = 200 * 1024;
 const HASH_STORE_BUSY_TIMEOUT = 1e3;
-const HASH_STORE_VERSION = 6;
+const HASH_STORE_VERSION = 7;
 const EDITS_MAX_ITEMS = 32;
 const SERVED_TTL_MS = 10080 * 60 * 1e3;
 const SERVED_ECHO_CAP = 150;
@@ -6095,20 +6095,18 @@ function assertUndoRequest(request) {
 //#endregion
 //#region src/url-schema/vendored/hashline/paths.js
 /**
-* On-disk home for dsh-better-edit state. Inside a tool call the store lives
-* co-located with the files being edited: `<workspace>/.dsh_better_edit/` (the
-* workspace is the session cwd, carried through the execution by
-* `withWorkspace`). Outside a tool call — tests, previews, startup — the store
-* falls back to the shared DeepSeek Harness home
-* (`$DSH_HOME/plugins/dsh-better-edit`, default `~/.dsh/plugins/dsh-better-edit`),
-* so a caller without a workspace never writes into an arbitrary cwd.
-* @param cwd - the workspace root, or undefined for the shared-home fallback.
+* On-disk home for dsh-better-edit state: ONE centralized store per harness
+* home — `$DSH_HOME/storages/dsh-better-edit` (default
+* `~/.dsh/storages/dsh-better-edit`), resolved through the harness home
+* resolver so `DSH_HOME` isolates deployments (test homes never touch prod).
+* There is no per-workspace state directory: the store keys everything by
+* canonical absolute path.
 */
-function configDir(cwd) {
-	return cwd !== void 0 ? join(resolve(cwd), ".dsh_better_edit") : join(resolveDshHome(), "plugins", "dsh-better-edit");
+function configDir() {
+	return join(resolveDshHome(), "storages", "dsh-better-edit");
 }
-function hashStorePath(cwd) {
-	return join(configDir(cwd), "hash-store.sqlite");
+function hashStorePath() {
+	return join(configDir(), "hash-store.sqlite");
 }
 
 //#endregion
@@ -6330,769 +6328,655 @@ function mapStableHashes(oldContent, oldHashes, newContent, removedHashes) {
 }
 
 //#endregion
-//#region src/url-schema/vendored/hashline/hashline/anchor-pipeline.js
-function diagRef(ref) {
-	const trimmed = ref.trim();
-	if (!trimmed.length) return `[E_BAD_REF] Invalid anchor. Expected a 3-char alphanumeric anchor (e.g. "aB3").`;
-	if (/^\d+/.test(trimmed)) return `[E_BAD_REF] Invalid anchor. Use the hash alone (e.g. "aB3") — no line numbers or trailing content.`;
-	if (trimmed.includes("│")) return `[E_BAD_REF] Invalid anchor "${trimmed}". remove_from and remove_to must contain the 3-char hash only — remove everything from "│" onward.`;
-	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 3-char alphanumeric anchor (e.g. "aB3").`;
-}
-function parseRef(ref) {
-	const trimmed = ref.trim();
-	if (trimmed.length === ANCHOR_LEN && ALPH_RE.test(trimmed)) return { hash: trimmed };
-	throw new Error(diagRef(ref));
+//#region src/url-schema/vendored/hashline/hash-store.js
+function isValidHashList(value) {
+	if (!Array.isArray(value)) return false;
+	for (const hash of value) if (typeof hash !== "string" || !HASH_RE.test(hash)) return false;
+	return true;
 }
-const parseHashRef = parseRef;
-function parseText(edit) {
-	if (typeof edit !== "string") throw new Error(NEW_CONTENT_NOT_STRING_MSG);
-	const normalized = edit.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
-	if (normalized === "") return [];
-	if (/^\n+$/.test(normalized)) return new Array(normalized.length).fill("");
-	return normalized.split("\n");
+function isValidSnapshot(value) {
+	if (typeof value !== "object" || value === null) return false;
+	const v = value;
+	if (typeof v.content !== "string") return false;
+	return isValidHashList(v.hashes);
 }
-function resAnchorFromMap(ref, hashIndex) {
-	const hashMatches = hashIndex.get(ref.hash);
-	if (!hashMatches || hashMatches.length === 0) return {
-		ref,
-		kind: "not_found"
-	};
-	if (hashMatches.length === 1) return {
-		line: hashMatches[0],
-		hash: ref.hash,
-		hashMatched: true
-	};
-	return {
-		ref,
-		kind: "ambiguous",
-		candidates: hashMatches
-	};
+/** A served-row array: per-position hash, or null for never-served slots. */
+function isValidServedList(value) {
+	if (!Array.isArray(value)) return false;
+	for (const entry of value) {
+		if (entry === null) continue;
+		if (typeof entry !== "string" || !HASH_RE.test(entry)) return false;
+	}
+	return true;
 }
-function assertAligned(fileLines, fileHashes, ctx) {
-	if (fileHashes.length !== fileLines.length) throw new Error(`${ctx}: fileHashes.length (${fileHashes.length}) must match fileLines.length (${fileLines.length}).`);
+function cacheKey(checksum) {
+	return `${CANON_VERSION}:${checksum}`;
 }
-function fmtMismatchWithServes(mismatches, fileLines, fileHashes, filePath) {
-	assertAligned(fileLines, fileHashes, "fmtMismatch");
-	const out = [];
-	const servedRows = [];
-	const seen = /* @__PURE__ */ new Set();
-	const pushRow = (ln) => {
-		if (ln < 1 || ln > fileLines.length) return;
-		const position = ln - 1;
-		if (seen.has(position)) return;
-		seen.add(position);
-		servedRows.push({
-			position,
-			hash: fileHashes[ln - 1]
-		});
-	};
-	const notFound = mismatches.filter((m) => m.kind === "not_found");
-	const ambiguous = mismatches.filter((m) => m.kind === "ambiguous");
-	const refList = notFound.map((m) => `"${m.ref.hash}"`).join(", ");
-	if (notFound.length > 0) {
-		out.push(`[E_STALE_ANCHOR] ${notFound.length} stale anchor${notFound.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}: ${refList}. Re-read for fresh anchors.`);
-		for (const m of notFound) {
-			const ctx = m.context;
-			if (!ctx) continue;
-			const from = Math.max(1, ctx.line - 1);
-			const to = Math.min(fileLines.length, ctx.line + 1);
-			const rows = [];
-			for (let ln = from; ln <= to; ln++) {
-				rows.push(`    ${ln}: ${fileHashes[ln - 1]}│${clipLine(fileLines[ln - 1] ?? "")}`);
-				pushRow(ln);
-			}
-			out.push("");
-			out.push(`  Current context around resolved anchor "${ctx.hash}" (line ${ctx.line}):\n${rows.join("\n")}`);
-		}
+function isCorruptionError(error) {
+	if (error && typeof error === "object") {
+		const errcode = error.errcode;
+		if (typeof errcode === "number") return errcode === 11 || errcode === 24 || errcode === 26;
+		const code = error.code;
+		if (typeof code === "string" && /NOTADB|CORRUPT/.test(code)) return true;
 	}
-	if (ambiguous.length > 0) {
-		if (out.length > 0) out.push("");
-		out.push(`[E_AMBIGUOUS_ANCHOR] ${ambiguous.length} ambiguous anchor${ambiguous.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}. Re-read for fresh anchors.`);
-		for (const m of ambiguous) {
-			const sample = (m.candidates ?? []).slice(0, 5);
-			const more = (m.candidates?.length ?? 0) > sample.length ? `, ... (+${(m.candidates?.length ?? 0) - sample.length} more)` : "";
-			const lines = sample.map((line) => {
-				const content = clipLine(fileLines[line - 1] ?? "");
-				pushRow(line);
-				return `    ${line}: ${fileHashes[line - 1]}│${content}`;
-			}).join("\n");
-			out.push(`  Hash "${m.ref.hash}" matches lines ${sample.join(", ")}${more}.\n${lines}`);
-		}
+	return error instanceof Error && /corrupt|not a database|malformed|database disk image/i.test(error.message);
+}
+function isBusyError(error) {
+	if (error && typeof error === "object") {
+		const errcode = error.errcode;
+		if (typeof errcode === "number") return errcode === 5 || errcode === 6;
 	}
-	return {
-		message: out.join("\n"),
-		servedRows
-	};
+	return error instanceof Error && /busy|locked/i.test(error.message);
 }
-const ITEM_KS = new Set([
-	"replacement_text",
-	"remove_from",
-	"remove_to"
-]);
-function assertItem(edit) {
-	rejectUnknownFields(edit, ITEM_KS, "Edit", "The edit takes only { replacement_text, remove_from, remove_to }.");
-	if ("remove_from" in edit && typeof edit.remove_from !== "string") throw new Error(`[E_BAD_SHAPE] Field "remove_from" must be an anchor string (3-char hash).`);
-	if ("remove_to" in edit && typeof edit.remove_to !== "string") throw new Error(`[E_BAD_SHAPE] Field "remove_to" must be an anchor string (3-char hash).`);
-	if (!("replacement_text" in edit)) throw new Error(`[E_BAD_SHAPE] The edit requires a "replacement_text" field. Provide the replacement text (use "" to delete).`);
-	if (typeof edit.replacement_text !== "string") throw new Error(NEW_CONTENT_NOT_STRING_MSG);
-	if (typeof edit.remove_from !== "string" || typeof edit.remove_to !== "string") throw new Error(`[E_BAD_SHAPE] The edit requires "remove_from" and "remove_to" anchor strings (3-char hashes from read output).`);
+function sleepSync(ms) {
+	const sab = new Int32Array(new SharedArrayBuffer(4));
+	Atomics.wait(sab, 0, 0, ms);
 }
-const ANCHOR_ROW_RE = /* @__PURE__ */ new RegExp(`^([+-]?)(${HASH_CLASS})│`);
-function resEdit(edit, warnings) {
-	assertItem(edit);
-	const editLines = parseText(edit.replacement_text);
-	const bounds = [edit.remove_from, edit.remove_to].map((ref) => {
-		const trimmed = ref.trim();
-		const match = trimmed.match(ANCHOR_ROW_RE);
-		if (match) {
-			let message;
-			if (match[1] === "+") message = `[E_BAD_REF] stripped diff-preview marker from remove_from/remove_to "${trimmed}".`;
-			else if (match[1] === "-") message = `[E_BAD_REF] stripped leading "-" marker from remove_from/remove_to "${trimmed}".`;
-			else message = `[E_BAD_REF] stripped "HASH│" prefix from remove_from/remove_to "${trimmed}".`;
-			warnings?.push(message);
-			return match[2];
-		}
-		return ref;
-	});
-	return {
-		content_lines: editLines,
-		hash_bounds: [parseHashRef(bounds[0]), parseHashRef(bounds[1])]
-	};
+const BUSY_RETRIES = 3;
+const BUSY_RETRY_DELAY_MS = 100;
+function withBusyRetry(fn) {
+	let lastError;
+	for (let attempt = 0; attempt <= BUSY_RETRIES; attempt++) try {
+		return fn();
+	} catch (error) {
+		lastError = error;
+		if (!isBusyError(error) || attempt === BUSY_RETRIES) throw error;
+		sleepSync(BUSY_RETRY_DELAY_MS);
+	}
+	throw lastError;
 }
-function warnUnicodeEsc(edit, warnings) {
-	if (edit.content_lines.some((line) => /\\uDDDD/i.test(line))) warnings.push("Detected literal \\uDDDD in edit content; no autocorrection applied. Verify whether this should be a real Unicode escape or plain text.");
+function openDbWithBusyRetry(storePath) {
+	return withBusyRetry(() => openDb(storePath));
 }
-/** @internal — private to anchor-pipeline seam; do not import directly, use anchor-pipeline.ts */
-function stripBarePrefixes(edit, fileHashes, warnings) {
-	const fileHashSet = new Set(fileHashes);
-	const stripped = [];
-	const contentLines = edit.content_lines.map((line, lineIndex) => {
-		const match = line.match(HL_BARE_PREFIX_RE);
-		if (!match) return line;
-		stripped.push({
-			lineIndex,
-			matched: fileHashSet.has(match[1])
-		});
-		return line.slice(match[0].length);
-	});
-	if (stripped.length === 0) return edit;
-	const locations = stripped.map((s) => `replacement_text line ${s.lineIndex + 1}`).join(", ");
-	const matchedCount = stripped.filter((s) => s.matched).length;
-	const evidence = matchedCount === 0 ? "0 matched — verify literal 'HASH│' content" : `${matchedCount}/${stripped.length} matched`;
-	warnings.push(`[E_BARE_HASH_PREFIX] stripped "HASH│" prefix from ${locations} (${evidence}).`);
-	return {
-		...edit,
-		content_lines: contentLines
-	};
+/** One open store per store path (per workspace); parallel sessions share per-workspace dbs. */
+const stores = /* @__PURE__ */ new Map();
+const openings = /* @__PURE__ */ new Map();
+let exitHandlerRegistered = false;
+function openDb(storePath) {
+	const db = new DatabaseSync(storePath, { timeout: HASH_STORE_BUSY_TIMEOUT });
+	try {
+		return buildStore(db);
+	} catch (error) {
+		try {
+			db.close();
+		} catch {}
+		throw error;
+	}
 }
-/** @internal — private to anchor-pipeline seam */
-function stripDiffPrefixes(edit, warnings) {
-	const stripped = [];
-	const contentLines = edit.content_lines.map((line, lineIndex) => {
-		const plus = line.match(HL_PREFIX_PLUS_RE);
-		if (plus) {
-			stripped.push(lineIndex);
-			return line.slice(plus[0].length);
-		}
-		const minus = line.match(HL_PREFIX_MINUS_RE);
-		if (minus) {
-			stripped.push(lineIndex);
-			return line.slice(minus[0].length);
-		}
-		return line;
-	});
-	if (stripped.length === 0) return edit;
-	const locations = stripped.map((i) => `replacement_text line ${i + 1}`).join(", ");
-	warnings.push(`[E_INVALID_PATCH] stripped diff-preview marker from ${locations}.`);
+function buildStore(db) {
+	db.exec("PRAGMA journal_mode = WAL");
+	db.exec("PRAGMA synchronous = NORMAL");
+	db.exec("CREATE TABLE IF NOT EXISTS snapshots (path TEXT PRIMARY KEY, checksum TEXT NOT NULL, line_count INTEGER NOT NULL, hashes TEXT NOT NULL, updated_at INTEGER NOT NULL)");
+	db.exec("CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
+	db.exec("CREATE TABLE IF NOT EXISTS undo (path TEXT PRIMARY KEY, content TEXT NOT NULL, bom TEXT NOT NULL, ending TEXT NOT NULL, hashes TEXT NOT NULL, result_content TEXT NOT NULL, updated_at INTEGER NOT NULL)");
+	const versionRow = db.prepare("SELECT value FROM meta WHERE key = 'version'").get();
+	const versionChanged = versionRow !== void 0 && versionRow.value !== String(HASH_STORE_VERSION);
+	if (versionChanged) {
+		db.exec("DELETE FROM snapshots");
+		db.exec("DELETE FROM undo");
+	}
+	const servedColumns = db.prepare("PRAGMA table_info(served)").all();
+	if (versionChanged || servedColumns.some((column) => column.name === "session_id")) db.exec("DROP TABLE IF EXISTS served");
+	db.exec("CREATE TABLE IF NOT EXISTS served (path TEXT NOT NULL PRIMARY KEY, hashes TEXT NOT NULL, reported TEXT, updated_at INTEGER NOT NULL)");
+	db.prepare("INSERT INTO meta (key, value) VALUES ('version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(String(HASH_STORE_VERSION));
+	const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
+	const allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo UNION SELECT path FROM served");
+	const allHashesStmt = db.prepare("SELECT path, hashes FROM snapshots");
+	const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
+	const upsertStmt = db.prepare("INSERT INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?) ON CONFLICT(path) DO UPDATE SET checksum = excluded.checksum, line_count = excluded.line_count, hashes = excluded.hashes, updated_at = excluded.updated_at");
+	const undoUpsertStmt = db.prepare("INSERT INTO undo (path, content, bom, ending, hashes, result_content, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(path) DO UPDATE SET content = excluded.content, bom = excluded.bom, ending = excluded.ending, hashes = excluded.hashes, result_content = excluded.result_content, updated_at = excluded.updated_at");
+	const undoGetStmt = db.prepare("SELECT content, bom, ending, hashes, result_content FROM undo WHERE path = ?");
+	const undoDelStmt = db.prepare("DELETE FROM undo WHERE path = ?");
+	const servedGetStmt = db.prepare("SELECT hashes, reported FROM served WHERE path = ?");
+	const servedUpsertStmt = db.prepare("INSERT INTO served (path, hashes, updated_at) VALUES (?, ?, ?) ON CONFLICT(path) DO UPDATE SET hashes = excluded.hashes, updated_at = excluded.updated_at");
+	const servedReportedUpsertStmt = db.prepare("INSERT INTO served (path, hashes, reported, updated_at) VALUES (?, '[]', ?, ?) ON CONFLICT(path) DO UPDATE SET reported = excluded.reported, updated_at = excluded.updated_at");
+	const servedReportedClearStmt = db.prepare("UPDATE served SET reported = NULL, updated_at = ? WHERE path = ?");
+	const servedDeleteStmt = db.prepare("DELETE FROM served WHERE path = ?");
+	const servedDeletePathStmt = db.prepare("DELETE FROM served WHERE path = ?");
+	const servedPruneOlderThanStmt = db.prepare("DELETE FROM served WHERE updated_at < ?");
 	return {
-		...edit,
-		content_lines: contentLines
-	};
+		db,
+		stmts: {
+			get: (...params) => getStmt.get(...params),
+			allPaths: (...params) => allStmt.all(...params),
+			allHashes: (...params) => allHashesStmt.all(...params),
+			deleteOne: (...params) => {
+				withBusyRetry(() => {
+					delStmt.run(...params);
+				});
+			},
+			upsert: (...params) => {
+				withBusyRetry(() => {
+					upsertStmt.run(...params);
+				});
+			},
+			undoUpsert: (...params) => {
+				withBusyRetry(() => {
+					undoUpsertStmt.run(...params);
+				});
+			},
+			undoGet: (...params) => undoGetStmt.get(...params),
+			undoDelete: (...params) => {
+				withBusyRetry(() => {
+					undoDelStmt.run(...params);
+				});
+			},
+			servedGet: (...params) => servedGetStmt.get(...params),
+			servedUpsert: (...params) => {
+				withBusyRetry(() => {
+					servedUpsertStmt.run(...params);
+				});
+			},
+			servedReportedUpsert: (...params) => {
+				withBusyRetry(() => {
+					servedReportedUpsertStmt.run(...params);
+				});
+			},
+			servedReportedClear: (path$1) => {
+				withBusyRetry(() => {
+					servedReportedClearStmt.run(Date.now(), path$1);
+				});
+			},
+			servedDelete: (...params) => {
+				withBusyRetry(() => {
+					servedDeleteStmt.run(...params);
+				});
+			},
+			servedDeletePath: (...params) => {
+				withBusyRetry(() => {
+					servedDeletePathStmt.run(...params);
+				});
+			},
+			servedPruneOlderThan: (...params) => {
+				withBusyRetry(() => {
+					servedPruneOlderThanStmt.run(...params);
+				});
+			}
+		}
+	};
 }
-/** @internal — private to anchor-pipeline seam */
-function swapReversedRanges(edit, fileHashes, warnings) {
-	const lineByHash = /* @__PURE__ */ new Map();
-	for (let i = 0; i < fileHashes.length; i++) lineByHash.set(fileHashes[i], i + 1);
-	const [startRef, endRef] = edit.hash_bounds;
-	const startLine = lineByHash.get(startRef.hash);
-	const endLine = lineByHash.get(endRef.hash);
-	if (startLine === void 0 || endLine === void 0 || startLine <= endLine) return edit;
-	warnings.push(`[E_BAD_OP] reversed remove_from/remove_to (${startRef.hash} after ${endRef.hash}); swapped.`);
+/** Wire the domain methods over the prepared statements. */
+function makeDomainStore(stmts) {
 	return {
-		...edit,
-		hash_bounds: [endRef, startRef]
+		engine: "node:sqlite",
+		getSnapshot(path$1, content, deleteCorrupt = true) {
+			const checksum = cacheKey(contentChecksum(content));
+			const lineCount = splitLines(content).length;
+			const row = stmts.get(path$1, checksum, lineCount);
+			if (!row) return void 0;
+			try {
+				const parsed = JSON.parse(row.hashes);
+				if (isValidHashList(parsed)) return parsed;
+				if (deleteCorrupt) stmts.deleteOne(path$1);
+				return;
+			} catch {
+				if (deleteCorrupt) stmts.deleteOne(path$1);
+				return;
+			}
+		},
+		upsertSnapshot(path$1, checksum, lineCount, hashes) {
+			stmts.upsert(path$1, cacheKey(checksum), lineCount, JSON.stringify(hashes), Date.now());
+		},
+		allKnownPaths() {
+			return stmts.allPaths();
+		},
+		allSnapshotHashes() {
+			return stmts.allHashes();
+		},
+		deleteSnapshot(path$1) {
+			stmts.deleteOne(path$1);
+		},
+		findSnapshotPaths(hashes) {
+			const rows = stmts.allHashes();
+			const matches = [];
+			for (const row of rows) try {
+				const parsed = JSON.parse(row.hashes);
+				if (!isValidHashList(parsed)) continue;
+				if (hashes.every((h) => parsed.includes(h))) matches.push(row.path);
+			} catch {}
+			return matches;
+		},
+		getUndo(path$1) {
+			const row = stmts.undoGet(path$1);
+			if (!row) return void 0;
+			try {
+				const parsed = JSON.parse(row.hashes);
+				if (!isValidHashList(parsed)) {
+					stmts.undoDelete(path$1);
+					return;
+				}
+				return {
+					content: row.content,
+					bom: row.bom,
+					ending: row.ending,
+					hashes: parsed,
+					resultContent: row.result_content
+				};
+			} catch {
+				stmts.undoDelete(path$1);
+				return;
+			}
+		},
+		upsertUndo(path$1, entry) {
+			stmts.undoUpsert(path$1, entry.content, entry.bom, entry.ending, JSON.stringify(entry.hashes), entry.resultContent, Date.now());
+		},
+		deleteUndo(path$1) {
+			stmts.undoDelete(path$1);
+		},
+		getServed(path$1) {
+			const row = stmts.servedGet(path$1);
+			if (!row) return [];
+			try {
+				const parsed = JSON.parse(row.hashes);
+				if (isValidServedList(parsed)) return parsed;
+				stmts.servedDelete(path$1);
+				return [];
+			} catch {
+				stmts.servedDelete(path$1);
+				return [];
+			}
+		},
+		getServedReported(path$1) {
+			const row = stmts.servedGet(path$1);
+			if (!row) return /* @__PURE__ */ new Set();
+			const raw = row.reported;
+			if (typeof raw !== "string" || raw.length === 0) return /* @__PURE__ */ new Set();
+			try {
+				const parsed = JSON.parse(raw);
+				if (!Array.isArray(parsed)) return /* @__PURE__ */ new Set();
+				return new Set(parsed.filter((h) => typeof h === "string" && HASH_RE.test(h)));
+			} catch {
+				return /* @__PURE__ */ new Set();
+			}
+		},
+		upsertServed(path$1, hashesJson) {
+			stmts.servedUpsert(path$1, hashesJson, Date.now());
+		},
+		upsertServedReported(path$1, reportedJson) {
+			stmts.servedReportedUpsert(path$1, reportedJson, Date.now());
+		},
+		clearServedReported(path$1) {
+			stmts.servedReportedClear(path$1);
+		},
+		deleteServed(path$1) {
+			stmts.servedDelete(path$1);
+		},
+		deleteServedByPath(path$1) {
+			stmts.servedDeletePath(path$1);
+		},
+		pruneServedOlderThan(ts) {
+			stmts.servedPruneOlderThan(ts);
+		},
+		async pruneMissing() {
+			const missing = await statMissing(stmts.allPaths());
+			if (missing.length === 0) return;
+			withStore(() => {
+				for (const path$1 of missing) {
+					stmts.deleteOne(path$1);
+					stmts.undoDelete(path$1);
+					stmts.servedDeletePath(path$1);
+				}
+			});
+		}
 	};
 }
-function trailingDups(contentLines, fileLines, endLine) {
-	const start = lastNonEmptyIndex(contentLines);
-	if (start < 0) return [];
-	const dups = [];
-	const maxK = Math.min(start + 1, fileLines.length - endLine);
-	for (let k = 0; k < maxK; k++) {
-		if (contentLines[start - k] !== fileLines[endLine + k]) break;
-		dups.push({
-			kind: "trailing",
-			replacementLineIndex: start - k
-		});
+function isHealthy(db) {
+	try {
+		return db.prepare("PRAGMA quick_check").get()?.quick_check === "ok";
+	} catch (error) {
+		if (isCorruptionError(error)) return false;
+		return true;
 	}
-	return dups;
 }
-function leadingDups(contentLines, fileLines, startLine) {
-	const start = firstNonEmptyIndex(contentLines);
-	if (start < 0) return [];
-	const dups = [];
-	const maxK = Math.min(contentLines.length - start, startLine - 1);
-	for (let k = 0; k < maxK; k++) {
-		if (contentLines[start + k] !== fileLines[startLine - 2 - k]) break;
-		dups.push({
-			kind: "leading",
-			replacementLineIndex: start + k
-		});
+async function quarantineStore(storePath) {
+	const suffix = `.corrupt-${Date.now()}`;
+	for (const candidate of [
+		storePath,
+		`${storePath}-wal`,
+		`${storePath}-shm`
+	]) try {
+		await rename(candidate, `${candidate}${suffix}`);
+	} catch (error) {
+		if (errCode(error) !== "ENOENT") console.error("Failed to quarantine corrupt hash store file:", error);
 	}
-	return dups;
 }
-function sectionIsUnique(canonLines, start, length) {
-	let count = 0;
-	for (let i = 0; i + length <= canonLines.length; i++) {
-		let k = 0;
-		while (k < length && canonLines[i + k] === canonLines[start + k]) k++;
-		if (k < length) continue;
-		count++;
-		if (count > 1) return false;
+function shutdownDb(db) {
+	try {
+		db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+	} catch {}
+	db.close();
+}
+const STAT_BATCH = 64;
+async function statMissing(rows) {
+	const missing = [];
+	for (let i = 0; i < rows.length; i += STAT_BATCH) {
+		const batch = rows.slice(i, i + STAT_BATCH);
+		const results = await Promise.all(batch.map(async (row) => {
+			try {
+				await stat(row.path);
+				return;
+			} catch {
+				return row.path;
+			}
+		}));
+		for (const path$1 of results) if (path$1 !== void 0) missing.push(path$1);
 	}
-	return true;
+	return missing;
 }
-function firstNewAfterDups(contentLines, rangeLines, canonLines, endLine) {
-	const firstNew = findNewEdge(contentLines, rangeLines, false);
-	if (!firstNew) return [];
-	const maxK = Math.min(contentLines.length - firstNew.index, canonLines.length - endLine);
-	let runLen = 0;
-	while (runLen < maxK && canon(contentLines[firstNew.index + runLen]) === canonLines[endLine + runLen]) runLen++;
-	if (runLen === 0 || !sectionIsUnique(canonLines, endLine, runLen)) return [];
-	const dups = [];
-	for (let k = 0; k < runLen; k++) dups.push({
-		kind: "first-new-after",
-		replacementLineIndex: firstNew.index + k
+async function openStore(storePath) {
+	await initHasher();
+	await mkdir(dirname(storePath), { recursive: true });
+	let existed = existsSync(storePath);
+	let opened;
+	try {
+		opened = openDbWithBusyRetry(storePath);
+	} catch (error) {
+		if (!isCorruptionError(error)) throw error;
+		console.error("Hash store failed to open, rebuilding:", error);
+		await quarantineStore(storePath);
+		existed = false;
+		opened = openDbWithBusyRetry(storePath);
+	}
+	if (!isHealthy(opened.db)) {
+		shutdownDb(opened.db);
+		await quarantineStore(storePath);
+		existed = false;
+		opened = openDbWithBusyRetry(storePath);
+	}
+	const { db, stmts } = opened;
+	if (!existed) await migrateLegacy(db, storePath);
+	withBusyRetry(() => {
+		stmts.servedPruneOlderThan(Date.now() - SERVED_TTL_MS);
 	});
-	return dups;
+	const store = makeDomainStore(stmts);
+	stores.set(storePath, {
+		path: storePath,
+		db,
+		stmts,
+		store
+	});
+	if (!exitHandlerRegistered) {
+		exitHandlerRegistered = true;
+		process.once("exit", () => shutdownHashStore());
+		for (const sig of ["SIGINT", "SIGTERM"]) process.once(sig, () => {
+			shutdownHashStore();
+			process.kill(process.pid, sig);
+		});
+	}
+	return store;
 }
-function lastNewBeforeDups(contentLines, rangeLines, canonLines, startLine) {
-	const lastNew = findNewEdge(contentLines, rangeLines, true);
-	if (!lastNew) return [];
-	const maxK = Math.min(lastNew.index + 1, startLine - 1);
-	let runLen = 0;
-	while (runLen < maxK && canon(contentLines[lastNew.index - runLen]) === canonLines[startLine - 2 - runLen]) runLen++;
-	if (runLen === 0) return [];
-	if (!sectionIsUnique(canonLines, startLine - 1 - runLen, runLen)) return [];
-	const dups = [];
-	for (let k = 0; k < runLen; k++) dups.push({
-		kind: "last-new-before",
-		replacementLineIndex: lastNew.index - k
+/** Resolve the store path: the single centralized store under `$DSH_HOME/storages`. */
+function storePathFor() {
+	return hashStorePath();
+}
+/**
+* Load (and cache) the centralized hash store. There is exactly one store per
+* harness home; `DSH_HOME` isolates deployments (test homes never touch prod).
+*/
+function loadHashStore() {
+	const storePath = storePathFor();
+	const cached = stores.get(storePath);
+	if (cached && cached.db.isOpen) return Promise.resolve(cached.store);
+	const existing = openings.get(storePath);
+	if (existing) return existing;
+	const promise = openStore(storePath).finally(() => {
+		openings.delete(storePath);
 	});
-	return dups;
+	openings.set(storePath, promise);
+	return promise;
 }
-function canonCounts(lines) {
-	const counts = /* @__PURE__ */ new Map();
-	for (const line of lines) {
-		const key = canon(line);
-		counts.set(key, (counts.get(key) ?? 0) + 1);
-	}
-	return counts;
+/** The cached store entry for the active workspace (or the shared-home fallback), if open. */
+function currentStore() {
+	const entry = stores.get(storePathFor());
+	return entry?.db.isOpen ? entry : void 0;
 }
-/** @internal — private to anchor-pipeline seam */
-function findNewEdge(contentLines, rangeLines, fromEnd) {
-	const multiset = canonCounts(rangeLines);
-	const step = fromEnd ? -1 : 1;
-	const start = fromEnd ? contentLines.length - 1 : 0;
-	for (let i = start; i >= 0 && i < contentLines.length; i += step) {
-		const line = contentLines[i];
-		if (line.length === 0) continue;
-		const key = canon(line);
-		const count = multiset.get(key) ?? 0;
-		if (count > 0) multiset.set(key, count - 1);
-		else return {
-			index: i,
-			line
-		};
-	}
+/** Close every open store (process exit, HMR, tests). */
+function shutdownHashStore() {
+	for (const [, entry] of stores) shutdownDb(entry.db);
+	stores.clear();
+	openings.clear();
 }
-/** @internal — private to anchor-pipeline seam: detection + boundaryDups belongs to AnchorPipeline ordering */
-function valEdit(edit, fileLines, fileHashes, warnings, signal) {
-	assertAligned(fileLines, fileHashes, "valEdit");
-	const mismatches = [];
-	const boundaryDups = [];
-	const hashIndex = /* @__PURE__ */ new Map();
-	for (let i = 0; i < fileHashes.length; i++) {
-		const h = fileHashes[i];
-		const list = hashIndex.get(h) ?? [];
-		list.push(i + 1);
-		hashIndex.set(h, list);
-	}
-	const tryResolve = (ref) => {
-		const result = resAnchorFromMap(ref, hashIndex);
-		if ("kind" in result) {
-			mismatches.push(result);
-			return;
-		}
-		return result;
-	};
-	abortIf(signal);
-	const startResolved = tryResolve(edit.hash_bounds[0]);
-	const endResolved = tryResolve(edit.hash_bounds[1]);
-	if (!startResolved || !endResolved) {
-		if (!startResolved && endResolved) {
-			const startMismatch = mismatches.findLast((m) => m.ref === edit.hash_bounds[0]);
-			if (startMismatch && startMismatch.kind === "not_found") startMismatch.context = endResolved;
-		} else if (startResolved && !endResolved) {
-			const endMismatch = mismatches.findLast((m) => m.ref === edit.hash_bounds[1]);
-			if (endMismatch && endMismatch.kind === "not_found") endMismatch.context = startResolved;
+/**
+* Run `fn` inside one BEGIN IMMEDIATE transaction on the active workspace's
+* store. Without an open store for this context the call runs bare (the
+* caller has already loaded the store in every in-process path).
+*/
+function withStore(fn) {
+	const store = currentStore();
+	if (store) withBusyRetry(() => {
+		store.db.exec("BEGIN IMMEDIATE");
+		try {
+			fn();
+			store.db.exec("COMMIT");
+		} catch (e) {
+			try {
+				store.db.exec("ROLLBACK");
+			} catch {}
+			throw e;
 		}
-		return {
-			resolved: void 0,
-			mismatches,
-			boundaryDups
-		};
-	}
-	if (startResolved.line > endResolved.line) throw new Error(`[E_BAD_OP] Range start line ${startResolved.line} must be <= end line ${endResolved.line} (anchors ${edit.hash_bounds[0].hash} and ${edit.hash_bounds[1].hash}).`);
-	const endLine = endResolved.line;
-	const rangeLines = fileLines.slice(startResolved.line - 1, endLine);
-	const canonLines = fileLines.map((line) => canon(line));
-	boundaryDups.push(...trailingDups(edit.content_lines, fileLines, endLine), ...leadingDups(edit.content_lines, fileLines, startResolved.line), ...firstNewAfterDups(edit.content_lines, rangeLines, canonLines, endLine), ...lastNewBeforeDups(edit.content_lines, rangeLines, canonLines, startResolved.line));
-	return {
-		resolved: {
-			content_lines: edit.content_lines,
-			hash_bounds: [startResolved, endResolved]
-		},
-		mismatches,
-		boundaryDups
-	};
+	});
+	else fn();
 }
-var ServedRejectionError = class extends Error {
-	code;
-	firstOffendingLine;
-	servedRows;
-	constructor(opts) {
-		super(opts.message);
-		this.name = "ServedRejectionError";
-		this.code = opts.code;
-		this.firstOffendingLine = opts.firstOffendingLine;
-		this.servedRows = opts.servedRows;
+async function migrateLegacy(db, storePath) {
+	const legacyPath = join(dirname(storePath), "hash-store.json");
+	let content;
+	try {
+		content = await readFile(legacyPath, "utf-8");
+	} catch (error) {
+		if (errCode(error) === "ENOENT") return;
+		console.error("Failed to read legacy hash store for migration:", error);
+		return;
 	}
-};
-var AnchorMismatchError = class extends Error {
-	servedRows;
-	constructor(message, servedRows) {
-		super(message);
-		this.name = "AnchorMismatchError";
-		this.servedRows = servedRows;
+	let parsed;
+	try {
+		parsed = JSON.parse(content);
+	} catch (error) {
+		console.error("Failed to parse legacy hash store, skipping migration:", error);
+		return;
 	}
-};
-function buildRangeEcho(startLine, endLine, fileHashes) {
-	const total = endLine - startLine + 1;
-	const shown = Math.min(total, SERVED_ECHO_CAP);
+	const raw = parsed.snapshots;
+	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
 	const rows = [];
-	for (let ln = startLine; ln < startLine + shown; ln++) rows.push({
-		position: ln - 1,
-		hash: fileHashes[ln - 1]
-	});
-	return rows;
-}
-function fmtServedRows(rows, fileLines) {
-	return rows.map((row) => `${row.hash}${HASH_SEP}${fileLines[row.position] ?? ""}`).join("\n");
+	for (const [key, value] of Object.entries(raw)) {
+		if (!isValidSnapshot(value)) continue;
+		if (new Set(value.hashes).size !== value.hashes.length) {
+			console.warn(`Skipped legacy snapshot with duplicate hashes for ${key}; it will be re-hashed on next read.`);
+			continue;
+		}
+		rows.push([
+			key,
+			contentChecksum(value.content),
+			splitLines(value.content).length,
+			JSON.stringify(value.hashes),
+			Date.now()
+		]);
+	}
+	if (rows.length > 0) {
+		db.exec("BEGIN IMMEDIATE");
+		try {
+			const stmt = db.prepare("INSERT OR REPLACE INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?)");
+			for (const row of rows) stmt.run(...row);
+			db.exec("COMMIT");
+		} catch (e) {
+			db.exec("ROLLBACK");
+			throw e;
+		}
+	}
+	try {
+		await rename(legacyPath, `${legacyPath}.bak`);
+	} catch (error) {
+		console.error("Failed to rename legacy hash store after migration:", error);
+	}
 }
-function retryHint() {
-	return "Retry with these anchors (no read needed).";
+/** Find files whose stored snapshot hashes contain every given anchor. */
+async function findSnapshotPathsByHashes(hashes) {
+	return (await loadHashStore()).findSnapshotPaths(hashes);
 }
-function paginationHint(nextOffset, more) {
-	return `[... ${more} more — read offset=${nextOffset}]`;
+/** Persist a hash snapshot for one path (async over the active store). */
+async function upsertSnapshotFor(path$1, checksum, lineCount, hashes) {
+	(await loadHashStore()).upsertSnapshot(path$1, checksum, lineCount, hashes);
 }
-function verifyServedRange(args) {
-	const { served, startHash, endHash, startLine, endLine, fileHashes, fileLines, filePath } = args;
-	const where = filePath ? ` in ${filePath}` : "";
-	const echoRows = buildRangeEcho(startLine, endLine, fileHashes);
-	const totalLen = endLine - startLine + 1;
-	const tail = echoRows.length < totalLen ? `\n${paginationHint(startLine + echoRows.length, totalLen - echoRows.length)}` : "";
-	const echo = fmtServedRows(echoRows, fileLines) + tail;
-	const startPositions = servedPositionsOf(served, startHash);
-	const endPositions = servedPositionsOf(served, endHash);
-	const currentLen = endLine - startLine + 1;
-	let from;
-	let to;
-	if (startPositions.length === 1 && endPositions.length === 1) {
-		from = Math.min(startPositions[0], endPositions[0]);
-		to = Math.max(startPositions[0], endPositions[0]);
-	} else {
-		const candidates = [];
-		for (const s of startPositions) for (const e of endPositions) {
-			const candFrom = Math.min(s, e);
-			const candTo = Math.max(s, e);
-			if (candTo - candFrom + 1 !== currentLen) continue;
-			let ok = true;
-			for (let k = 0; k < currentLen; k++) if (served[candFrom + k] !== fileHashes[startLine - 1 + k]) {
-				ok = false;
-				break;
-			}
-			if (ok) candidates.push({
-				from: candFrom,
-				to: candTo
-			});
+
+//#endregion
+//#region src/url-schema/vendored/hashline/hashline/hash.js
+let defaultHashSnapshotIO;
+function snapshotIOFor(store) {
+	if (store) return {
+		get: (path$1, content, deleteCorrupt) => Promise.resolve(store.getSnapshot(path$1, content, deleteCorrupt)),
+		upsert: (path$1, checksum, lineCount, hashes) => {
+			store.upsertSnapshot(path$1, checksum, lineCount, hashes);
+			return Promise.resolve();
 		}
-		if (candidates.length === 1) {
-			from = candidates[0].from;
-			to = candidates[0].to;
-		} else if (candidates.length > 1) {
-			candidates.sort((a, b) => Math.abs(a.from - (startLine - 1)) - Math.abs(b.from - (startLine - 1)));
-			from = candidates[0].from;
-			to = candidates[0].to;
+	};
+	return defaultHashSnapshotIO ?? {
+		get: async (path$1, content, deleteCorrupt) => {
+			return (await loadHashStore()).getSnapshot(path$1, content, deleteCorrupt);
+		},
+		upsert: async (path$1, checksum, lineCount, hashes) => {
+			(await loadHashStore()).upsertSnapshot(path$1, checksum, lineCount, hashes);
+		}
+	};
+}
+async function lineHashes(content, path$1, previous, ioOrStore, persist) {
+	await initHasher();
+	if (!path$1) return lineHashesPure(content);
+	const io = ioOrStore && "getSnapshot" in ioOrStore ? snapshotIOFor(ioOrStore) : ioOrStore ?? snapshotIOFor(void 0);
+	if (previous) {
+		const newHashes$1 = mapStableHashes(previous.content, previous.hashes, content, previous.removedHashes);
+		if (persist !== false && io) try {
+			await io.upsert(path$1, contentChecksum(content), splitLines(content).length, newHashes$1);
+		} catch (e) {
+			console.error("Failed to persist hash snapshot:", e);
 		}
+		return newHashes$1;
 	}
-	if (from === void 0 || to === void 0) {
-		const problems = [];
-		if (startPositions.length === 0) problems.push(`remove_from "${startHash}" has no served position`);
-		else if (startPositions.length > 1) problems.push(`remove_from "${startHash}" was served at ${startPositions.length} positions`);
-		if (endPositions.length === 0) problems.push(`remove_to "${endHash}" has no served position`);
-		else if (endPositions.length > 1) problems.push(`remove_to "${endHash}" was served at ${endPositions.length} positions`);
-		throw new ServedRejectionError({
-			code: "E_RANGE_UNVERIFIED",
-			message: `[E_RANGE_UNVERIFIED] cannot verify range against served state${where}: ${problems.join("; ")}. Current range:
-${echo}
-${retryHint()}`,
-			servedRows: echoRows
-		});
+	let cached;
+	if (io) try {
+		cached = await io.get(path$1, content, persist !== false);
+	} catch (e) {
+		console.error("Failed to read hash store snapshot:", e);
 	}
-	for (let i = from; i <= to; i++) if (served[i] === null) throw new ServedRejectionError({
-		code: "E_RANGE_UNSERVED",
-		message: `[E_RANGE_UNSERVED] line ${i + 1}${where} was never served.\nCurrent range:\n${echo}\n${retryHint()}`,
-		firstOffendingLine: i + 1,
-		servedRows: echoRows
-	});
-	const servedLen = to - from + 1;
-	if (servedLen !== currentLen) throw new ServedRejectionError({
-		code: "E_RANGE_STALE",
-		message: `[E_RANGE_STALE] served span (${servedLen} lines) no longer matches current range (${currentLen} lines)${where}.\nCurrent range:\n${echo}\n${retryHint()}`,
-		firstOffendingLine: startLine,
-		servedRows: echoRows
-	});
-	for (let k = 0; k < servedLen; k++) if (served[from + k] !== fileHashes[startLine - 1 + k]) {
-		const offendingLine = startLine + k;
-		throw new ServedRejectionError({
-			code: "E_RANGE_STALE",
-			message: `[E_RANGE_STALE] Line ${offendingLine}${where} differs from what you were served — the file changed on disk since it was read. Current range:\n${echo}\n${retryHint()}`,
-			firstOffendingLine: offendingLine,
-			servedRows: echoRows
-		});
+	if (cached) return cached;
+	const newHashes = lineHashesPure(content);
+	if (persist !== false && io) try {
+		await io.upsert(path$1, contentChecksum(content), splitLines(content).length, newHashes);
+	} catch (e) {
+		console.error("Failed to persist hash snapshot:", e);
 	}
+	return newHashes;
 }
-async function recordEchoServes(sessionKey, path$1, rows, policy, lineCount) {
-	if (policy !== "live") return;
-	await recordServed(sessionKey, path$1, rows, lineCount);
+
+//#endregion
+//#region src/url-schema/vendored/hashline/session-view.js
+const current = new AsyncLocalStorage();
+function withWorkspace(cwd, fn) {
+	return current.run(cwd, fn);
 }
-function buildIdx(content) {
-	const fileLines = splitLines(content);
-	const lineStarts = [];
-	let offset = 0;
-	for (let index = 0; index < fileLines.length; index++) {
-		lineStarts.push(offset);
-		offset += fileLines[index].length;
-		if (index < fileLines.length - 1) offset += 1;
+function execCwd(exec) {
+	return exec.agent?.session.header.cwd ?? process.cwd();
+}
+/**
+* Merge served rows into a copy of the stored array. This single helper owns
+* the served-merge invariant shared by recordServed and recordServedTruncated.
+* Eagerly heals orphaned serves: if the same hash is written at a new position
+* the old position is nulled (O(n) scan, no extra I/O). This prevents a
+* partial re-serve from leaving a stale duplicate behind (ADR-0008).
+*/
+function _mergeServedRows(current$1, rows, options) {
+	const updated = current$1.slice();
+	if (options?.truncateTo !== void 0 && updated.length > options.truncateTo) updated.length = options.truncateTo;
+	if (options?.clearFrom !== void 0) for (let i = options.clearFrom; i < updated.length; i++) updated[i] = null;
+	const index = /* @__PURE__ */ new Map();
+	for (let i = 0; i < updated.length; i++) {
+		const h = updated[i];
+		if (h === null) continue;
+		const prev = index.get(h);
+		if (prev !== void 0) updated[prev] = null;
+		index.set(h, i);
 	}
-	return {
-		fileLines,
-		lineStarts
-	};
+	for (const entry of rows) {
+		if (!Number.isInteger(entry.position) || entry.position < 0) throw new TypeError(`Invalid served position: ${entry.position}`);
+		if (entry.hash !== null && (typeof entry.hash !== "string" || !HASH_RE.test(entry.hash))) throw new TypeError(`Invalid served hash: ${String(entry.hash)}`);
+		while (updated.length <= entry.position) updated.push(null);
+		if (entry.hash !== null) {
+			const existing = index.get(entry.hash);
+			if (existing !== void 0 && existing !== entry.position) {
+				updated[existing] = null;
+				index.delete(entry.hash);
+			}
+			const oldAtPos = updated[entry.position];
+			if (oldAtPos !== null && oldAtPos !== entry.hash) index.delete(oldAtPos);
+			index.set(entry.hash, entry.position);
+		} else {
+			const oldAtPos = updated[entry.position];
+			if (oldAtPos !== null) index.delete(oldAtPos);
+		}
+		updated[entry.position] = entry.hash;
+	}
+	while (updated.length > 0 && updated[updated.length - 1] === null) updated.pop();
+	return updated;
 }
-function assertNotEmpty(originalContent, result) {
-	if (originalContent.length > 0 && result.length === 0) throw new Error("[E_WOULD_EMPTY] Cannot empty a non-empty file via edit. Use `write` if you need to clear the file.");
+async function loadServed(path$1) {
+	return (await loadHashStore()).getServed(path$1);
 }
-function resToSpan(edit, content, lineIndex) {
-	const { fileLines, lineStarts } = lineIndex;
-	const startLine = edit.hash_bounds[0].line;
-	const endLine = edit.hash_bounds[1].line;
-	const originalLines = fileLines.slice(startLine - 1, endLine);
-	if (originalLines.length === edit.content_lines.length && originalLines.every((line, lineIndex$1) => line === edit.content_lines[lineIndex$1])) return {
-		kind: "noop",
-		loc: edit.hash_bounds[0].hash,
-		currentContent: originalLines.join("\n")
-	};
-	if (edit.content_lines.length > 0) return {
-		kind: "replace",
-		start: lineStarts[startLine - 1],
-		end: lineStarts[endLine - 1] + fileLines[endLine - 1].length,
-		replacement: edit.content_lines.join("\n")
-	};
-	if (startLine === 1 && endLine === fileLines.length) return {
-		kind: "replace",
-		start: 0,
-		end: content.length,
-		replacement: ""
-	};
-	if (endLine < fileLines.length) return {
-		kind: "replace",
-		start: lineStarts[startLine - 1],
-		end: lineStarts[endLine],
-		replacement: ""
-	};
-	if (content.endsWith("\n")) return {
-		kind: "replace",
-		start: lineStarts[startLine - 1],
-		end: content.length,
-		replacement: ""
-	};
-	const prevLine = startLine >= 2 ? fileLines[startLine - 2] : void 0;
-	return {
-		kind: "replace",
-		start: prevLine !== void 0 && prevLine.length === 0 ? lineStarts[startLine - 1] : Math.max(0, lineStarts[startLine - 1] - 1),
-		end: content.length,
-		replacement: ""
-	};
+async function recordServed(path$1, rows, lineCount) {
+	if (rows.length === 0) return;
+	try {
+		const store = await loadHashStore();
+		withStore(() => {
+			const current$1 = store.getServed(path$1);
+			const updated = _mergeServedRows(current$1, rows, lineCount === void 0 ? void 0 : { truncateTo: lineCount });
+			if (current$1.length === updated.length && current$1.every((v, i) => v === updated[i])) return;
+			store.upsertServed(path$1, JSON.stringify(updated));
+		});
+	} catch (error) {
+		console.error("Failed to record served rows:", error);
+	}
 }
-function assemble(content, span, signal) {
-	abortIf(signal);
-	return content.slice(0, span.start) + span.replacement + content.slice(span.end);
+async function recordServedTruncated(path$1, rows, lineCount, clearFrom = 0) {
+	if (rows.length === 0) return;
+	try {
+		const store = await loadHashStore();
+		withStore(() => {
+			const current$1 = store.getServed(path$1);
+			const updated = _mergeServedRows(current$1, rows, {
+				truncateTo: lineCount,
+				clearFrom
+			});
+			if (current$1.length === updated.length && current$1.every((v, i) => v === updated[i])) return;
+			store.upsertServed(path$1, JSON.stringify(updated));
+		});
+	} catch (error) {
+		console.error("Failed to record truncated served rows:", error);
+	}
 }
-function applyEdit(content, edit, signal, precomputedHashes, filePath, served) {
-	abortIf(signal);
-	const lineIndex = buildIdx(content);
-	const fileHashes = precomputedHashes ?? lineHashesPure(content);
-	const warnings = [];
-	const prefixFixed = stripDiffPrefixes(stripBarePrefixes(swapReversedRanges(edit, fileHashes, warnings), fileHashes, warnings), warnings);
-	const { resolved: initialResolved, mismatches, boundaryDups } = valEdit(prefixFixed, lineIndex.fileLines, fileHashes, warnings, signal);
-	if (mismatches.length || !initialResolved) {
-		const { message, servedRows } = fmtMismatchWithServes(mismatches, lineIndex.fileLines, fileHashes, filePath);
-		throw new AnchorMismatchError(message, servedRows);
+async function driftReported(path$1) {
+	try {
+		return (await loadHashStore()).getServedReported(path$1);
+	} catch (error) {
+		console.error("Failed to load reported drift set:", error);
+		return /* @__PURE__ */ new Set();
 	}
-	warnUnicodeEsc(prefixFixed, warnings);
-	let resolved = initialResolved;
-	let autoFixes;
-	if (boundaryDups.length > 0) {
-		autoFixes = [];
-		const correctedEdit = {
-			...prefixFixed,
-			content_lines: [...prefixFixed.content_lines]
-		};
-		const seen = /* @__PURE__ */ new Set();
-		const uniqueDups = [];
-		for (const dup of boundaryDups) {
-			if (seen.has(dup.replacementLineIndex)) continue;
-			seen.add(dup.replacementLineIndex);
-			uniqueDups.push(dup);
-		}
-		const dupsByIndex = uniqueDups.sort((a, b) => b.replacementLineIndex - a.replacementLineIndex);
-		for (const dup of dupsByIndex) {
-			const idx = dup.replacementLineIndex;
-			if (idx < 0 || idx >= correctedEdit.content_lines.length) continue;
-			const removed = correctedEdit.content_lines.splice(idx, 1)[0];
-			autoFixes.push({
-				kind: dup.kind,
-				removedLine: removed,
-				removedLineIndex: idx
-			});
-		}
-		const correctedResult = valEdit(correctedEdit, lineIndex.fileLines, fileHashes, warnings, signal);
-		if (correctedResult.mismatches.length || !correctedResult.resolved) {
-			const { message, servedRows } = fmtMismatchWithServes(correctedResult.mismatches, lineIndex.fileLines, fileHashes, filePath);
-			throw new AnchorMismatchError(message, servedRows);
-		}
-		resolved = correctedResult.resolved;
-	}
-	if (served) {
-		const startAnchor = resolved.hash_bounds[0];
-		const endAnchor = resolved.hash_bounds[1];
-		verifyServedRange({
-			served,
-			startHash: startAnchor.hash,
-			endHash: endAnchor.hash,
-			startLine: startAnchor.line,
-			endLine: endAnchor.line,
-			fileHashes,
-			fileLines: lineIndex.fileLines,
-			filePath
-		});
-	}
-	const spanResult = resToSpan(resolved, content, lineIndex);
-	if (spanResult.kind === "noop") return {
-		content,
-		firstChangedLine: void 0,
-		lastChangedLine: void 0,
-		range: resolvedRange(resolved),
-		...warnings.length ? { warnings } : {},
-		noopEdit: {
-			loc: spanResult.loc,
-			currentContent: spanResult.currentContent
-		}
-	};
-	const result = assemble(content, spanResult, signal);
-	assertNotEmpty(content, result);
-	const changed = changedRange(content, result);
-	return {
-		content: result,
-		firstChangedLine: changed?.firstChangedLine,
-		lastChangedLine: changed?.lastChangedLine,
-		range: resolvedRange(resolved),
-		...warnings.length ? { warnings } : {},
-		...autoFixes ? { autoFixes } : {}
-	};
-}
-function resolvedRange(resolved) {
-	const [start, end] = resolved.hash_bounds;
-	return {
-		startLine: start.line,
-		endLine: end.line,
-		startHash: start.hash,
-		endHash: end.hash,
-		delta: resolved.content_lines.length - (Math.abs(end.line - start.line) + 1)
-	};
-}
-function fmtRegion(hashes, lines) {
-	if (hashes.length !== lines.length) throw new Error(`fmtRegion: hashes.length (${hashes.length}) must match lines.length (${lines.length}).`);
-	return lines.map((line, index) => `${hashes[index]}${HASH_SEP}${line}`).join("\n");
-}
-function changedRange(original, result) {
-	if (original === result) return null;
-	if (original.length === 0) return {
-		firstChangedLine: 1,
-		lastChangedLine: splitLines(result).length
-	};
-	const originalLines = splitLines(original);
-	const resultLines = splitLines(result);
-	if (originalLines.length === resultLines.length && originalLines.every((line, index) => line === resultLines[index])) return null;
-	const minLen = Math.min(originalLines.length, resultLines.length);
-	let first = 0;
-	while (first < minLen && originalLines[first] === resultLines[first]) first++;
-	let lastOrig = originalLines.length - 1;
-	let lastRes = resultLines.length - 1;
-	while (lastOrig >= first && lastRes >= first && originalLines[lastOrig] === resultLines[lastRes]) {
-		lastOrig--;
-		lastRes--;
-	}
-	return {
-		firstChangedLine: first + 1,
-		lastChangedLine: Math.max(first, lastRes) + 1
-	};
-}
-
-//#endregion
-//#region src/url-schema/vendored/hashline/session-view.js
-const current = new AsyncLocalStorage();
-function withWorkspace(cwd, fn) {
-	return current.run(cwd, fn);
-}
-function workspaceCwd() {
-	return current.getStore();
-}
-let fallbackSessionKey;
-function sessionKeyFor(sessionId) {
-	if (sessionId && sessionId.length > 0) return sessionId;
-	return fallbackSessionKey ??= randomUUID();
-}
-function execCwd(exec) {
-	return exec.agent?.session.header.cwd ?? process.cwd();
-}
-function execSessionKey(exec) {
-	return sessionKeyFor(exec.agent?.session.id);
-}
-/**
-* Merge served rows into a copy of the stored array. This single helper owns
-* the served-merge invariant shared by recordServed and recordServedTruncated.
-* Eagerly heals orphaned serves: if the same hash is written at a new position
-* the old position is nulled (O(n) scan, no extra I/O). This prevents a
-* partial re-serve from leaving a stale duplicate behind (ADR-0008).
-*/
-function _mergeServedRows(current$1, rows, options) {
-	const updated = current$1.slice();
-	if (options?.truncateTo !== void 0 && updated.length > options.truncateTo) updated.length = options.truncateTo;
-	if (options?.clearFrom !== void 0) for (let i = options.clearFrom; i < updated.length; i++) updated[i] = null;
-	const index = /* @__PURE__ */ new Map();
-	for (let i = 0; i < updated.length; i++) {
-		const h = updated[i];
-		if (h === null) continue;
-		const prev = index.get(h);
-		if (prev !== void 0) updated[prev] = null;
-		index.set(h, i);
-	}
-	for (const entry of rows) {
-		if (!Number.isInteger(entry.position) || entry.position < 0) throw new TypeError(`Invalid served position: ${entry.position}`);
-		if (entry.hash !== null && (typeof entry.hash !== "string" || !HASH_RE.test(entry.hash))) throw new TypeError(`Invalid served hash: ${String(entry.hash)}`);
-		while (updated.length <= entry.position) updated.push(null);
-		if (entry.hash !== null) {
-			const existing = index.get(entry.hash);
-			if (existing !== void 0 && existing !== entry.position) {
-				updated[existing] = null;
-				index.delete(entry.hash);
-			}
-			const oldAtPos = updated[entry.position];
-			if (oldAtPos !== null && oldAtPos !== entry.hash) index.delete(oldAtPos);
-			index.set(entry.hash, entry.position);
-		} else {
-			const oldAtPos = updated[entry.position];
-			if (oldAtPos !== null) index.delete(oldAtPos);
-		}
-		updated[entry.position] = entry.hash;
-	}
-	while (updated.length > 0 && updated[updated.length - 1] === null) updated.pop();
-	return updated;
-}
-async function loadServed(sessionKey, path$1) {
-	return (await loadHashStore()).getServed(sessionKey, path$1);
 }
-async function recordServed(sessionKey, path$1, rows, lineCount) {
-	if (rows.length === 0) return;
-	try {
-		const store = await loadHashStore();
-		withStore(() => {
-			const current$1 = store.getServed(sessionKey, path$1);
-			const updated = _mergeServedRows(current$1, rows, lineCount === void 0 ? void 0 : { truncateTo: lineCount });
-			if (current$1.length === updated.length && current$1.every((v, i) => v === updated[i])) return;
-			store.upsertServed(sessionKey, path$1, JSON.stringify(updated));
-		});
-	} catch (error) {
-		console.error("Failed to record served rows:", error);
-	}
-}
-async function recordServedTruncated(sessionKey, path$1, rows, lineCount, clearFrom = 0) {
-	if (rows.length === 0) return;
-	try {
-		const store = await loadHashStore();
-		withStore(() => {
-			const current$1 = store.getServed(sessionKey, path$1);
-			const updated = _mergeServedRows(current$1, rows, {
-				truncateTo: lineCount,
-				clearFrom
-			});
-			if (current$1.length === updated.length && current$1.every((v, i) => v === updated[i])) return;
-			store.upsertServed(sessionKey, path$1, JSON.stringify(updated));
-		});
-	} catch (error) {
-		console.error("Failed to record truncated served rows:", error);
-	}
-}
-async function driftReported(sessionKey, path$1) {
-	try {
-		return (await loadHashStore()).getServedReported(sessionKey, path$1);
-	} catch (error) {
-		console.error("Failed to load reported drift set:", error);
-		return /* @__PURE__ */ new Set();
-	}
-}
-async function markDriftReported(sessionKey, path$1, hashes) {
+async function markDriftReported(path$1, hashes) {
 	try {
 		const valid = hashes.filter((hash) => HASH_RE.test(hash));
 		if (valid.length === 0) return;
 		const store = await loadHashStore();
 		withStore(() => {
-			const current$1 = store.getServedReported(sessionKey, path$1);
+			const current$1 = store.getServedReported(path$1);
 			for (const hash of valid) current$1.add(hash);
-			store.upsertServedReported(sessionKey, path$1, JSON.stringify([...current$1]));
+			store.upsertServedReported(path$1, JSON.stringify([...current$1]));
 		});
 	} catch (error) {
 		console.error("Failed to record reported drift set:", error);
 	}
 }
-async function clearDriftReported(sessionKey, path$1) {
+async function clearDriftReported(path$1) {
 	try {
 		const store = await loadHashStore();
 		withStore(() => {
-			store.clearServedReported(sessionKey, path$1);
+			store.clearServedReported(path$1);
 		});
 	} catch (error) {
 		console.error("Failed to clear reported drift set:", error);
@@ -7189,568 +7073,661 @@ function computeDrift(input) {
 	};
 }
 async function scanDrift(input) {
-	const reported = await driftReported(input.sessionKey, input.path);
+	const reported = await driftReported(input.path);
 	const result = computeDrift({
 		...input,
 		reported
 	});
 	if (!result || result.allAlreadyReported) return result?.text;
-	await recordServed(input.sessionKey, input.path, result.rows.map((row) => ({
+	await recordServed(input.path, result.rows.map((row) => ({
 		position: row.position,
 		hash: row.hash
 	})), input.resultLines.length);
-	await markDriftReported(input.sessionKey, input.path, result.rows.filter((row) => row.drifted).map((row) => row.hash));
+	await markDriftReported(input.path, result.rows.filter((row) => row.drifted).map((row) => row.hash));
 	return result.text;
 }
 
 //#endregion
-//#region src/url-schema/vendored/hashline/hash-store.js
-function isValidHashList(value) {
-	if (!Array.isArray(value)) return false;
-	for (const hash of value) if (typeof hash !== "string" || !HASH_RE.test(hash)) return false;
-	return true;
+//#region src/url-schema/vendored/hashline/hashline/anchor-pipeline.js
+function diagRef(ref) {
+	const trimmed = ref.trim();
+	if (!trimmed.length) return `[E_BAD_REF] Invalid anchor. Expected a 3-char alphanumeric anchor (e.g. "aB3").`;
+	if (/^\d+/.test(trimmed)) return `[E_BAD_REF] Invalid anchor. Use the hash alone (e.g. "aB3") — no line numbers or trailing content.`;
+	if (trimmed.includes("│")) return `[E_BAD_REF] Invalid anchor "${trimmed}". remove_from and remove_to must contain the 3-char hash only — remove everything from "│" onward.`;
+	return `[E_BAD_REF] Invalid anchor "${trimmed}". Expected a 3-char alphanumeric anchor (e.g. "aB3").`;
 }
-function isValidSnapshot(value) {
-	if (typeof value !== "object" || value === null) return false;
-	const v = value;
-	if (typeof v.content !== "string") return false;
-	return isValidHashList(v.hashes);
+function parseRef(ref) {
+	const trimmed = ref.trim();
+	if (trimmed.length === ANCHOR_LEN && ALPH_RE.test(trimmed)) return { hash: trimmed };
+	throw new Error(diagRef(ref));
 }
-/** A served-row array: per-position hash, or null for never-served slots. */
-function isValidServedList(value) {
-	if (!Array.isArray(value)) return false;
-	for (const entry of value) {
-		if (entry === null) continue;
-		if (typeof entry !== "string" || !HASH_RE.test(entry)) return false;
-	}
-	return true;
+const parseHashRef = parseRef;
+function parseText(edit) {
+	if (typeof edit !== "string") throw new Error(NEW_CONTENT_NOT_STRING_MSG);
+	const normalized = edit.replace(/\r\n/g, "\n").replace(/\r/g, "\n");
+	if (normalized === "") return [];
+	if (/^\n+$/.test(normalized)) return new Array(normalized.length).fill("");
+	return normalized.split("\n");
 }
-function cacheKey(checksum) {
-	return `${CANON_VERSION}:${checksum}`;
+function resAnchorFromMap(ref, hashIndex) {
+	const hashMatches = hashIndex.get(ref.hash);
+	if (!hashMatches || hashMatches.length === 0) return {
+		ref,
+		kind: "not_found"
+	};
+	if (hashMatches.length === 1) return {
+		line: hashMatches[0],
+		hash: ref.hash,
+		hashMatched: true
+	};
+	return {
+		ref,
+		kind: "ambiguous",
+		candidates: hashMatches
+	};
 }
-function isCorruptionError(error) {
-	if (error && typeof error === "object") {
-		const errcode = error.errcode;
-		if (typeof errcode === "number") return errcode === 11 || errcode === 24 || errcode === 26;
-		const code = error.code;
-		if (typeof code === "string" && /NOTADB|CORRUPT/.test(code)) return true;
-	}
-	return error instanceof Error && /corrupt|not a database|malformed|database disk image/i.test(error.message);
+function assertAligned(fileLines, fileHashes, ctx) {
+	if (fileHashes.length !== fileLines.length) throw new Error(`${ctx}: fileHashes.length (${fileHashes.length}) must match fileLines.length (${fileLines.length}).`);
 }
-function isBusyError(error) {
-	if (error && typeof error === "object") {
-		const errcode = error.errcode;
-		if (typeof errcode === "number") return errcode === 5 || errcode === 6;
+function fmtMismatchWithServes(mismatches, fileLines, fileHashes, filePath) {
+	assertAligned(fileLines, fileHashes, "fmtMismatch");
+	const out = [];
+	const servedRows = [];
+	const seen = /* @__PURE__ */ new Set();
+	const pushRow = (ln) => {
+		if (ln < 1 || ln > fileLines.length) return;
+		const position = ln - 1;
+		if (seen.has(position)) return;
+		seen.add(position);
+		servedRows.push({
+			position,
+			hash: fileHashes[ln - 1]
+		});
+	};
+	const notFound = mismatches.filter((m) => m.kind === "not_found");
+	const ambiguous = mismatches.filter((m) => m.kind === "ambiguous");
+	const refList = notFound.map((m) => `"${m.ref.hash}"`).join(", ");
+	if (notFound.length > 0) {
+		out.push(`[E_STALE_ANCHOR] ${notFound.length} stale anchor${notFound.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}: ${refList}. Re-read for fresh anchors.`);
+		for (const m of notFound) {
+			const ctx = m.context;
+			if (!ctx) continue;
+			const from = Math.max(1, ctx.line - 1);
+			const to = Math.min(fileLines.length, ctx.line + 1);
+			const rows = [];
+			for (let ln = from; ln <= to; ln++) {
+				rows.push(`    ${ln}: ${fileHashes[ln - 1]}│${clipLine(fileLines[ln - 1] ?? "")}`);
+				pushRow(ln);
+			}
+			out.push("");
+			out.push(`  Current context around resolved anchor "${ctx.hash}" (line ${ctx.line}):\n${rows.join("\n")}`);
+		}
 	}
-	return error instanceof Error && /busy|locked/i.test(error.message);
+	if (ambiguous.length > 0) {
+		if (out.length > 0) out.push("");
+		out.push(`[E_AMBIGUOUS_ANCHOR] ${ambiguous.length} ambiguous anchor${ambiguous.length > 1 ? "s" : ""}${filePath ? ` in ${filePath}` : ""}. Re-read for fresh anchors.`);
+		for (const m of ambiguous) {
+			const sample = (m.candidates ?? []).slice(0, 5);
+			const more = (m.candidates?.length ?? 0) > sample.length ? `, ... (+${(m.candidates?.length ?? 0) - sample.length} more)` : "";
+			const lines = sample.map((line) => {
+				const content = clipLine(fileLines[line - 1] ?? "");
+				pushRow(line);
+				return `    ${line}: ${fileHashes[line - 1]}│${content}`;
+			}).join("\n");
+			out.push(`  Hash "${m.ref.hash}" matches lines ${sample.join(", ")}${more}.\n${lines}`);
+		}
+	}
+	return {
+		message: out.join("\n"),
+		servedRows
+	};
 }
-function sleepSync(ms) {
-	const sab = new Int32Array(new SharedArrayBuffer(4));
-	Atomics.wait(sab, 0, 0, ms);
+const ITEM_KS = new Set([
+	"replacement_text",
+	"remove_from",
+	"remove_to"
+]);
+function assertItem(edit) {
+	rejectUnknownFields(edit, ITEM_KS, "Edit", "The edit takes only { replacement_text, remove_from, remove_to }.");
+	if ("remove_from" in edit && typeof edit.remove_from !== "string") throw new Error(`[E_BAD_SHAPE] Field "remove_from" must be an anchor string (3-char hash).`);
+	if ("remove_to" in edit && typeof edit.remove_to !== "string") throw new Error(`[E_BAD_SHAPE] Field "remove_to" must be an anchor string (3-char hash).`);
+	if (!("replacement_text" in edit)) throw new Error(`[E_BAD_SHAPE] The edit requires a "replacement_text" field. Provide the replacement text (use "" to delete).`);
+	if (typeof edit.replacement_text !== "string") throw new Error(NEW_CONTENT_NOT_STRING_MSG);
+	if (typeof edit.remove_from !== "string" || typeof edit.remove_to !== "string") throw new Error(`[E_BAD_SHAPE] The edit requires "remove_from" and "remove_to" anchor strings (3-char hashes from read output).`);
 }
-const BUSY_RETRIES = 3;
-const BUSY_RETRY_DELAY_MS = 100;
-function withBusyRetry(fn) {
-	let lastError;
-	for (let attempt = 0; attempt <= BUSY_RETRIES; attempt++) try {
-		return fn();
-	} catch (error) {
-		lastError = error;
-		if (!isBusyError(error) || attempt === BUSY_RETRIES) throw error;
-		sleepSync(BUSY_RETRY_DELAY_MS);
+const ANCHOR_ROW_RE = /* @__PURE__ */ new RegExp(`^([+-]?)(${HASH_CLASS})│`);
+function resEdit(edit, warnings) {
+	assertItem(edit);
+	const editLines = parseText(edit.replacement_text);
+	const bounds = [edit.remove_from, edit.remove_to].map((ref) => {
+		const trimmed = ref.trim();
+		const match = trimmed.match(ANCHOR_ROW_RE);
+		if (match) {
+			let message;
+			if (match[1] === "+") message = `[E_BAD_REF] stripped diff-preview marker from remove_from/remove_to "${trimmed}".`;
+			else if (match[1] === "-") message = `[E_BAD_REF] stripped leading "-" marker from remove_from/remove_to "${trimmed}".`;
+			else message = `[E_BAD_REF] stripped "HASH│" prefix from remove_from/remove_to "${trimmed}".`;
+			warnings?.push(message);
+			return match[2];
+		}
+		return ref;
+	});
+	return {
+		content_lines: editLines,
+		hash_bounds: [parseHashRef(bounds[0]), parseHashRef(bounds[1])]
+	};
+}
+function warnUnicodeEsc(edit, warnings) {
+	if (edit.content_lines.some((line) => /\\uDDDD/i.test(line))) warnings.push("Detected literal \\uDDDD in edit content; no autocorrection applied. Verify whether this should be a real Unicode escape or plain text.");
+}
+/** @internal — private to anchor-pipeline seam; do not import directly, use anchor-pipeline.ts */
+function stripBarePrefixes(edit, fileHashes, warnings) {
+	const fileHashSet = new Set(fileHashes);
+	const stripped = [];
+	const contentLines = edit.content_lines.map((line, lineIndex) => {
+		const match = line.match(HL_BARE_PREFIX_RE);
+		if (!match) return line;
+		stripped.push({
+			lineIndex,
+			matched: fileHashSet.has(match[1])
+		});
+		return line.slice(match[0].length);
+	});
+	if (stripped.length === 0) return edit;
+	const locations = stripped.map((s) => `replacement_text line ${s.lineIndex + 1}`).join(", ");
+	const matchedCount = stripped.filter((s) => s.matched).length;
+	const evidence = matchedCount === 0 ? "0 matched — verify literal 'HASH│' content" : `${matchedCount}/${stripped.length} matched`;
+	warnings.push(`[E_BARE_HASH_PREFIX] stripped "HASH│" prefix from ${locations} (${evidence}).`);
+	return {
+		...edit,
+		content_lines: contentLines
+	};
+}
+/** @internal — private to anchor-pipeline seam */
+function stripDiffPrefixes(edit, warnings) {
+	const stripped = [];
+	const contentLines = edit.content_lines.map((line, lineIndex) => {
+		const plus = line.match(HL_PREFIX_PLUS_RE);
+		if (plus) {
+			stripped.push(lineIndex);
+			return line.slice(plus[0].length);
+		}
+		const minus = line.match(HL_PREFIX_MINUS_RE);
+		if (minus) {
+			stripped.push(lineIndex);
+			return line.slice(minus[0].length);
+		}
+		return line;
+	});
+	if (stripped.length === 0) return edit;
+	const locations = stripped.map((i) => `replacement_text line ${i + 1}`).join(", ");
+	warnings.push(`[E_INVALID_PATCH] stripped diff-preview marker from ${locations}.`);
+	return {
+		...edit,
+		content_lines: contentLines
+	};
+}
+/** @internal — private to anchor-pipeline seam */
+function swapReversedRanges(edit, fileHashes, warnings) {
+	const lineByHash = /* @__PURE__ */ new Map();
+	for (let i = 0; i < fileHashes.length; i++) lineByHash.set(fileHashes[i], i + 1);
+	const [startRef, endRef] = edit.hash_bounds;
+	const startLine = lineByHash.get(startRef.hash);
+	const endLine = lineByHash.get(endRef.hash);
+	if (startLine === void 0 || endLine === void 0 || startLine <= endLine) return edit;
+	warnings.push(`[E_BAD_OP] reversed remove_from/remove_to (${startRef.hash} after ${endRef.hash}); swapped.`);
+	return {
+		...edit,
+		hash_bounds: [endRef, startRef]
+	};
+}
+function trailingDups(contentLines, fileLines, endLine) {
+	const start = lastNonEmptyIndex(contentLines);
+	if (start < 0) return [];
+	const dups = [];
+	const maxK = Math.min(start + 1, fileLines.length - endLine);
+	for (let k = 0; k < maxK; k++) {
+		if (contentLines[start - k] !== fileLines[endLine + k]) break;
+		dups.push({
+			kind: "trailing",
+			replacementLineIndex: start - k
+		});
 	}
-	throw lastError;
+	return dups;
 }
-function openDbWithBusyRetry(storePath) {
-	return withBusyRetry(() => openDb(storePath));
+function leadingDups(contentLines, fileLines, startLine) {
+	const start = firstNonEmptyIndex(contentLines);
+	if (start < 0) return [];
+	const dups = [];
+	const maxK = Math.min(contentLines.length - start, startLine - 1);
+	for (let k = 0; k < maxK; k++) {
+		if (contentLines[start + k] !== fileLines[startLine - 2 - k]) break;
+		dups.push({
+			kind: "leading",
+			replacementLineIndex: start + k
+		});
+	}
+	return dups;
 }
-/** One open store per store path (per workspace); parallel sessions share per-workspace dbs. */
-const stores = /* @__PURE__ */ new Map();
-const openings = /* @__PURE__ */ new Map();
-let exitHandlerRegistered = false;
-function openDb(storePath) {
-	const db = new DatabaseSync(storePath, { timeout: HASH_STORE_BUSY_TIMEOUT });
-	try {
-		return buildStore(db);
-	} catch (error) {
-		try {
-			db.close();
-		} catch {}
-		throw error;
+function sectionIsUnique(canonLines, start, length) {
+	let count = 0;
+	for (let i = 0; i + length <= canonLines.length; i++) {
+		let k = 0;
+		while (k < length && canonLines[i + k] === canonLines[start + k]) k++;
+		if (k < length) continue;
+		count++;
+		if (count > 1) return false;
 	}
+	return true;
 }
-function buildStore(db) {
-	db.exec("PRAGMA journal_mode = WAL");
-	db.exec("PRAGMA synchronous = NORMAL");
-	db.exec("CREATE TABLE IF NOT EXISTS snapshots (path TEXT PRIMARY KEY, checksum TEXT NOT NULL, line_count INTEGER NOT NULL, hashes TEXT NOT NULL, updated_at INTEGER NOT NULL)");
-	db.exec("CREATE TABLE IF NOT EXISTS meta (key TEXT PRIMARY KEY, value TEXT NOT NULL)");
-	db.exec("CREATE TABLE IF NOT EXISTS undo (path TEXT PRIMARY KEY, content TEXT NOT NULL, bom TEXT NOT NULL, ending TEXT NOT NULL, hashes TEXT NOT NULL, result_content TEXT NOT NULL, updated_at INTEGER NOT NULL)");
-	const versionRow = db.prepare("SELECT value FROM meta WHERE key = 'version'").get();
-	const versionChanged = versionRow !== void 0 && versionRow.value !== String(HASH_STORE_VERSION);
-	if (versionChanged) {
-		db.exec("DELETE FROM snapshots");
-		db.exec("DELETE FROM undo");
+function firstNewAfterDups(contentLines, rangeLines, canonLines, endLine) {
+	const firstNew = findNewEdge(contentLines, rangeLines, false);
+	if (!firstNew) return [];
+	const maxK = Math.min(contentLines.length - firstNew.index, canonLines.length - endLine);
+	let runLen = 0;
+	while (runLen < maxK && canon(contentLines[firstNew.index + runLen]) === canonLines[endLine + runLen]) runLen++;
+	if (runLen === 0 || !sectionIsUnique(canonLines, endLine, runLen)) return [];
+	const dups = [];
+	for (let k = 0; k < runLen; k++) dups.push({
+		kind: "first-new-after",
+		replacementLineIndex: firstNew.index + k
+	});
+	return dups;
+}
+function lastNewBeforeDups(contentLines, rangeLines, canonLines, startLine) {
+	const lastNew = findNewEdge(contentLines, rangeLines, true);
+	if (!lastNew) return [];
+	const maxK = Math.min(lastNew.index + 1, startLine - 1);
+	let runLen = 0;
+	while (runLen < maxK && canon(contentLines[lastNew.index - runLen]) === canonLines[startLine - 2 - runLen]) runLen++;
+	if (runLen === 0) return [];
+	if (!sectionIsUnique(canonLines, startLine - 1 - runLen, runLen)) return [];
+	const dups = [];
+	for (let k = 0; k < runLen; k++) dups.push({
+		kind: "last-new-before",
+		replacementLineIndex: lastNew.index - k
+	});
+	return dups;
+}
+function canonCounts(lines) {
+	const counts = /* @__PURE__ */ new Map();
+	for (const line of lines) {
+		const key = canon(line);
+		counts.set(key, (counts.get(key) ?? 0) + 1);
 	}
-	const servedColumns = db.prepare("PRAGMA table_info(served)").all();
-	if (versionChanged || !servedColumns.some((column) => column.name === "session_id")) db.exec("DROP TABLE IF EXISTS served");
-	db.exec("CREATE TABLE IF NOT EXISTS served (session_id TEXT NOT NULL, path TEXT NOT NULL, hashes TEXT NOT NULL, reported TEXT, updated_at INTEGER NOT NULL, PRIMARY KEY (session_id, path))");
-	db.prepare("INSERT INTO meta (key, value) VALUES ('version', ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value").run(String(HASH_STORE_VERSION));
-	const getStmt = db.prepare("SELECT hashes FROM snapshots WHERE path = ? AND checksum = ? AND line_count = ?");
-	const allStmt = db.prepare("SELECT path FROM snapshots UNION SELECT path FROM undo UNION SELECT path FROM served");
-	const allHashesStmt = db.prepare("SELECT path, hashes FROM snapshots");
-	const delStmt = db.prepare("DELETE FROM snapshots WHERE path = ?");
-	const upsertStmt = db.prepare("INSERT INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?) ON CONFLICT(path) DO UPDATE SET checksum = excluded.checksum, line_count = excluded.line_count, hashes = excluded.hashes, updated_at = excluded.updated_at");
-	const undoUpsertStmt = db.prepare("INSERT INTO undo (path, content, bom, ending, hashes, result_content, updated_at) VALUES (?, ?, ?, ?, ?, ?, ?) ON CONFLICT(path) DO UPDATE SET content = excluded.content, bom = excluded.bom, ending = excluded.ending, hashes = excluded.hashes, result_content = excluded.result_content, updated_at = excluded.updated_at");
-	const undoGetStmt = db.prepare("SELECT content, bom, ending, hashes, result_content FROM undo WHERE path = ?");
-	const undoDelStmt = db.prepare("DELETE FROM undo WHERE path = ?");
-	const servedGetStmt = db.prepare("SELECT hashes, reported FROM served WHERE session_id = ? AND path = ?");
-	const servedUpsertStmt = db.prepare("INSERT INTO served (session_id, path, hashes, updated_at) VALUES (?, ?, ?, ?) ON CONFLICT(session_id, path) DO UPDATE SET hashes = excluded.hashes, updated_at = excluded.updated_at");
-	const servedReportedUpsertStmt = db.prepare("INSERT INTO served (session_id, path, hashes, reported, updated_at) VALUES (?, ?, '[]', ?, ?) ON CONFLICT(session_id, path) DO UPDATE SET reported = excluded.reported, updated_at = excluded.updated_at");
-	const servedReportedClearStmt = db.prepare("UPDATE served SET reported = NULL, updated_at = ? WHERE session_id = ? AND path = ?");
-	const servedDeleteStmt = db.prepare("DELETE FROM served WHERE session_id = ? AND path = ?");
-	const servedDeletePathStmt = db.prepare("DELETE FROM served WHERE path = ?");
-	const servedWipeStmt = db.prepare("DELETE FROM served WHERE session_id = ?");
-	const servedPruneOlderThanStmt = db.prepare("DELETE FROM served WHERE updated_at < ?");
-	return {
-		db,
-		stmts: {
-			get: (...params) => getStmt.get(...params),
-			allPaths: (...params) => allStmt.all(...params),
-			allHashes: (...params) => allHashesStmt.all(...params),
-			deleteOne: (...params) => {
-				withBusyRetry(() => {
-					delStmt.run(...params);
-				});
-			},
-			upsert: (...params) => {
-				withBusyRetry(() => {
-					upsertStmt.run(...params);
-				});
-			},
-			undoUpsert: (...params) => {
-				withBusyRetry(() => {
-					undoUpsertStmt.run(...params);
-				});
-			},
-			undoGet: (...params) => undoGetStmt.get(...params),
-			undoDelete: (...params) => {
-				withBusyRetry(() => {
-					undoDelStmt.run(...params);
-				});
-			},
-			servedGet: (...params) => servedGetStmt.get(...params),
-			servedUpsert: (...params) => {
-				withBusyRetry(() => {
-					servedUpsertStmt.run(...params);
-				});
-			},
-			servedReportedUpsert: (...params) => {
-				withBusyRetry(() => {
-					servedReportedUpsertStmt.run(...params);
-				});
-			},
-			servedReportedClear: (...params) => {
-				withBusyRetry(() => {
-					servedReportedClearStmt.run(params[1], params[0], params[2]);
-				});
-			},
-			servedDelete: (...params) => {
-				withBusyRetry(() => {
-					servedDeleteStmt.run(...params);
-				});
-			},
-			servedDeletePath: (...params) => {
-				withBusyRetry(() => {
-					servedDeletePathStmt.run(...params);
-				});
-			},
-			servedWipe: (...params) => {
-				withBusyRetry(() => {
-					servedWipeStmt.run(...params);
-				});
-			},
-			servedPruneOlderThan: (...params) => {
-				withBusyRetry(() => {
-					servedPruneOlderThanStmt.run(...params);
-				});
-			}
+	return counts;
+}
+/** @internal — private to anchor-pipeline seam */
+function findNewEdge(contentLines, rangeLines, fromEnd) {
+	const multiset = canonCounts(rangeLines);
+	const step = fromEnd ? -1 : 1;
+	const start = fromEnd ? contentLines.length - 1 : 0;
+	for (let i = start; i >= 0 && i < contentLines.length; i += step) {
+		const line = contentLines[i];
+		if (line.length === 0) continue;
+		const key = canon(line);
+		const count = multiset.get(key) ?? 0;
+		if (count > 0) multiset.set(key, count - 1);
+		else return {
+			index: i,
+			line
+		};
+	}
+}
+/** @internal — private to anchor-pipeline seam: detection + boundaryDups belongs to AnchorPipeline ordering */
+function valEdit(edit, fileLines, fileHashes, warnings, signal) {
+	assertAligned(fileLines, fileHashes, "valEdit");
+	const mismatches = [];
+	const boundaryDups = [];
+	const hashIndex = /* @__PURE__ */ new Map();
+	for (let i = 0; i < fileHashes.length; i++) {
+		const h = fileHashes[i];
+		const list = hashIndex.get(h) ?? [];
+		list.push(i + 1);
+		hashIndex.set(h, list);
+	}
+	const tryResolve = (ref) => {
+		const result = resAnchorFromMap(ref, hashIndex);
+		if ("kind" in result) {
+			mismatches.push(result);
+			return;
 		}
+		return result;
 	};
-}
-/** Wire the domain methods over the prepared statements. */
-function makeDomainStore(stmts) {
-	return {
-		engine: "node:sqlite",
-		getSnapshot(path$1, content, deleteCorrupt = true) {
-			const checksum = cacheKey(contentChecksum(content));
-			const lineCount = splitLines(content).length;
-			const row = stmts.get(path$1, checksum, lineCount);
-			if (!row) return void 0;
-			try {
-				const parsed = JSON.parse(row.hashes);
-				if (isValidHashList(parsed)) return parsed;
-				if (deleteCorrupt) stmts.deleteOne(path$1);
-				return;
-			} catch {
-				if (deleteCorrupt) stmts.deleteOne(path$1);
-				return;
-			}
-		},
-		upsertSnapshot(path$1, checksum, lineCount, hashes) {
-			stmts.upsert(path$1, cacheKey(checksum), lineCount, JSON.stringify(hashes), Date.now());
-		},
-		allKnownPaths() {
-			return stmts.allPaths();
-		},
-		allSnapshotHashes() {
-			return stmts.allHashes();
-		},
-		deleteSnapshot(path$1) {
-			stmts.deleteOne(path$1);
-		},
-		findSnapshotPaths(hashes) {
-			const rows = stmts.allHashes();
-			const matches = [];
-			for (const row of rows) try {
-				const parsed = JSON.parse(row.hashes);
-				if (!isValidHashList(parsed)) continue;
-				if (hashes.every((h) => parsed.includes(h))) matches.push(row.path);
-			} catch {}
-			return matches;
-		},
-		getUndo(path$1) {
-			const row = stmts.undoGet(path$1);
-			if (!row) return void 0;
-			try {
-				const parsed = JSON.parse(row.hashes);
-				if (!isValidHashList(parsed)) {
-					stmts.undoDelete(path$1);
-					return;
-				}
-				return {
-					content: row.content,
-					bom: row.bom,
-					ending: row.ending,
-					hashes: parsed,
-					resultContent: row.result_content
-				};
-			} catch {
-				stmts.undoDelete(path$1);
-				return;
-			}
-		},
-		upsertUndo(path$1, entry) {
-			stmts.undoUpsert(path$1, entry.content, entry.bom, entry.ending, JSON.stringify(entry.hashes), entry.resultContent, Date.now());
-		},
-		deleteUndo(path$1) {
-			stmts.undoDelete(path$1);
-		},
-		getServed(sessionKey, path$1) {
-			const row = stmts.servedGet(sessionKey, path$1);
-			if (!row) return [];
-			try {
-				const parsed = JSON.parse(row.hashes);
-				if (isValidServedList(parsed)) return parsed;
-				stmts.servedDelete(sessionKey, path$1);
-				return [];
-			} catch {
-				stmts.servedDelete(sessionKey, path$1);
-				return [];
-			}
-		},
-		getServedReported(sessionKey, path$1) {
-			const row = stmts.servedGet(sessionKey, path$1);
-			if (!row) return /* @__PURE__ */ new Set();
-			const raw = row.reported;
-			if (typeof raw !== "string" || raw.length === 0) return /* @__PURE__ */ new Set();
-			try {
-				const parsed = JSON.parse(raw);
-				if (!Array.isArray(parsed)) return /* @__PURE__ */ new Set();
-				return new Set(parsed.filter((h) => typeof h === "string" && HASH_RE.test(h)));
-			} catch {
-				return /* @__PURE__ */ new Set();
-			}
-		},
-		upsertServed(sessionKey, path$1, hashesJson) {
-			stmts.servedUpsert(sessionKey, path$1, hashesJson, Date.now());
-		},
-		upsertServedReported(sessionKey, path$1, reportedJson) {
-			stmts.servedReportedUpsert(sessionKey, path$1, reportedJson, Date.now());
-		},
-		clearServedReported(sessionKey, path$1) {
-			stmts.servedReportedClear(sessionKey, Date.now(), path$1);
-		},
-		deleteServed(sessionKey, path$1) {
-			stmts.servedDelete(sessionKey, path$1);
-		},
-		deleteServedByPath(path$1) {
-			stmts.servedDeletePath(path$1);
-		},
-		wipeServed(sessionKey) {
-			stmts.servedWipe(sessionKey);
-		},
-		pruneServedOlderThan(ts) {
-			stmts.servedPruneOlderThan(ts);
-		},
-		async pruneMissing() {
-			const missing = await statMissing(stmts.allPaths());
-			if (missing.length === 0) return;
-			withStore(() => {
-				for (const path$1 of missing) {
-					stmts.deleteOne(path$1);
-					stmts.undoDelete(path$1);
-					stmts.servedDeletePath(path$1);
-				}
-			});
+	abortIf(signal);
+	const startResolved = tryResolve(edit.hash_bounds[0]);
+	const endResolved = tryResolve(edit.hash_bounds[1]);
+	if (!startResolved || !endResolved) {
+		if (!startResolved && endResolved) {
+			const startMismatch = mismatches.findLast((m) => m.ref === edit.hash_bounds[0]);
+			if (startMismatch && startMismatch.kind === "not_found") startMismatch.context = endResolved;
+		} else if (startResolved && !endResolved) {
+			const endMismatch = mismatches.findLast((m) => m.ref === edit.hash_bounds[1]);
+			if (endMismatch && endMismatch.kind === "not_found") endMismatch.context = startResolved;
 		}
+		return {
+			resolved: void 0,
+			mismatches,
+			boundaryDups
+		};
+	}
+	if (startResolved.line > endResolved.line) throw new Error(`[E_BAD_OP] Range start line ${startResolved.line} must be <= end line ${endResolved.line} (anchors ${edit.hash_bounds[0].hash} and ${edit.hash_bounds[1].hash}).`);
+	const endLine = endResolved.line;
+	const rangeLines = fileLines.slice(startResolved.line - 1, endLine);
+	const canonLines = fileLines.map((line) => canon(line));
+	boundaryDups.push(...trailingDups(edit.content_lines, fileLines, endLine), ...leadingDups(edit.content_lines, fileLines, startResolved.line), ...firstNewAfterDups(edit.content_lines, rangeLines, canonLines, endLine), ...lastNewBeforeDups(edit.content_lines, rangeLines, canonLines, startResolved.line));
+	return {
+		resolved: {
+			content_lines: edit.content_lines,
+			hash_bounds: [startResolved, endResolved]
+		},
+		mismatches,
+		boundaryDups
 	};
 }
-function isHealthy(db) {
-	try {
-		return db.prepare("PRAGMA quick_check").get()?.quick_check === "ok";
-	} catch (error) {
-		if (isCorruptionError(error)) return false;
-		return true;
+var ServedRejectionError = class extends Error {
+	code;
+	firstOffendingLine;
+	servedRows;
+	constructor(opts) {
+		super(opts.message);
+		this.name = "ServedRejectionError";
+		this.code = opts.code;
+		this.firstOffendingLine = opts.firstOffendingLine;
+		this.servedRows = opts.servedRows;
 	}
-}
-async function quarantineStore(storePath) {
-	const suffix = `.corrupt-${Date.now()}`;
-	for (const candidate of [
-		storePath,
-		`${storePath}-wal`,
-		`${storePath}-shm`
-	]) try {
-		await rename(candidate, `${candidate}${suffix}`);
-	} catch (error) {
-		if (errCode(error) !== "ENOENT") console.error("Failed to quarantine corrupt hash store file:", error);
+};
+var AnchorMismatchError = class extends Error {
+	servedRows;
+	constructor(message, servedRows) {
+		super(message);
+		this.name = "AnchorMismatchError";
+		this.servedRows = servedRows;
 	}
+};
+function buildRangeEcho(startLine, endLine, fileHashes) {
+	const total = endLine - startLine + 1;
+	const shown = Math.min(total, SERVED_ECHO_CAP);
+	const rows = [];
+	for (let ln = startLine; ln < startLine + shown; ln++) rows.push({
+		position: ln - 1,
+		hash: fileHashes[ln - 1]
+	});
+	return rows;
 }
-function shutdownDb(db) {
-	try {
-		db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
-	} catch {}
-	db.close();
+function fmtServedRows(rows, fileLines) {
+	return rows.map((row) => `${row.hash}${HASH_SEP}${fileLines[row.position] ?? ""}`).join("\n");
 }
-const STAT_BATCH = 64;
-async function statMissing(rows) {
-	const missing = [];
-	for (let i = 0; i < rows.length; i += STAT_BATCH) {
-		const batch = rows.slice(i, i + STAT_BATCH);
-		const results = await Promise.all(batch.map(async (row) => {
-			try {
-				await stat(row.path);
-				return;
-			} catch {
-				return row.path;
-			}
-		}));
-		for (const path$1 of results) if (path$1 !== void 0) missing.push(path$1);
-	}
-	return missing;
+function retryHint() {
+	return "Read the file once to refresh anchors, then resubmit the whole batch.";
 }
-async function openStore(storePath) {
-	await initHasher();
-	await mkdir(dirname(storePath), { recursive: true });
-	let existed = existsSync(storePath);
-	let opened;
-	try {
-		opened = openDbWithBusyRetry(storePath);
-	} catch (error) {
-		if (!isCorruptionError(error)) throw error;
-		console.error("Hash store failed to open, rebuilding:", error);
-		await quarantineStore(storePath);
-		existed = false;
-		opened = openDbWithBusyRetry(storePath);
+function paginationHint(nextOffset, more) {
+	return `[... ${more} more — read offset=${nextOffset}]`;
+}
+function verifyServedRange(args) {
+	const { served, startHash, endHash, startLine, endLine, fileHashes, fileLines, filePath } = args;
+	const where = filePath ? ` in ${filePath}` : "";
+	const echoRows = buildRangeEcho(startLine, endLine, fileHashes);
+	const totalLen = endLine - startLine + 1;
+	const tail = echoRows.length < totalLen ? `\n${paginationHint(startLine + echoRows.length, totalLen - echoRows.length)}` : "";
+	const echo = fmtServedRows(echoRows, fileLines) + tail;
+	const startPositions = servedPositionsOf(served, startHash);
+	const endPositions = servedPositionsOf(served, endHash);
+	if (startPositions.length === 0 && endPositions.length === 0) return;
+	const currentLen = endLine - startLine + 1;
+	let from;
+	let to;
+	if (startPositions.length === 1 && endPositions.length === 1) {
+		from = Math.min(startPositions[0], endPositions[0]);
+		to = Math.max(startPositions[0], endPositions[0]);
+	} else {
+		const candidates = [];
+		for (const s of startPositions) for (const e of endPositions) {
+			const candFrom = Math.min(s, e);
+			const candTo = Math.max(s, e);
+			if (candTo - candFrom + 1 !== currentLen) continue;
+			let ok = true;
+			for (let k = 0; k < currentLen; k++) if (served[candFrom + k] !== fileHashes[startLine - 1 + k]) {
+				ok = false;
+				break;
+			}
+			if (ok) candidates.push({
+				from: candFrom,
+				to: candTo
+			});
+		}
+		if (candidates.length === 1) {
+			from = candidates[0].from;
+			to = candidates[0].to;
+		} else if (candidates.length > 1) {
+			candidates.sort((a, b) => Math.abs(a.from - (startLine - 1)) - Math.abs(b.from - (startLine - 1)));
+			from = candidates[0].from;
+			to = candidates[0].to;
+		}
 	}
-	if (!isHealthy(opened.db)) {
-		shutdownDb(opened.db);
-		await quarantineStore(storePath);
-		existed = false;
-		opened = openDbWithBusyRetry(storePath);
+	if (from === void 0 || to === void 0) {
+		const problems = [];
+		if (startPositions.length === 0) problems.push(`remove_from "${startHash}" has no served position`);
+		else if (startPositions.length > 1) problems.push(`remove_from "${startHash}" was served at ${startPositions.length} positions`);
+		if (endPositions.length === 0) problems.push(`remove_to "${endHash}" has no served position`);
+		else if (endPositions.length > 1) problems.push(`remove_to "${endHash}" was served at ${endPositions.length} positions`);
+		throw new ServedRejectionError({
+			code: "E_RANGE_UNVERIFIED",
+			message: `[E_RANGE_UNVERIFIED] cannot verify range against served state${where}: ${problems.join("; ")}. Current range:
+${echo}
+${retryHint()}`,
+			servedRows: echoRows
+		});
 	}
-	const { db, stmts } = opened;
-	if (!existed) await migrateLegacy(db, storePath);
-	withBusyRetry(() => {
-		stmts.servedPruneOlderThan(Date.now() - SERVED_TTL_MS);
+	for (let i = from; i <= to; i++) if (served[i] === null) throw new ServedRejectionError({
+		code: "E_RANGE_UNSERVED",
+		message: `[E_RANGE_UNSERVED] line ${i + 1}${where} was never served.\nCurrent range:\n${echo}\n${retryHint()}`,
+		firstOffendingLine: i + 1,
+		servedRows: echoRows
 	});
-	const store = makeDomainStore(stmts);
-	stores.set(storePath, {
-		path: storePath,
-		db,
-		stmts,
-		store
+	const servedLen = to - from + 1;
+	if (servedLen !== currentLen) throw new ServedRejectionError({
+		code: "E_RANGE_STALE",
+		message: `[E_RANGE_STALE] served span (${servedLen} lines) no longer matches current range (${currentLen} lines)${where}.\nCurrent range:\n${echo}\n${retryHint()}`,
+		firstOffendingLine: startLine,
+		servedRows: echoRows
 	});
-	if (!exitHandlerRegistered) {
-		exitHandlerRegistered = true;
-		process.once("exit", () => shutdownHashStore());
-		for (const sig of ["SIGINT", "SIGTERM"]) process.once(sig, () => {
-			shutdownHashStore();
-			process.kill(process.pid, sig);
+	for (let k = 0; k < servedLen; k++) if (served[from + k] !== fileHashes[startLine - 1 + k]) {
+		const offendingLine = startLine + k;
+		throw new ServedRejectionError({
+			code: "E_RANGE_STALE",
+			message: `[E_RANGE_STALE] Line ${offendingLine}${where} differs from what you were served — the file changed on disk since it was read. Current range:\n${echo}\n${retryHint()}`,
+			firstOffendingLine: offendingLine,
+			servedRows: echoRows
 		});
 	}
-	return store;
 }
-/** Resolve the store path for this call: explicit cwd, the active workspace, or the shared-home fallback. */
-function storePathFor(cwd) {
-	return hashStorePath(cwd ?? workspaceCwd());
+async function recordEchoServes(path$1, rows, policy, lineCount) {
+	if (policy !== "live") return;
+	await recordServed(path$1, rows, lineCount);
 }
-/**
-* Load (and cache) the hash store for the given cwd — or, when omitted, the
-* workspace active for this async execution (`withWorkspace`), falling back to
-* the shared `$DSH_HOME` store outside a tool call.
-* @param cwd - optional explicit workspace root; defaults to the active workspace.
-*/
-function loadHashStore(cwd) {
-	const storePath = storePathFor(cwd);
-	const cached = stores.get(storePath);
-	if (cached && cached.db.isOpen) return Promise.resolve(cached.store);
-	const existing = openings.get(storePath);
-	if (existing) return existing;
-	const promise = openStore(storePath).finally(() => {
-		openings.delete(storePath);
-	});
-	openings.set(storePath, promise);
-	return promise;
+function buildIdx(content) {
+	const fileLines = splitLines(content);
+	const lineStarts = [];
+	let offset = 0;
+	for (let index = 0; index < fileLines.length; index++) {
+		lineStarts.push(offset);
+		offset += fileLines[index].length;
+		if (index < fileLines.length - 1) offset += 1;
+	}
+	return {
+		fileLines,
+		lineStarts
+	};
 }
-/** The cached store entry for the active workspace (or the shared-home fallback), if open. */
-function currentStore() {
-	const entry = stores.get(storePathFor());
-	return entry?.db.isOpen ? entry : void 0;
+function assertNotEmpty(originalContent, result) {
+	if (originalContent.length > 0 && result.length === 0) throw new Error("[E_WOULD_EMPTY] Cannot empty a non-empty file via edit. Use `write` if you need to clear the file.");
 }
-/** Close every open store (process exit, HMR, tests). */
-function shutdownHashStore() {
-	for (const [, entry] of stores) shutdownDb(entry.db);
-	stores.clear();
-	openings.clear();
+function resToSpan(edit, content, lineIndex) {
+	const { fileLines, lineStarts } = lineIndex;
+	const startLine = edit.hash_bounds[0].line;
+	const endLine = edit.hash_bounds[1].line;
+	const originalLines = fileLines.slice(startLine - 1, endLine);
+	if (originalLines.length === edit.content_lines.length && originalLines.every((line, lineIndex$1) => line === edit.content_lines[lineIndex$1])) return {
+		kind: "noop",
+		loc: edit.hash_bounds[0].hash,
+		currentContent: originalLines.join("\n")
+	};
+	if (edit.content_lines.length > 0) return {
+		kind: "replace",
+		start: lineStarts[startLine - 1],
+		end: lineStarts[endLine - 1] + fileLines[endLine - 1].length,
+		replacement: edit.content_lines.join("\n")
+	};
+	if (startLine === 1 && endLine === fileLines.length) return {
+		kind: "replace",
+		start: 0,
+		end: content.length,
+		replacement: ""
+	};
+	if (endLine < fileLines.length) return {
+		kind: "replace",
+		start: lineStarts[startLine - 1],
+		end: lineStarts[endLine],
+		replacement: ""
+	};
+	if (content.endsWith("\n")) return {
+		kind: "replace",
+		start: lineStarts[startLine - 1],
+		end: content.length,
+		replacement: ""
+	};
+	const prevLine = startLine >= 2 ? fileLines[startLine - 2] : void 0;
+	return {
+		kind: "replace",
+		start: prevLine !== void 0 && prevLine.length === 0 ? lineStarts[startLine - 1] : Math.max(0, lineStarts[startLine - 1] - 1),
+		end: content.length,
+		replacement: ""
+	};
 }
-/**
-* Run `fn` inside one BEGIN IMMEDIATE transaction on the active workspace's
-* store. Without an open store for this context the call runs bare (the
-* caller has already loaded the store in every in-process path).
-*/
-function withStore(fn) {
-	const store = currentStore();
-	if (store) withBusyRetry(() => {
-		store.db.exec("BEGIN IMMEDIATE");
-		try {
-			fn();
-			store.db.exec("COMMIT");
-		} catch (e) {
-			try {
-				store.db.exec("ROLLBACK");
-			} catch {}
-			throw e;
-		}
-	});
-	else fn();
+function assemble(content, span, signal) {
+	abortIf(signal);
+	return content.slice(0, span.start) + span.replacement + content.slice(span.end);
 }
-async function migrateLegacy(db, storePath) {
-	const legacyPath = join(dirname(storePath), "hash-store.json");
-	let content;
-	try {
-		content = await readFile(legacyPath, "utf-8");
-	} catch (error) {
-		if (errCode(error) === "ENOENT") return;
-		console.error("Failed to read legacy hash store for migration:", error);
-		return;
-	}
-	let parsed;
-	try {
-		parsed = JSON.parse(content);
-	} catch (error) {
-		console.error("Failed to parse legacy hash store, skipping migration:", error);
-		return;
+function applyEdit(content, edit, signal, precomputedHashes, filePath, served) {
+	abortIf(signal);
+	const lineIndex = buildIdx(content);
+	const fileHashes = precomputedHashes ?? lineHashesPure(content);
+	const warnings = [];
+	const prefixFixed = stripDiffPrefixes(stripBarePrefixes(swapReversedRanges(edit, fileHashes, warnings), fileHashes, warnings), warnings);
+	const { resolved: initialResolved, mismatches, boundaryDups } = valEdit(prefixFixed, lineIndex.fileLines, fileHashes, warnings, signal);
+	if (mismatches.length || !initialResolved) {
+		const { message, servedRows } = fmtMismatchWithServes(mismatches, lineIndex.fileLines, fileHashes, filePath);
+		throw new AnchorMismatchError(message, servedRows);
 	}
-	const raw = parsed.snapshots;
-	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return;
-	const rows = [];
-	for (const [key, value] of Object.entries(raw)) {
-		if (!isValidSnapshot(value)) continue;
-		if (new Set(value.hashes).size !== value.hashes.length) {
-			console.warn(`Skipped legacy snapshot with duplicate hashes for ${key}; it will be re-hashed on next read.`);
-			continue;
+	warnUnicodeEsc(prefixFixed, warnings);
+	let resolved = initialResolved;
+	let autoFixes;
+	if (boundaryDups.length > 0) {
+		autoFixes = [];
+		const correctedEdit = {
+			...prefixFixed,
+			content_lines: [...prefixFixed.content_lines]
+		};
+		const seen = /* @__PURE__ */ new Set();
+		const uniqueDups = [];
+		for (const dup of boundaryDups) {
+			if (seen.has(dup.replacementLineIndex)) continue;
+			seen.add(dup.replacementLineIndex);
+			uniqueDups.push(dup);
 		}
-		rows.push([
-			key,
-			contentChecksum(value.content),
-			splitLines(value.content).length,
-			JSON.stringify(value.hashes),
-			Date.now()
-		]);
-	}
-	if (rows.length > 0) {
-		db.exec("BEGIN IMMEDIATE");
-		try {
-			const stmt = db.prepare("INSERT OR REPLACE INTO snapshots (path, checksum, line_count, hashes, updated_at) VALUES (?, ?, ?, ?, ?)");
-			for (const row of rows) stmt.run(...row);
-			db.exec("COMMIT");
-		} catch (e) {
-			db.exec("ROLLBACK");
-			throw e;
+		const dupsByIndex = uniqueDups.sort((a, b) => b.replacementLineIndex - a.replacementLineIndex);
+		for (const dup of dupsByIndex) {
+			const idx = dup.replacementLineIndex;
+			if (idx < 0 || idx >= correctedEdit.content_lines.length) continue;
+			const removed = correctedEdit.content_lines.splice(idx, 1)[0];
+			autoFixes.push({
+				kind: dup.kind,
+				removedLine: removed,
+				removedLineIndex: idx
+			});
+		}
+		const correctedResult = valEdit(correctedEdit, lineIndex.fileLines, fileHashes, warnings, signal);
+		if (correctedResult.mismatches.length || !correctedResult.resolved) {
+			const { message, servedRows } = fmtMismatchWithServes(correctedResult.mismatches, lineIndex.fileLines, fileHashes, filePath);
+			throw new AnchorMismatchError(message, servedRows);
 		}
+		resolved = correctedResult.resolved;
 	}
-	try {
-		await rename(legacyPath, `${legacyPath}.bak`);
-	} catch (error) {
-		console.error("Failed to rename legacy hash store after migration:", error);
+	if (served) {
+		const startAnchor = resolved.hash_bounds[0];
+		const endAnchor = resolved.hash_bounds[1];
+		verifyServedRange({
+			served,
+			startHash: startAnchor.hash,
+			endHash: endAnchor.hash,
+			startLine: startAnchor.line,
+			endLine: endAnchor.line,
+			fileHashes,
+			fileLines: lineIndex.fileLines,
+			filePath
+		});
 	}
-}
-/** Find files whose stored snapshot hashes contain every given anchor. */
-async function findSnapshotPathsByHashes(hashes) {
-	return (await loadHashStore()).findSnapshotPaths(hashes);
-}
-/** Persist a hash snapshot for one path (async over the active store). */
-async function upsertSnapshotFor(path$1, checksum, lineCount, hashes) {
-	(await loadHashStore()).upsertSnapshot(path$1, checksum, lineCount, hashes);
-}
-
-//#endregion
-//#region src/url-schema/vendored/hashline/hashline/hash.js
-let defaultHashSnapshotIO;
-function snapshotIOFor(store) {
-	if (store) return {
-		get: (path$1, content, deleteCorrupt) => Promise.resolve(store.getSnapshot(path$1, content, deleteCorrupt)),
-		upsert: (path$1, checksum, lineCount, hashes) => {
-			store.upsertSnapshot(path$1, checksum, lineCount, hashes);
-			return Promise.resolve();
+	const spanResult = resToSpan(resolved, content, lineIndex);
+	if (spanResult.kind === "noop") return {
+		content,
+		firstChangedLine: void 0,
+		lastChangedLine: void 0,
+		range: resolvedRange(resolved),
+		...warnings.length ? { warnings } : {},
+		noopEdit: {
+			loc: spanResult.loc,
+			currentContent: spanResult.currentContent
 		}
 	};
-	return defaultHashSnapshotIO ?? {
-		get: async (path$1, content, deleteCorrupt) => {
-			return (await loadHashStore()).getSnapshot(path$1, content, deleteCorrupt);
-		},
-		upsert: async (path$1, checksum, lineCount, hashes) => {
-			(await loadHashStore()).upsertSnapshot(path$1, checksum, lineCount, hashes);
-		}
+	const result = assemble(content, spanResult, signal);
+	assertNotEmpty(content, result);
+	const changed = changedRange(content, result);
+	return {
+		content: result,
+		firstChangedLine: changed?.firstChangedLine,
+		lastChangedLine: changed?.lastChangedLine,
+		range: resolvedRange(resolved),
+		...warnings.length ? { warnings } : {},
+		...autoFixes ? { autoFixes } : {}
 	};
 }
-async function lineHashes(content, path$1, previous, ioOrStore, persist) {
-	await initHasher();
-	if (!path$1) return lineHashesPure(content);
-	const io = ioOrStore && "getSnapshot" in ioOrStore ? snapshotIOFor(ioOrStore) : ioOrStore ?? snapshotIOFor(void 0);
-	if (previous) {
-		const newHashes$1 = mapStableHashes(previous.content, previous.hashes, content, previous.removedHashes);
-		if (persist !== false && io) try {
-			await io.upsert(path$1, contentChecksum(content), splitLines(content).length, newHashes$1);
-		} catch (e) {
-			console.error("Failed to persist hash snapshot:", e);
-		}
-		return newHashes$1;
-	}
-	let cached;
-	if (io) try {
-		cached = await io.get(path$1, content, persist !== false);
-	} catch (e) {
-		console.error("Failed to read hash store snapshot:", e);
-	}
-	if (cached) return cached;
-	const newHashes = lineHashesPure(content);
-	if (persist !== false && io) try {
-		await io.upsert(path$1, contentChecksum(content), splitLines(content).length, newHashes);
-	} catch (e) {
-		console.error("Failed to persist hash snapshot:", e);
+function resolvedRange(resolved) {
+	const [start, end] = resolved.hash_bounds;
+	return {
+		startLine: start.line,
+		endLine: end.line,
+		startHash: start.hash,
+		endHash: end.hash,
+		delta: resolved.content_lines.length - (Math.abs(end.line - start.line) + 1)
+	};
+}
+function fmtRegion(hashes, lines) {
+	if (hashes.length !== lines.length) throw new Error(`fmtRegion: hashes.length (${hashes.length}) must match lines.length (${lines.length}).`);
+	return lines.map((line, index) => `${hashes[index]}${HASH_SEP}${line}`).join("\n");
+}
+function changedRange(original, result) {
+	if (original === result) return null;
+	if (original.length === 0) return {
+		firstChangedLine: 1,
+		lastChangedLine: splitLines(result).length
+	};
+	const originalLines = splitLines(original);
+	const resultLines = splitLines(result);
+	if (originalLines.length === resultLines.length && originalLines.every((line, index) => line === resultLines[index])) return null;
+	const minLen = Math.min(originalLines.length, resultLines.length);
+	let first = 0;
+	while (first < minLen && originalLines[first] === resultLines[first]) first++;
+	let lastOrig = originalLines.length - 1;
+	let lastRes = resultLines.length - 1;
+	while (lastOrig >= first && lastRes >= first && originalLines[lastOrig] === resultLines[lastRes]) {
+		lastOrig--;
+		lastRes--;
 	}
-	return newHashes;
+	return {
+		firstChangedLine: first + 1,
+		lastChangedLine: Math.max(first, lastRes) + 1
+	};
 }
 
 //#endregion
@@ -8182,15 +8159,15 @@ const UTF8_REWRITE_NOTE = "[Non-UTF-8 bytes shown as U+FFFD; editing rewrites th
 * context.
 */
 async function readAndServe(io, rawPath, cwd, options) {
-	const { sessionKey, signal } = options;
+	const { signal } = options;
 	abortIf(signal);
 	const view = await readView(io, rawPath, cwd, {
 		offset: options.offset,
 		limit: options.limit,
 		signal
 	});
-	if (view.served.length > 0) await recordServed(sessionKey, view.absolutePath, view.served, view.hashes.length);
-	await clearDriftReported(sessionKey, view.absolutePath);
+	if (view.served.length > 0) await recordServed(view.absolutePath, view.served, view.hashes.length);
+	await clearDriftReported(view.absolutePath);
 	return {
 		text: view.hadUtf8DecodeErrors ? `${view.text}\n\n${UTF8_REWRITE_NOTE}` : view.text,
 		served: view.served,
@@ -8254,10 +8231,8 @@ function createReadTool(deps) {
 			}
 			return withWorkspace(execCwd(exec), async () => {
 				const cwd = execCwd(exec);
-				const sessionKey = execSessionKey(exec);
 				const signal = exec.signal;
 				const { text, absolutePath } = await readAndServe(io, rawPath, cwd, {
-					sessionKey,
 					signal,
 					offset: canonical.offset,
 					limit: canonical.limit
@@ -8684,12 +8659,12 @@ async function applyOne(input, onReject) {
 * with no change. Messages are byte-identical to the pre-engine tools.
 */
 async function enforceNoopLoop(opts) {
-	const { absolutePath, removeFrom, removeTo, displayPath, index, count, sessionKey, originalHashes } = opts;
+	const { absolutePath, removeFrom, removeTo, displayPath, index, count, originalHashes } = opts;
 	if (index === void 0) {
 		if (count >= NOOP_LOOP_THRESHOLD) {
 			const echoRows = buildRangeEcho(opts.range.startLine, opts.range.endLine, originalHashes);
 			const echo = fmtServedRows(echoRows, splitLines(opts.originalNormalized));
-			await recordEchoServes(sessionKey, absolutePath, echoRows, "live", originalHashes.length);
+			await recordEchoServes(absolutePath, echoRows, "live", originalHashes.length);
 			throw new Error(`[E_NOOP_LOOP] identical edit (${removeFrom} → ${removeTo} in ${displayPath}) submitted ${count}×, no changes each time. Range already contains this text; resend will reject. Current range:\n${echo}`);
 		}
 		if (count === 2) return `[E_NOOP_LOOP] Notice: identical edit (${removeFrom} → ${removeTo} in ${displayPath}) no-op'd twice; range already has this text. Resend will reject.`;
@@ -8698,7 +8673,7 @@ async function enforceNoopLoop(opts) {
 	if (count >= NOOP_LOOP_THRESHOLD) {
 		const originalLines = splitLines(opts.originalNormalized);
 		const echoRows = opts.echoRows;
-		if (echoRows) await recordEchoServes(sessionKey, absolutePath, echoRows, "live", originalHashes.length);
+		if (echoRows) await recordEchoServes(absolutePath, echoRows, "live", originalHashes.length);
 		throw new Error(`[E_NOOP_LOOP] edits[${index}] (${displayPath}): identical edit (${removeFrom} → ${removeTo}) submitted ${count}×, no changes each time. Range already has this text; resend will reject the batch.` + (echoRows ? ` Current on-disk range:\n${fmtServedRows(echoRows, originalLines)}` : ""));
 	}
 	if (count === 2) return `[E_NOOP_LOOP] Notice: edits[${index}] (${displayPath}) — identical edit no-op'd twice; range already has this text. Resend will reject the batch.`;
@@ -8728,7 +8703,7 @@ async function runFileEdits(io, items, opts) {
 		signal: opts.signal,
 		maxLines: MAX_HASH_LINES
 	});
-	const served = await loadServed(opts.sessionKey, absolutePath);
+	const served = await loadServed(absolutePath);
 	const warnings = [];
 	let currentContent = originalNormalized;
 	let currentHashes = originalHashes;
@@ -8760,7 +8735,7 @@ async function runFileEdits(io, items, opts) {
 			if (error instanceof AnchorMismatchError || error instanceof ServedRejectionError) {
 				const originalLines = splitLines(originalNormalized);
 				const echoRows = error.servedRows.length > 0 ? error.servedRows : edit ? echoRowsForItem(edit, originalHashes) : void 0;
-				if (echoRows) await recordEchoServes(opts.sessionKey, absolutePath, echoRows, "live", originalHashes.length);
+				if (echoRows) await recordEchoServes(absolutePath, echoRows, "live", originalHashes.length);
 				const echoBlock = echoRows ? ` Current on-disk range for edits[${item.index}] (unchanged — nothing was written):\n${fmtServedRows(echoRows, originalLines)}` : " Call read() to get fresh anchors.";
 				throw new Error(`[E_BATCH_ABORT] edits[${item.index}] (${item.path}) failed: ${error.message}${echoBlock}\nThe whole batch was rejected and NOTHING was written — no file changed and earlier items in the batch were NOT applied. Fix the failing edit (and any later edit that depends on it), then resubmit the batch.`);
 			}
@@ -8787,7 +8762,6 @@ async function runFileEdits(io, items, opts) {
 				displayPath: item.path,
 				index: item.index,
 				count,
-				sessionKey: opts.sessionKey,
 				originalHashes,
 				originalNormalized,
 				echoRows: echoRowsForItem(applied.edit, originalHashes)
@@ -8826,7 +8800,6 @@ async function runFileEdits(io, items, opts) {
 		const originalLines = splitLines(originalNormalized);
 		try {
 			driftNotice = await scanDrift({
-				sessionKey: opts.sessionKey,
 				served,
 				resultHashes,
 				resultLines,
@@ -9036,11 +9009,8 @@ function buildBatchResult(sections) {
 * across every tool — it concentrates (deep).
 */
 async function execute(opts) {
-	const { io, items, sessionKey, signal, exec, sandbox, sandboxPolicy } = opts;
-	const fileResult = await applySequence(io, items, {
-		signal,
-		sessionKey
-	});
+	const { io, items, signal, exec, sandbox, sandboxPolicy } = opts;
+	const fileResult = await applySequence(io, items, { signal });
 	const toSection = () => ({
 		path: fileResult.displayPath,
 		originalNormalized: fileResult.originalNormalized,
@@ -9057,7 +9027,7 @@ async function execute(opts) {
 	const recordIfNeeded = async (built$1) => {
 		if (built$1.details.servedRows && built$1.details.servedRows.length > 0) {
 			const entry = built$1.details.servedByPath?.[0];
-			if (entry) await recordServedTruncated(sessionKey, fileResult.absolutePath, entry.servedRows, splitLines(fileResult.result).length, fileResult.range.startLine - 1);
+			if (entry) await recordServedTruncated(fileResult.absolutePath, entry.servedRows, splitLines(fileResult.result).length, fileResult.range.startLine - 1);
 		}
 	};
 	if (items.length === 1 && fileResult.appliedCount + fileResult.noopCount === 1) {
@@ -9214,7 +9184,6 @@ function buildEditTool(io, sandbox) {
 		async execute(args, exec) {
 			return withWorkspace(execCwd(exec), async () => {
 				const cwd = execCwd(exec);
-				const sessionKey = execSessionKey(exec);
 				const signal = exec.signal;
 				const canonical = normalizeRequest(args);
 				assertEditRequest(canonical);
@@ -9251,7 +9220,6 @@ function buildEditTool(io, sandbox) {
 				return execute({
 					io,
 					items,
-					sessionKey,
 					signal,
 					exec,
 					sandbox,
@@ -9296,7 +9264,6 @@ function buildUndoTool(io, sandbox) {
 		async execute(args, exec) {
 			return withWorkspace(execCwd(exec), async () => {
 				const cwd = execCwd(exec);
-				const sessionKey = execSessionKey(exec);
 				const signal = exec.signal;
 				const canonical = normalizeRequest(args);
 				assertUndoRequest(canonical);
@@ -9347,7 +9314,7 @@ function buildUndoTool(io, sandbox) {
 				const parts = [`Undone last edit on ${path$1}.`];
 				if (linesAddedByEdit > 0 || linesRemovedByEdit > 0) parts.push(`Removed ${linesAddedByEdit} line(s) that were added and restored ${linesRemovedByEdit} line(s) that were removed.`);
 				parts.push("File reverted to previous state. The post-edit diff rows carry the restored file’s fresh anchors for follow-up edits.");
-				if (undoDenseRows.length > 0) await recordServedTruncated(sessionKey, absolutePath, undoDenseRows, splitLines(undo.content).length, restoredRange?.firstChangedLine ?? undoDiffResult.firstChangedLine ?? 0);
+				if (undoDenseRows.length > 0) await recordServedTruncated(absolutePath, undoDenseRows, splitLines(undo.content).length, restoredRange?.firstChangedLine ?? undoDiffResult.firstChangedLine ?? 0);
 				return [
 					parts.join("\n"),
 					"",
@@ -9366,51 +9333,6 @@ function registerUndoTool(_rootCtx, agentCtx, io, sandbox) {
 	return agentCtx.tools.register(buildUndoTool(io, sandbox));
 }
 
-//#endregion
-//#region src/url-schema/vendored/hashline/write-hook.js
-const AUTO_READ_HEADING = "--- Auto-read (hashline anchors) ---";
-/**
-* Register the post-write auto-read listener on the calling agent's scope.
-* Replaces the result content (never the canonical value) with the original
-* content plus the hashline preview; any failure falls back to the untouched
-* decision so a broken auto-read never breaks the write.
-* @param rootCtx - host context for diagnostics.
-* @param agentCtx - the agent's scoped context; the listener receives only
-*   this agent's tool results.
-* @param io - the filesystem bridge.
-* @returns the exact disposer that unregisters the listener.
-*/
-function registerWriteHook(rootCtx, agentCtx, io) {
-	return agentCtx.on("tools/post-execute", async (exec, result, next) => {
-		return withWorkspace(execCwd(exec), async () => {
-			const decision = await next();
-			if (exec.name !== "write" || result.isError || decision.kind !== "accept") return decision;
-			const decisionContent = decision.content ?? result.content;
-			const rawPath = exec.arguments?.file_path ?? exec.arguments?.path;
-			if (typeof rawPath !== "string") return decision;
-			try {
-				const cwd = execCwd(exec);
-				const sessionKey = execSessionKey(exec);
-				const signal = exec.signal;
-				const { text } = await readAndServe(io, rawPath, cwd, {
-					sessionKey,
-					signal
-				});
-				return {
-					kind: "accept",
-					content: [...decisionContent, {
-						type: "text",
-						text: `\n\n${AUTO_READ_HEADING}\n${text}`
-					}]
-				};
-			} catch (error) {
-				rootCtx.logger.warn(`dsh-better-edit: auto-read after write failed: ${error instanceof Error ? error.message : String(error)}`);
-				return decision;
-			}
-		});
-	});
-}
-
 //#endregion
 //#region src/url-schema/vendored/hashline/guidance/parse.js
 /**
@@ -9847,7 +9769,6 @@ function installAgentTools(rootCtx, agent, resolver) {
 		const hashlineIo = ctxFsIO(rootCtx.fs, rootCtx);
 		disposers.push(registerEditTool(rootCtx, agent.ctx, hashlineIo, hashlineSandbox));
 		disposers.push(registerUndoTool(rootCtx, agent.ctx, hashlineIo, hashlineSandbox));
-		disposers.push(registerWriteHook(rootCtx, agent.ctx, hashlineIo));
 		{
 			const diagnosticsHook = buildLspWriteFeedback().postWrite;
 			disposers.push(agent.ctx.on("tools/post-execute", async (exec, result, next) => {
@@ -11754,7 +11675,7 @@ function apply(ctx, config) {
 				if (session === void 0) return "";
 				const sandboxPolicy = runtimeCtx.get("sandboxPolicy");
 				if (!sandboxPolicy) return "";
-				return sandboxPolicy.resolve({ session }).mode === "workspace-write" ? "Restricted operations may be retried once with sandbox_permissions for single-call escalation, pending user approval." : "";
+				return sandboxPolicy.resolve({ session }).mode === "workspace-write" ? "A sandbox-deniable/denied call may be escalated with `sandbox_permissions=\"danger-full-access\"` and a one-line `justification`; the runtime will prompt for user approval. Escalation and its approval/denial are per-call." : "";
 			}
 		});
 	});