@dsh-electron/dsh-plugin-multi-root-workspace 0.1.13 → 0.1.15

package/lib/{instructions-KsUwUFE0.js → instructions-Ck9wp4J4.js}

@@ -1,8 +1,10 @@
 import { t as effectiveDirectory } from "./session-directory-BLOstut1.js";
 import { c as withRegistryRead, s as withRegistryAdmission } from "./registry-operation-C2ZV3Jhw.js";
-import { n as instructionsApi, t as createInstructionMessage } from "./llm-message-fYORacvh.js";
-import { t as aroundTool } from "./tool-context-CpgIFcCB.js";
-import { l as isCanonicallyUnder } from "./roots-Ca_W1S9n.js";
+import { t as instructionsApi } from "./agent-instructions-BXuKhOzr.js";
+import { t as createInstructionMessage } from "./llm-message-CepyzEBQ.js";
+import { t as aroundTool } from "./tool-context-CCeY3mrK.js";
+import { r as opsCompatibilityToken } from "./ops-settings-UN2oOKEp.js";
+import { l as isCanonicallyUnder } from "./roots-CmaWxRVy.js";
 import { createHash } from "node:crypto";
 import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import "@deepseek-ai/cordis";
@@ -45,11 +47,96 @@ function ptcFileActivity(event) {
 		failed: data.isError !== false || data.error !== void 0
 	};
 }
+const OPS_STABLE_MAX_BYTES = 2097152;
+function stableOpsJson(value) {
+	const seen = /* @__PURE__ */ new Set();
+	let nodes = 0, bytes = 0;
+	const over = () => {
+		throw new Error("multi-root workspace: OPS fingerprint exceeded its budget");
+	};
+	const walk = (entry, depth) => {
+		if (depth > 24) over();
+		nodes += 1;
+		if (nodes > 65536) over();
+		if (entry === void 0) over();
+		if (entry === null || typeof entry === "string" || typeof entry === "boolean") {
+			if (typeof entry === "string") {
+				bytes += entry.length;
+				if (bytes > OPS_STABLE_MAX_BYTES) over();
+			}
+			return entry;
+		}
+		if (typeof entry === "number") {
+			if (!Number.isFinite(entry)) over();
+			return entry;
+		}
+		if (typeof entry !== "object" || entry === null) over();
+		const obj = entry;
+		if (seen.has(obj)) over();
+		seen.add(obj);
+		if (Array.isArray(obj)) {
+			const out = obj.map((item) => walk(item, depth + 1));
+			seen.delete(obj);
+			return out;
+		}
+		const keys = Object.keys(obj);
+		if (keys.length > 4096) over();
+		for (const key of keys) {
+			bytes += key.length;
+			if (bytes > OPS_STABLE_MAX_BYTES) over();
+		}
+		const out = Object.fromEntries(keys.sort().map((key) => [key, walk(obj[key], depth + 1)]));
+		seen.delete(obj);
+		return out;
+	};
+	const json = JSON.stringify(walk(value, 0));
+	if (json === void 0 || Buffer.byteLength(json, "utf8") > OPS_STABLE_MAX_BYTES) over();
+	return json;
+}
+const OPS_OPSID = (kind, id, name, args) => JSON.stringify([
+	kind,
+	id,
+	name,
+	createHash("sha256").update(stableOpsJson(args)).digest("hex")
+]);
+const opsActivityEvidenceKey = OPS_OPSID;
+const OPS_PUBLISH = {
+	ops_discover_tools: true,
+	ops_load_sdk: true
+};
 /** Rebuild read-only discovery candidates from successful durable activity after resume. */
-function replayedInstructionTargets(events, origin) {
+function replayedInstructionTargets(events, origin, liveOpsEvidence, pendingExec, options) {
+	const opsOn = options?.opsCompatibility === true;
 	let cwd = origin;
 	const pending = /* @__PURE__ */ new Map();
+	const eventsPrior = /* @__PURE__ */ new Map();
+	const ended = /* @__PURE__ */ new Set();
 	const paths = /* @__PURE__ */ new Set();
+	const isCurrentExec = (call) => {
+		if (pendingExec === void 0 || call.name !== pendingExec.name) return false;
+		const kind = pendingExec.parent === void 0 ? "native" : "ptc";
+		if (call.kind !== kind || call.id !== pendingExec.callId) return false;
+		let parsed;
+		try {
+			parsed = JSON.parse(call.arguments);
+			return stableOpsJson(parsed) === stableOpsJson(pendingExec.arguments);
+		} catch {
+			return false;
+		}
+	};
+	const opsEntry = (call) => {
+		if (liveOpsEvidence === void 0) throw new Error("review-context: OPS file activity lacks live evidence");
+		let parsed;
+		try {
+			parsed = JSON.parse(call.arguments);
+		} catch {
+			throw new Error("review-context: incomplete durable OPS arguments");
+		}
+		const entry = liveOpsEvidence.get(OPS_OPSID(call.kind, call.id, call.name, parsed));
+		if (entry === void 0) throw new Error("review-context: OPS file activity lacks live evidence");
+		if (entry.complete !== true) throw new Error("review-context: incomplete OPS file activity evidence");
+		return entry;
+	};
 	for (const raw of events) {
 		const event = raw;
 		if (event.type === "working-directory/change" && typeof event.data.cwd === "string") {
@@ -65,7 +152,13 @@ function replayedInstructionTargets(events, origin) {
 				arguments: ptc.arguments
 			} : event.data;
 			if (typeof call.callId !== "string" || typeof call.name !== "string" || typeof call.arguments !== "string") throw new Error("review-context: incomplete durable file activity");
-			pending.set(call.callId, {
+			const kind = ptc?.kind === "start" ? "ptc" : "native";
+			const id = ptc?.kind === "start" ? ptc.id.slice(4) : call.callId;
+			const key = JSON.stringify([kind, id]);
+			if (opsOn && call.name.startsWith("ops_") && (pending.has(key) || ended.has(key))) throw new Error("review-context: duplicate durable OPS call");
+			pending.set(key, {
+				kind,
+				id,
 				name: call.name,
 				arguments: call.arguments,
 				directories: new Set(cwd === void 0 ? [] : [cwd])
@@ -75,12 +168,32 @@ function replayedInstructionTargets(events, origin) {
 		}
 		if (event.type !== "tool/result" && ptc?.kind !== "end") continue;
 		const message = event.data.message;
-		const id = ptc?.kind === "end" ? ptc.id : message?.source?.callId;
-		if (typeof id !== "string") throw new Error("review-context: incomplete durable result");
-		const call = pending.get(id);
-		pending.delete(id);
-		if (call === void 0) continue;
-		if (ptc?.kind === "end" ? ptc.failed : event.data.error !== void 0 || toolResultFailed(message ?? {})) continue;
+		const rawId = ptc?.kind === "end" ? ptc.id : message?.source?.callId;
+		if (typeof rawId !== "string") throw new Error("review-context: incomplete durable result");
+		const kind = ptc?.kind === "end" ? "ptc" : "native";
+		const id = ptc?.kind === "end" ? ptc.id.slice(4) : rawId;
+		const key = JSON.stringify([kind, id]);
+		const call = pending.get(key);
+		if (call === void 0) {
+			const prior = eventsPrior.get(key);
+			if (opsOn && prior !== void 0 && prior.name.startsWith("ops_") && OPS_PUBLISH[prior.name] !== true) throw new Error("review-context: duplicate durable OPS result");
+			continue;
+		}
+		pending.delete(key);
+		if (opsOn && call.name.startsWith("ops_") && OPS_PUBLISH[call.name] !== true) {
+			eventsPrior.set(key, call);
+			ended.add(key);
+			if (ended.size > 512) throw new Error("review-context: durable OPS result index exceeded");
+		}
+		const failed = ptc?.kind === "end" ? ptc.failed : event.data.error !== void 0 || toolResultFailed(message ?? {});
+		if (opsOn && call.name.startsWith("ops_") && OPS_PUBLISH[call.name] !== true) {
+			const entry = opsEntry(call);
+			if (failed && entry.targets.length > 0) throw new Error("review-context: OPS activity contradicts its durable failure");
+			for (const target of entry.targets) paths.add(target.path);
+			if (paths.size > 512) throw new Error("review-context: durable work index exceeded");
+			continue;
+		}
+		if (failed) continue;
 		const path = touchedPathOfToolCall(call.name, call.arguments);
 		if (path === void 0) continue;
 		if (isAbsolute(path)) paths.add(path);
@@ -90,6 +203,12 @@ function replayedInstructionTargets(events, origin) {
 		}
 		if (paths.size > 512) throw new Error("review-context: durable work index exceeded");
 	}
+	for (const call of pending.values()) {
+		if (!call.name.startsWith("ops_") || OPS_PUBLISH[call.name] === true) continue;
+		if (!opsOn) continue;
+		if (isCurrentExec(call)) continue;
+		throw new Error("review-context: OPS file activity has no final result");
+	}
 	return [...paths];
 }
 /** fs tools whose success touches the file at their `file_path` argument. */
@@ -110,6 +229,344 @@ function touchedPathOfToolCall(name, argumentsJson) {
 	if (typeof parsed !== "object" || parsed === null || !("file_path" in parsed) || typeof parsed.file_path !== "string") return void 0;
 	return parsed.file_path.trim() || void 0;
 }
+const OPS_READ_TARGETS = {
+	inspect_local_file: true,
+	stat: true,
+	read_files: true
+};
+const OPS_WRITE_TARGETS = {
+	write_file: true,
+	edit_file: true,
+	replace: true,
+	copy: true
+};
+const OPS_TARGETS = {
+	...OPS_READ_TARGETS,
+	...OPS_WRITE_TARGETS,
+	move: true,
+	remove: true
+};
+function record(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function canonicalize(path) {
+	if (!isAbsolute(path)) return void 0;
+	try {
+		return canonicalPath(path);
+	} catch {
+		return;
+	}
+}
+function itemPath(item) {
+	if (!record(item) || typeof item.path !== "string" || item.path === "") return void 0;
+	return item.path;
+}
+function canonicalizeArg(path, cwd) {
+	if (typeof path !== "string" || path.trim() === "") return void 0;
+	const absolute = isAbsolute(path) ? path : cwd === void 0 ? void 0 : resolve(cwd, path);
+	return absolute === void 0 ? void 0 : canonicalize(absolute);
+}
+function requestCanonicals(name, args, cwd) {
+	if (!record(args)) return void 0;
+	if (name === "ops_read_files") {
+		if (!Array.isArray(args.files) || args.files.length === 0 || args.files.length > 32) return void 0;
+		const paths = args.files.map((file) => canonicalizeArg(record(file) ? file.path : void 0, cwd));
+		return paths.every((path) => path !== void 0) ? paths : void 0;
+	}
+	const path = canonicalizeArg(args.path, cwd);
+	if (path === void 0) return void 0;
+	const to = name === "ops_copy" || name === "ops_move" ? canonicalizeArg(args.to, cwd) : void 0;
+	if ((name === "ops_copy" || name === "ops_move") && to === void 0) return void 0;
+	return to === void 0 ? [path] : [path, to];
+}
+function observed(observedPaths, path) {
+	const canonical = canonicalize(path);
+	return canonical !== void 0 && observedPaths.some((candidate) => canonicalize(candidate) === canonical);
+}
+const REVISION = /^[0-9a-f]{64}$/;
+const safeBytes = (value) => typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+function dedupe(targets) {
+	const seen = /* @__PURE__ */ new Set();
+	return targets.filter((target) => {
+		const key = `${target.kind}:${canonicalize(target.path) ?? target.path}`;
+		if (seen.has(key)) return false;
+		seen.add(key);
+		return true;
+	});
+}
+const inside = (directory, path) => {
+	const rel = relative(directory, path);
+	return rel !== "" && !rel.startsWith("..") && !isAbsolute(rel);
+};
+function normalizeOpsFileActivity(input) {
+	const bare = input.name.startsWith("ops_") ? input.name.slice(4) : void 0;
+	if (bare === void 0 || OPS_TARGETS[bare] !== true) return {
+		targets: [],
+		complete: false
+	};
+	const value = input.finalValue;
+	if (input.isError === true) return {
+		targets: [],
+		complete: record(value) && record(value.error) && value.error.effectState === "none"
+	};
+	if (!record(value) || typeof value.status !== "string") return {
+		targets: [],
+		complete: false
+	};
+	if (value.status === "error") return {
+		targets: [],
+		complete: (record(value.error) ? value.error.effectState : void 0) === "none"
+	};
+	if (value.status !== "completed" && value.status !== "partial") return {
+		targets: [],
+		complete: false
+	};
+	const receipt = "data" in value ? record(value.data) ? value.data : void 0 : value;
+	if (!record(receipt)) return {
+		targets: [],
+		complete: false
+	};
+	const outerPartial = value.status === "partial";
+	if (record(value.error) || record(receipt.error) || typeof receipt.status === "string" && receipt.status !== "completed" && receipt.status !== "partial") return {
+		targets: [],
+		complete: false
+	};
+	const outerCwd = typeof receipt.resolvedFrom === "string" ? receipt.resolvedFrom : void 0;
+	if (outerCwd !== void 0 && input.cwd !== void 0 && canonicalize(outerCwd) !== canonicalize(input.cwd)) return {
+		targets: [],
+		complete: false
+	};
+	const proven = (path) => {
+		if (path === void 0) return void 0;
+		const canonical = canonicalize(path);
+		return canonical !== void 0 && observed(input.observedPaths, canonical) ? canonical : void 0;
+	};
+	if (OPS_WRITE_TARGETS[bare] === true || bare === "move" || bare === "remove") {
+		const args = record(input.args) ? input.args : {};
+		if (receipt.status !== "completed") return {
+			targets: [],
+			complete: false
+		};
+		if (record(receipt.error)) return {
+			targets: [],
+			complete: false
+		};
+		if (args.dryRun === true || receipt.dryRun === true || receipt.planned === true) return {
+			targets: [],
+			complete: true
+		};
+		if (receipt.phase !== "verify") return {
+			targets: [],
+			complete: false
+		};
+		if (receipt.changed === 0) return {
+			targets: [],
+			complete: true
+		};
+		if (typeof receipt.changed !== "number" || !Number.isSafeInteger(receipt.changed) || receipt.changed <= 0) return {
+			targets: [],
+			complete: false
+		};
+		const items = Array.isArray(receipt.items) ? receipt.items : void 0;
+		if (items === void 0 || items.length === 0) return {
+			targets: [],
+			complete: false
+		};
+		const request = requestCanonicals(input.name, input.args, input.cwd);
+		const targets = [];
+		let unproven = false;
+		let destProven = false;
+		let sourceProven = false;
+		for (const item of items) {
+			const path = itemPath(item);
+			const canonical = proven(path);
+			if (path === void 0 || canonical === void 0) {
+				unproven = true;
+				continue;
+			}
+			if (record(item) && record(item.error)) {
+				unproven = true;
+				continue;
+			}
+			if (record(item) && item.removed === true) {
+				if ((bare === "move" || bare === "remove") && request !== void 0 && request[0] === canonical) {
+					targets.push({
+						path: canonical,
+						kind: "remove"
+					});
+					sourceProven = true;
+				} else unproven = true;
+				continue;
+			}
+			if (bare === "remove") {
+				unproven = true;
+				continue;
+			}
+			const bytesAfter = record(item) && safeBytes(item.bytesAfter);
+			const revision = record(item) && (typeof item.revision === "string" && REVISION.test(item.revision) || typeof item.revisionAfter === "string" && REVISION.test(item.revisionAfter));
+			if (!bytesAfter || !revision) {
+				unproven = true;
+				continue;
+			}
+			if (!(bare === "replace" ? request !== void 0 && (request[0] === canonical || inside(request[0], canonical)) : request !== void 0 && request[bare === "copy" || bare === "move" ? 1 : 0] === canonical)) {
+				unproven = true;
+				continue;
+			}
+			targets.push({
+				path: canonical,
+				kind: "write"
+			});
+			destProven = true;
+		}
+		if (bare === "move" && (!destProven || !sourceProven)) unproven = true;
+		const complete = !unproven && !outerPartial && receipt.complete === true && (receipt.failed === void 0 || receipt.failed === 0) && (receipt.pending === void 0 || receipt.pending === 0);
+		return {
+			targets: dedupe(targets),
+			complete
+		};
+	}
+	if (bare === "stat") {
+		const canonical = proven(itemPath(receipt));
+		const request = canonicalizeArg(record(input.args) ? input.args.path : void 0, input.cwd);
+		const provenStat = canonical !== void 0 && receipt.exists === true && typeof receipt.revision === "string" && REVISION.test(receipt.revision) && safeBytes(receipt.bytes) && request === canonical;
+		return {
+			targets: provenStat ? [{
+				path: canonical,
+				kind: "read"
+			}] : [],
+			complete: provenStat === true && receipt.complete === true
+		};
+	}
+	const topItems = Array.isArray(receipt.items) ? receipt.items : void 0;
+	if (topItems === void 0 && bare === "inspect_local_file") return {
+		targets: [],
+		complete: false
+	};
+	const requests = requestCanonicals(input.name, input.args, input.cwd);
+	const targets = [];
+	let unproven = false;
+	if (bare === "read_files") {
+		if (topItems === void 0 || requests === void 0) return {
+			targets: [],
+			complete: false
+		};
+		const provenIndexes = /* @__PURE__ */ new Set();
+		for (const [index, item] of topItems.entries()) {
+			if (!record(item) || item.status !== "completed" || record(item.error)) {
+				unproven = true;
+				continue;
+			}
+			const canonical = proven(itemPath(item));
+			const expected = requests[index];
+			if (canonical === void 0 || expected === void 0 || canonical !== expected) {
+				unproven = true;
+				continue;
+			}
+			if (typeof item.revision !== "string" || !REVISION.test(item.revision) || !safeBytes(item.bytes)) {
+				unproven = true;
+				continue;
+			}
+			provenIndexes.add(index);
+			targets.push({
+				path: canonical,
+				kind: "read"
+			});
+		}
+		for (const index of requests.keys()) if (!provenIndexes.has(index)) unproven = true;
+		const complete = !unproven && !outerPartial && provenIndexes.size === requests.length && receipt.complete === true && (receipt.failed === void 0 || receipt.failed === 0) && (receipt.pending === void 0 || receipt.pending === 0);
+		return {
+			targets: dedupe(targets),
+			complete
+		};
+	}
+	if (receipt.status !== "completed" || record(receipt.error)) return {
+		targets: [],
+		complete: false
+	};
+	const rows = topItems ?? [];
+	const request = requests?.[0];
+	let path = proven(itemPath(receipt));
+	let unprovenRow = false;
+	for (const row of rows) {
+		if (!record(row) || record(row.error)) {
+			unprovenRow = true;
+			continue;
+		}
+		const rowPath = proven(itemPath(row));
+		if (rowPath === void 0) {
+			unprovenRow = true;
+			continue;
+		}
+		const textRow = Number.isSafeInteger(row.line) && row.line > 0 && typeof row.text === "string";
+		const hexRow = row.view === "hex" && Number.isSafeInteger(row.offset) && row.offset >= 0 && typeof row.text === "string";
+		if (!textRow && !hexRow) {
+			unprovenRow = true;
+			continue;
+		}
+		if (path === void 0) path = rowPath;
+		else if (path !== rowPath) unprovenRow = true;
+	}
+	const provenInspect = path !== void 0 && request === path && !unprovenRow && typeof receipt.revision === "string" && REVISION.test(receipt.revision) && safeBytes(receipt.bytes);
+	return {
+		targets: provenInspect === true ? [{
+			path,
+			kind: "read"
+		}] : [],
+		complete: provenInspect === true && receipt.complete === true && !outerPartial
+	};
+}
+const PENDING_EMPTY = {
+	discover_tools: true,
+	load_sdk: true
+};
+const PENDING_PATH = {
+	inspect_local_file: true,
+	stat: true,
+	read_table: true,
+	read_docx: true,
+	read_pdf: true,
+	write_file: true,
+	edit_file: true,
+	remove: true
+};
+const PENDING_PAIR = {
+	copy: true,
+	move: true
+};
+function pendingInstructionTargets(name, args) {
+	if (FILE_TOUCH_TOOL_NAMES[name] === true) {
+		const parsed = typeof args === "string" ? (() => {
+			try {
+				return JSON.parse(args);
+			} catch {
+				return;
+			}
+		})() : args;
+		if (!record(parsed) || typeof parsed.file_path !== "string" || parsed.file_path.trim() === "") return [];
+		return [parsed.file_path.trim()];
+	}
+	if (!name.startsWith("ops_")) return [];
+	const bare = name.slice(4);
+	if (PENDING_EMPTY[bare] === true) return [];
+	if (!record(args)) throw new Error(`review-context: ${name} arguments are incomplete`);
+	if (bare === "read_files") {
+		if (!Array.isArray(args.files) || args.files.length === 0 || args.files.length > 32) throw new Error(`review-context: ${name} files argument is incomplete`);
+		return args.files.map((file) => {
+			if (!record(file) || typeof file.path !== "string" || file.path.trim() === "") throw new Error(`review-context: ${name} files argument is incomplete`);
+			return file.path.trim();
+		});
+	}
+	if (PENDING_PAIR[bare] === true) {
+		const paths = [args.path, args.to];
+		if (paths.some((path) => typeof path !== "string" || path.trim() === "")) throw new Error(`review-context: ${name} path arguments are incomplete`);
+		return paths.map((path) => path.trim());
+	}
+	if (PENDING_PATH[bare] === true) {
+		if (typeof args.path !== "string" || args.path.trim() === "") throw new Error(`review-context: ${name} path argument is incomplete`);
+		return [args.path.trim()];
+	}
+	throw new Error(`review-context: ${name} has dynamic instruction targets that cannot be determined`);
+}
 //#endregion
 //#region src/compat/instruction-overlap.ts
 /** Recognize files already represented by the native instruction baseline in this step. */
@@ -216,6 +673,9 @@ const DEFAULT_MAX_BYTES = 65536;
 const DEFAULT_MAX_SOURCE_BYTES = 32768;
 /** Cap on unanswered `tool/call` records remembered per session. */
 const MAX_PENDING_CALLS = 128;
+const MAX_LIVE_OPS_CALLS = 128;
+const MAX_LIVE_OPS_OBSERVED = 64;
+const MAX_LIVE_OPS_EVIDENCE = 128;
 /** Cap on touched paths remembered per session; beyond it, touches are dropped. */
 const MAX_TOUCHED_PATHS = 64;
 /** Cap on delivered scopes remembered per session; beyond it, nested scopes stop. */
@@ -310,7 +770,199 @@ function apply(ctx, config = {}) {
 	const states = /* @__PURE__ */ new WeakMap();
 	const callsBySession = /* @__PURE__ */ new WeakMap();
 	const executions = new AsyncLocalStorage();
-	aroundTool(ctx, (exec, next) => executions.run(exec, next));
+	const fingerprintOf = (value) => createHash("sha256").update(stableOpsJson(value)).digest("hex");
+	const record = (value) => value !== null && typeof value === "object";
+	const keyOf = (exec) => exec.token ?? exec;
+	let disposed = false;
+	const opsLive = /* @__PURE__ */ new Map();
+	const removeEntry = (key) => {
+		const call = opsLive.get(key);
+		if (call === void 0) return void 0;
+		if (call.signal !== void 0 && call.abort !== void 0) call.signal.removeEventListener("abort", call.abort);
+		opsLive.delete(key);
+		return call;
+	};
+	const boundedLiveSet = (key, call) => {
+		if (opsLive.size >= MAX_LIVE_OPS_CALLS) {
+			const oldest = opsLive.keys().next();
+			if (!oldest.done) {
+				const evicted = removeEntry(oldest.value);
+				if (evicted !== void 0 && evicted.mode === opsCompatibilityToken(ctx)) stateOf(evicted.session).activityIncomplete = true;
+			}
+		}
+		opsLive.set(key, call);
+	};
+	const putEvidence = (state, key, entry) => {
+		const existing = state.liveOpsEvidence.get(key);
+		if (existing !== void 0) {
+			if (existing.complete === entry.complete && JSON.stringify(existing.targets) === JSON.stringify(entry.targets)) return;
+			if (existing.complete === true) {
+				state.activityIncomplete = true;
+				return;
+			}
+		} else if (state.liveOpsEvidence.size >= MAX_LIVE_OPS_EVIDENCE) {
+			const oldest = state.liveOpsEvidence.keys().next();
+			if (!oldest.done) state.liveOpsEvidence.delete(oldest.value);
+			state.activityIncomplete = true;
+		}
+		state.liveOpsEvidence.set(key, entry);
+	};
+	const mark = (call) => {
+		if (call.mode !== opsCompatibilityToken(ctx)) return;
+		const state = stateOf(call.session);
+		state.activityIncomplete = true;
+		try {
+			putEvidence(state, opsActivityEvidenceKey(call.kind, call.callId, call.name, call.args), {
+				targets: [],
+				complete: false
+			});
+		} catch (error) {
+			ctx.logger.warn(`multi-root instructions: OPS activity key failed: ${error.message}`);
+		}
+	};
+	aroundTool(ctx, (exec, next) => executions.run(exec, () => runLive(exec, next)));
+	const runLive = async (exec, next) => {
+		const agent = exec.agent;
+		const bare = exec.name.startsWith("ops_") ? exec.name.slice(4) : "";
+		const modeToken = opsCompatibilityToken(ctx);
+		if (bare === "" || bare === "discover_tools" || bare === "load_sdk" || agent === void 0 || disposed || modeToken === void 0) return await next();
+		let argsJson = "";
+		let incomplete = false;
+		try {
+			argsJson = stableOpsJson(exec.arguments);
+		} catch {
+			incomplete = true;
+		}
+		const directories = ctx.get("workingDirectory");
+		const ensured = directories === void 0 ? void 0 : await directories.ensure(agent, exec.signal).catch(() => void 0);
+		if (disposed || opsCompatibilityToken(ctx) !== modeToken) return await next();
+		const cwd = ensured ?? effectiveDirectory(ctx, agent.session) ?? agent.session?.header?.cwd;
+		const call = {
+			exec,
+			session: agent.session,
+			agent,
+			token: keyOf(exec),
+			kind: exec.parent === void 0 ? "native" : "ptc",
+			callId: exec.callId,
+			name: exec.name,
+			args: incomplete ? void 0 : JSON.parse(argsJson),
+			argsJson,
+			cwd,
+			observed: /* @__PURE__ */ new Set(),
+			incomplete,
+			signal: exec.signal,
+			mode: modeToken
+		};
+		if (exec.signal?.aborted === true) {
+			mark(call);
+			return await next();
+		}
+		boundedLiveSet(call.token, call);
+		call.abort = () => {
+			const removed = removeEntry(call.token);
+			if (removed !== void 0) mark(removed);
+		};
+		call.signal?.addEventListener("abort", call.abort);
+		let result;
+		try {
+			result = await next();
+		} catch (error) {
+			removeEntry(call.token);
+			throw error;
+		}
+		if (call.mode !== opsCompatibilityToken(ctx)) {
+			removeEntry(call.token);
+			return result;
+		}
+		try {
+			const raw = result !== null && typeof result === "object" && "value" in result ? result.value : result;
+			call.fingerprint = fingerprintOf(raw);
+		} catch {
+			call.incomplete = true;
+			ctx.logger.warn("multi-root instructions: OPS activity fingerprint exceeded its budget");
+		}
+		return result;
+	};
+	ctx.on.call(ctx, "tools/result", (exec, result) => {
+		const call = removeEntry(keyOf(exec));
+		if (call === void 0) return;
+		if (call.mode !== opsCompatibilityToken(ctx)) return;
+		try {
+			const final = result;
+			const sameArgs = (() => {
+				try {
+					return stableOpsJson(exec.arguments) === call.argsJson;
+				} catch {
+					return false;
+				}
+			})();
+			const identity = exec === call.exec && keyOf(exec) === call.token && exec.agent?.session === call.session && exec.name === call.name && exec.callId === call.callId && sameArgs && exec.signal?.aborted !== true && !disposed && call.incomplete !== true;
+			const effectNone = final.isError === true && record(final.value) && record(final.value.error) && final.value.error.effectState === "none";
+			if (!identity || call.fingerprint === void 0) {
+				mark(call);
+				return;
+			}
+			let same = false;
+			try {
+				same = fingerprintOf(final.value) === call.fingerprint;
+			} catch {
+				ctx.logger.warn("multi-root instructions: OPS final fingerprint exceeded its budget");
+			}
+			if (!same) {
+				mark(call);
+				return;
+			}
+			if (final.isError === true) {
+				if (effectNone === true) try {
+					putEvidence(stateOf(call.session), opsActivityEvidenceKey(call.kind, call.callId, call.name, call.args), {
+						targets: [],
+						complete: true
+					});
+				} catch {
+					mark(call);
+				}
+				else mark(call);
+				return;
+			}
+			const activity = normalizeOpsFileActivity({
+				name: call.name,
+				args: call.args,
+				cwd: call.cwd,
+				finalValue: final.value,
+				observedPaths: [...call.observed]
+			});
+			const state = stateOf(call.session);
+			if (!activity.complete) state.activityIncomplete = true;
+			for (const target of activity.targets) {
+				if (state.worked.size >= MAX_DELIVERED_SCOPES && !state.worked.has(target.path)) state.overflow = true;
+				else state.worked.add(target.path);
+				if (state.touched.size >= MAX_TOUCHED_PATHS) state.overflow = true;
+				else state.touched.add(target.path);
+			}
+			try {
+				putEvidence(state, opsActivityEvidenceKey(call.kind, call.callId, call.name, call.args), {
+					targets: activity.targets,
+					complete: activity.complete
+				});
+			} catch {
+				mark(call);
+			}
+		} catch (error) {
+			ctx.logger.warn(`multi-root instructions: live OPS activity observer failed: ${error.message}`);
+			mark(call);
+		}
+	}, { global: true });
+	const onDispose = ctx.on;
+	onDispose.call(ctx, "agent/disposed", (payload) => {
+		for (const [key, call] of [...opsLive]) if (call.agent === payload.agent) removeEntry(key);
+	}, { global: true });
+	onDispose.call(ctx, "session/disposed", (session) => {
+		for (const [key, call] of [...opsLive]) if (call.session === session) removeEntry(key);
+	}, { global: true });
+	ctx.effect(() => () => {
+		disposed = true;
+		for (const key of [...opsLive.keys()]) removeEntry(key);
+	});
 	const stateOf = (session) => {
 		const existing = states.get(session);
 		if (existing !== void 0) return existing;
@@ -318,7 +970,8 @@ function apply(ctx, config = {}) {
 			scopes: /* @__PURE__ */ new Map(),
 			provenanceRoots: /* @__PURE__ */ new Set(),
 			touched: /* @__PURE__ */ new Set(),
-			worked: /* @__PURE__ */ new Set()
+			worked: /* @__PURE__ */ new Set(),
+			liveOpsEvidence: /* @__PURE__ */ new Map()
 		};
 		states.set(session, created);
 		return created;
@@ -367,16 +1020,16 @@ function apply(ctx, config = {}) {
 			knownRoots(session) {
 				return [...states.get(session)?.provenanceRoots ?? []];
 			},
-			async snapshot(agent, roots, target, signal) {
-				return withRegistryRead(scope, scope.sandboxPolicy.resolve({ session: agent.session }).workspaceRoot, "instructions", async () => {
+			async snapshot(agent, roots, target, signal, pending) {
+				const modeToken = opsCompatibilityToken(scope);
+				const snapshot = await withRegistryRead(scope, scope.sandboxPolicy.resolve({ session: agent.session }).workspaceRoot, "instructions", async () => {
+					if (opsCompatibilityToken(scope) !== modeToken) throw new Error("review-context: OPS compatibility changed during the snapshot; retry");
 					const allowed = new Set(scope.multiRootScope.scopeOf(scope.sandboxPolicy.resolve({ session: agent.session }).workspaceRoot));
 					roots = roots.filter((root) => allowed.has(root));
 					signal.throwIfAborted();
-					if (roots.length === 0) return [];
-					const api = await instructionsApi();
-					if (api === void 0) throw new Error("review-context: instruction discovery unavailable");
 					const existing = states.get(agent.session);
 					if (existing?.overflow) throw new Error("review-context: successful work index exceeded");
+					if (modeToken !== void 0 && existing?.activityIncomplete === true) throw new Error("review-context: incomplete OPS file activity");
 					const state = {
 						scopes: new Map([...existing?.scopes ?? []].map(([key, value]) => [key, {
 							...value,
@@ -384,10 +1037,15 @@ function apply(ctx, config = {}) {
 						}])),
 						provenanceRoots: new Set(existing?.provenanceRoots),
 						touched: /* @__PURE__ */ new Set([...existing?.touched ?? [], ...existing?.worked ?? []]),
-						worked: /* @__PURE__ */ new Set()
+						worked: /* @__PURE__ */ new Set(),
+						liveOpsEvidence: new Map(existing?.liveOpsEvidence ?? [])
 					};
-					for (const path of replayedInstructionTargets(agent.session.snapshotEvents(), agent.session.header.cwd)) state.touched.add(path);
-					if (target !== void 0) state.touched.add(target);
+					for (const path of replayedInstructionTargets(agent.session.snapshotEvents(), agent.session.header.cwd, modeToken === void 0 ? void 0 : existing?.liveOpsEvidence, modeToken === void 0 ? void 0 : pending, { opsCompatibility: modeToken !== void 0 })) state.touched.add(path);
+					const targets = typeof target === "string" ? [target] : target ?? [];
+					for (const item of targets) state.touched.add(item);
+					if (roots.length === 0) return [];
+					const api = await instructionsApi();
+					if (api === void 0) throw new Error("review-context: instruction discovery unavailable");
 					const cwd = effectiveDirectory(scope, agent.session);
 					const reviewCwd = cwd === void 0 ? void 0 : canonicalPath(cwd);
 					const result = [];
@@ -403,17 +1061,27 @@ function apply(ctx, config = {}) {
 					}
 					signal.throwIfAborted();
 					if (Buffer.byteLength(JSON.stringify(result), "utf8") > maxBytes) throw new Error("review-context: instruction budget exceeded");
+					if (opsCompatibilityToken(scope) !== modeToken) throw new Error("review-context: OPS compatibility changed during the snapshot; retry");
 					return result;
 				});
+				if (opsCompatibilityToken(scope) !== modeToken) throw new Error("review-context: OPS compatibility changed during the snapshot; retry");
+				return snapshot;
 			}
 		});
-		scope.on("fs/observed", (target, _observation, actor) => {
+		scope.on.call(scope, "fs/observed", (target, _observation, actor) => {
 			const exec = executions.getStore();
-			if (exec?.agent === void 0 || FILE_TOUCH_TOOL_NAMES[exec.name] !== true || actor !== exec) return;
+			if (exec?.agent === void 0 || actor !== exec) return;
+			const live = opsLive.get(keyOf(exec));
+			if (live !== void 0 && live.mode === opsCompatibilityToken(ctx)) {
+				if (live.observed.size < MAX_LIVE_OPS_OBSERVED) live.observed.add(scope.fs.processPath(target));
+				else live.incomplete = true;
+				return;
+			}
+			if (FILE_TOUCH_TOOL_NAMES[exec.name] !== true) return;
 			const calls = callsBySession.get(exec.agent.session);
 			const call = calls?.get(exec.callId) ?? calls?.get(`ptc:${exec.callId}`);
 			if (call !== void 0) call.observedPath = scope.fs.processPath(target);
-		});
+		}, { global: true });
 		scope.on("agent/pre-step", async ({ agent, messages, signal }, next) => {
 			const decision = await next();
 			if (decision.kind !== "enter") return decision;
@@ -448,7 +1116,8 @@ async function pending(ctx, states, agent, config, maxBytes, signal, messages, r
 		scopes: /* @__PURE__ */ new Map(),
 		provenanceRoots: /* @__PURE__ */ new Set(),
 		touched: /* @__PURE__ */ new Set(),
-		worked: /* @__PURE__ */ new Set()
+		worked: /* @__PURE__ */ new Set(),
+		liveOpsEvidence: /* @__PURE__ */ new Map()
 	};
 	states.set(session, state);
 	const evaluatedTouches = new Set(state.touched);
@@ -747,4 +1416,4 @@ async function loadDirectory(fs, api, root, config, signal, cwd, strict = false)
 	};
 }
 //#endregion
-export { composeInstructionMessage as a, apply as i, DEFAULT_MAX_SOURCE_BYTES as n, inject as o, PLUGIN_SOURCE as r, touchedPathOfToolCall as s, DEFAULT_MAX_BYTES as t };
+export { composeInstructionMessage as a, stableOpsJson as c, apply as i, touchedPathOfToolCall as l, DEFAULT_MAX_SOURCE_BYTES as n, inject as o, PLUGIN_SOURCE as r, pendingInstructionTargets as s, DEFAULT_MAX_BYTES as t };