@dsh-electron/dsh-plugin-multi-root-workspace 0.1.8 → 0.1.10

package/lib/llm-message-fYORacvh.js

@@ -0,0 +1,206 @@
+import { createRequire } from "node:module";
+//#region src/compat/agent-instructions.ts
+/**
+* Compatibility adapter for upstream's instruction discovery and rendering.
+*
+* `@deepseek-ai/dsh-agent-instructions` renamed its renderer between two
+* releases this plugin supports, without changing its signature:
+*
+* ```text
+* 0.1.5-rc.2     renderWorkspaceContext(files, options)   RenderedWorkspaceContext
+* 0.1.6-alpha.1  renderAgentInstructions(files, options)  RenderedAgentInstructions
+* ```
+*
+* `discoverBaselineInstructionFiles` kept both its name and its signature.
+*
+* All coupling to that package is concentrated here so the business layer
+* (`src/instructions.ts`) only ever calls {@link renderInstructions} and
+* {@link InstructionsApi.discover}. A future rename is one edit in this file,
+* not a version check sprinkled through the provider.
+*
+* The export is picked by NAME rather than by comparing the release string:
+* a structural probe also copes with upstream keeping both names for a release,
+* or reshaping within one, which a version comparison does not.
+*
+* The package is loaded LAZILY, and its genuine ABSENCE is reported as absence
+* rather than thrown. It is an optional peer: the default DSH bundle mounts it,
+* but a minimal composition legitimately has neither it nor an agent, and in
+* that case this plugin's instruction row must simply contribute nothing. A
+* package that is present but cannot be evaluated is a different answer, and
+* one this adapter reports instead of caching as absence.
+*
+* @module @dsh-electron/dsh-plugin-multi-root-workspace/compat/agent-instructions
+*/
+/** Raised when the package is present but carries neither renderer name. */
+var DshInstructionApiError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "DshInstructionApiError";
+	}
+};
+/** Resolution is attempted once per process; `null` records a confirmed absence. */
+let resolution;
+/**
+* Pick the renderer this release exports.
+* @param module - the loaded upstream module.
+* @returns the renderer.
+* @throws {DshInstructionApiError} when neither name is present.
+*/
+function selectRenderer(module) {
+	const render = module.renderAgentInstructions ?? module.renderWorkspaceContext;
+	if (render === void 0) throw new DshInstructionApiError("multi-root workspace: @deepseek-ai/dsh-agent-instructions exports neither renderAgentInstructions (0.1.6 and later) nor renderWorkspaceContext (0.1.5); the additional roots' instruction files cannot be rendered. Adapt src/compat/agent-instructions.ts to the installed release.");
+	return render;
+}
+/**
+* Adapt one loaded upstream module to {@link InstructionsApi}.
+* @param module - the loaded upstream module.
+* @returns the adapted surface.
+* @throws {DshInstructionApiError} when a function this plugin needs is absent.
+*/
+function adaptInstructionsModule(module) {
+	const discover = module.discoverBaselineInstructionFiles;
+	if (discover === void 0) throw new DshInstructionApiError("multi-root workspace: @deepseek-ai/dsh-agent-instructions does not export discoverBaselineInstructionFiles; adapt src/compat/agent-instructions.ts to the installed release.");
+	return {
+		discover: (options) => discover(options),
+		render: selectRenderer(module)
+	};
+}
+/**
+* Whether one package is installed at all, judged WITHOUT evaluating it.
+*
+* This is what separates "the optional peer is absent" from "the optional peer
+* is installed but its evaluation fails" (a missing transitive dependency, a
+* broken build). Only a genuine resolvability failure counts as absence: a
+* resolution that fails for another reason (an `exports` map with no `require`
+* condition, say) leaves the verdict to the `import()` below, which is the
+* authority on whether the module can actually be loaded.
+* @param specifier - the bare package specifier to probe.
+* @returns whether the package resolves from this module.
+*/
+function isPackageInstalled(specifier) {
+	try {
+		createRequire(import.meta.url).resolve(specifier);
+		return true;
+	} catch (error) {
+		const code = error?.code;
+		return code !== "MODULE_NOT_FOUND" && code !== "ERR_MODULE_NOT_FOUND";
+	}
+}
+/**
+* Load and adapt the upstream instruction surface, once.
+*
+* @returns the adapted surface, or `undefined` when the package is not
+*   installed. A package that IS installed but exports neither renderer throws
+*   instead: that is a compatibility break to fix, not an optional seam. So
+*   does one that is installed but cannot be evaluated at all — a missing
+*   transitive dependency, a broken build — because reporting that as absence
+*   would drop every additional root's instructions for the rest of the
+*   process. See {@link isPackageInstalled} for how the two are told apart.
+*/
+async function instructionsApi() {
+	resolution ??= (async () => {
+		if (!isPackageInstalled("@deepseek-ai/dsh-agent-instructions")) return null;
+		return adaptInstructionsModule(await import("@deepseek-ai/dsh-agent-instructions"));
+	})();
+	return await resolution ?? void 0;
+}
+/**
+* Render loaded instruction files within a byte budget, through whichever
+* renderer the installed release exports.
+*
+* This is the only rendering entry point the business layer uses.
+* @param files - loaded files, ordered broadest to most specific.
+* @param options - the byte budget.
+* @returns the rendered text and its budget diagnostics.
+* @throws {DshInstructionApiError} when no usable renderer is installed.
+*/
+async function renderInstructions(files, options) {
+	const api = await instructionsApi();
+	if (api === void 0) throw new DshInstructionApiError("multi-root workspace: @deepseek-ai/dsh-agent-instructions is not installed, so instruction files cannot be rendered. Check for its presence with instructionsApi() before calling renderInstructions().");
+	return api.render(files, options);
+}
+//#endregion
+//#region src/compat/llm-message.ts
+/**
+* This plugin's own producer kind.
+*
+* Session format 4 rejects the shared `kind: 'plugin'` (`format v4 message
+* requires a producer-owned source kind`). The kind is ours, not
+* `agent-instructions`: upstream treats that kind's `changes` array as its
+* own reconciliation authority.
+*/
+const PRODUCER_SOURCE_KIND = "multi-root-workspace";
+/**
+* The first session format whose encoder refuses `kind: 'plugin'`.
+* Earlier formats declare that kind on `MessageSourceMap` and require it.
+*/
+const PRODUCER_OWNED_FORMAT = 4;
+/**
+* Which source kind the installed session format will persist.
+* @param formatVersion - `SESSION_FORMAT_VERSION`, when the session package is installed.
+* @returns `plugin` through format 3, and this plugin's own kind from format 4 on.
+*/
+function instructionSourceKind(formatVersion) {
+	return formatVersion !== void 0 && formatVersion >= PRODUCER_OWNED_FORMAT ? PRODUCER_SOURCE_KIND : "plugin";
+}
+/**
+* The installed session format, when that package is present.
+*
+* A composition that never persists a session can omit the package; format 3
+* is then the spelling that still declares `kind: 'plugin'`. Any other failure
+* is a broken install and must surface.
+* @returns the format version, or `undefined` when the package is not installed.
+*/
+async function installedFormatVersion() {
+	try {
+		const session = await import("@deepseek-ai/dsh-session");
+		return typeof session.SESSION_FORMAT_VERSION === "number" ? session.SESSION_FORMAT_VERSION : void 0;
+	} catch (error) {
+		const code = error.code;
+		if (code === "ERR_MODULE_NOT_FOUND" || code === "MODULE_NOT_FOUND") return void 0;
+		throw error;
+	}
+}
+/**
+* Build one user-role instruction message.
+*
+* Format 3 and earlier: `{ kind: 'plugin', plugin, form: 'instructions' }`.
+* Format 4 and later: `{ kind: 'multi-root-workspace', plugin, form: 'instructions' }`.
+* @param input - the body and the plugin attribution.
+* @returns the frozen message upstream's helper produced.
+* @throws {Error} when the optional peer is absent: a step that has instruction
+*   text to deliver cannot be served without it, and staying silent would drop
+*   user-visible context instead of reporting a misconfigured composition.
+*/
+async function createInstructionMessage(input) {
+	let module;
+	try {
+		module = await import("@deepseek-ai/dsh-llm");
+	} catch (error) {
+		throw new Error(`multi-root workspace: @deepseek-ai/dsh-llm is not installed, so additional roots' instruction files cannot be delivered as messages (${error instanceof Error ? error.message : String(error)}).`);
+	}
+	const create = module.createUserMessage;
+	return create({
+		content: [{
+			type: "text",
+			text: input.text
+		}],
+		source: instructionSource(input.plugin, await installedFormatVersion())
+	});
+}
+/** The source object the installed format will persist. */
+function instructionSource(plugin, formatVersion) {
+	const kind = instructionSourceKind(formatVersion);
+	if (kind === "plugin") return {
+		kind,
+		plugin,
+		form: "instructions"
+	};
+	return {
+		kind,
+		plugin,
+		form: "instructions"
+	};
+}
+//#endregion
+export { renderInstructions as i, instructionsApi as n, isPackageInstalled as r, createInstructionMessage as t };

package/lib/lsp.js

@@ -1,6 +1,6 @@
+import { t as wrapMethod } from "./method-wrapper-CFY3p3j2.js";
 import { t as aroundTool } from "./tool-context-CpgIFcCB.js";
 import { t as routeWorkspacePath } from "./workspace-routing-YPxaQ4V3.js";
-import { t as wrapMethod } from "./method-wrapper-CFY3p3j2.js";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/lsp.ts
 const inject = [

package/lib/metadata-DgqSdVX_.js

@@ -0,0 +1,35 @@
+import { t as RootValidationError } from "./roots-Ca_W1S9n.js";
+import { createHash } from "node:crypto";
+import { basename } from "node:path";
+//#region src/skills/metadata.ts
+/** Registry metadata only; this module never resolves or grants a directory. */
+function validAliasId(value) {
+	return typeof value === "string" && value.length <= 48 && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value);
+}
+function skillsMetadataValid(row, rows) {
+	return validAliasId(row.aliasId) && typeof row.skillsEnabled === "boolean" && rows.filter((other) => other.aliasId === row.aliasId).length === 1;
+}
+function validateAliasId(value, others) {
+	if (!validAliasId(value) || others.some((row) => row.aliasId === value)) throw new RootValidationError("invalid-alias-id", "aliasId must be unique kebab-case, between 1 and 48 characters");
+	return value;
+}
+/** Missing metadata is legacy; malformed supplied metadata is preserved and withheld. */
+function migrateRootSkills(rows) {
+	const used = new Set(rows.flatMap((row) => validAliasId(row.aliasId) ? [row.aliasId] : []));
+	const generated = /* @__PURE__ */ new Map();
+	for (const row of [...rows].sort((a, b) => a.id < b.id ? -1 : a.id > b.id ? 1 : 0)) {
+		if (row.aliasId !== void 0) continue;
+		const base = (row.alias || basename(row.path)).normalize("NFKD").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32).replace(/-$/g, "") || "root";
+		const aliasId = used.has(base) ? `${base}-${createHash("sha256").update(row.id).digest("hex").slice(0, 12)}` : base;
+		if (used.has(aliasId)) continue;
+		used.add(aliasId);
+		generated.set(row, aliasId);
+	}
+	return rows.map((row) => ({
+		...row,
+		...row.aliasId === void 0 && generated.has(row) ? { aliasId: generated.get(row) } : {},
+		...row.skillsEnabled === void 0 ? { skillsEnabled: row.readOnlyRecordedPath === void 0 && (row.aliasId === void 0 || validAliasId(row.aliasId) && rows.filter((other) => other.aliasId === row.aliasId).length === 1) } : {}
+	}));
+}
+//#endregion
+export { skillsMetadataValid as n, validateAliasId as r, migrateRootSkills as t };

package/lib/{registry-DCxC5Lay.js → registry-KSsmU393.js}

@@ -1,10 +1,11 @@
-import { i as isWindowsNetworkOrDevicePath } from "./windows-runner-contract-CEfmZzu0.js";
-import { a as classifyStoredRoots, d as reservedRootBoundary, f as resolveRootIndex, i as canonicalRoot, m as validateRootCandidate, n as additionalRootId, r as availableRoots, s as expandRootInput, t as RootValidationError, u as removeStatusAt } from "./roots-B-0l8mNG.js";
+import { i as isWindowsNetworkOrDevicePath } from "./windows-runner-contract-B5R2K3mM.js";
+import { a as classifyStoredRoots, d as reservedRootBoundary, f as resolveRootIndex, i as canonicalRoot, m as validateRootCandidate, n as additionalRootId, r as availableRoots, s as expandRootInput, t as RootValidationError, u as removeStatusAt } from "./roots-Ca_W1S9n.js";
+import { r as validateAliasId, t as migrateRootSkills } from "./metadata-DgqSdVX_.js";
 import { createRequire } from "node:module";
-import { Service } from "@deepseek-ai/cordis";
 import { closeSync, fstatSync, mkdirSync, openSync, statSync } from "node:fs";
-import { dirname, isAbsolute } from "node:path";
 import { randomUUID } from "node:crypto";
+import { dirname, isAbsolute } from "node:path";
+import { Service } from "@deepseek-ai/cordis";
 import { defineDomain, domainTable } from "@deepseek-ai/dsh-storage-domain";
 import { tryLockExclusive } from "@deepseek-ai/node-addon-system/flock";
 //#region src/compat/storage-zod.ts
@@ -123,7 +124,7 @@ var RegistryAuthorityLease = class RegistryAuthorityLease {
 			mode: 448
 		});
 		if (process.platform === "win32") {
-			const { acquireLockHandleWin32 } = await import("./registry-lease-win32-DTO6QpT9.js");
+			const { acquireLockHandleWin32 } = await import("./registry-lease-win32-DVTq9d4D.js");
 			let handle;
 			try {
 				handle = await acquireLockHandleWin32(leasePath);
@@ -175,7 +176,7 @@ var RegistryAuthorityLease = class RegistryAuthorityLease {
 		if (this.released) return;
 		this.released = true;
 		if (this.held.kind === "win32") {
-			const { releaseLockHandleWin32 } = await import("./registry-lease-win32-DTO6QpT9.js");
+			const { releaseLockHandleWin32 } = await import("./registry-lease-win32-DVTq9d4D.js");
 			await releaseLockHandleWin32(this.held.handle);
 			return;
 		}
@@ -268,6 +269,8 @@ const persistedRoot = z.object({
 	readOnlyRecordedPath: z.string().min(1).optional(),
 	readWriteRecordedPath: z.string().min(1).optional(),
 	alias: z.string().optional(),
+	aliasId: z.unknown().optional(),
+	skillsEnabled: z.unknown().optional(),
 	addedAt: z.string().min(1)
 });
 const persistedPrimaryRoot = z.object({ roots: z.array(persistedRoot) });
@@ -469,6 +472,7 @@ var MultiRootRegistry = class extends Service {
 				id: additionalRootId(randomUUID()),
 				path: canonical,
 				access,
+				skillsEnabled: access !== "read-only",
 				...grantFields(access, canonical),
 				state: "available",
 				...alias === void 0 ? {} : { alias },
@@ -477,6 +481,7 @@ var MultiRootRegistry = class extends Service {
 				...dropGrantFields(status),
 				path: canonical,
 				access: input.access ?? status.access,
+				...input.access !== void 0 && input.access !== status.access ? { skillsEnabled: input.access !== "read-only" } : {},
 				...grantFields(input.access ?? status.access, canonical),
 				addedAt: (/* @__PURE__ */ new Date()).toISOString(),
 				...alias === void 0 ? {} : { alias }
@@ -520,6 +525,7 @@ var MultiRootRegistry = class extends Service {
 			const next = statuses.map((status, index) => index === targetIndex ? {
 				...dropGrantFields(status),
 				access,
+				skillsEnabled: access !== "read-only",
 				...recorded === void 0 ? {} : grantFields(access, recorded)
 			} : status);
 			return await this.persist(key, next);
@@ -579,6 +585,28 @@ var MultiRootRegistry = class extends Service {
 			return await this.persist(key, next);
 		});
 	}
+	/** Change a Skill switch without changing any grant field. */
+	async setSkillsEnabled(primaryRoot, ref, skillsEnabled) {
+		if (typeof skillsEnabled !== "boolean") throw new RootValidationError("invalid-ref", "skillsEnabled must be a boolean");
+		return await this.setSkillsMetadata(primaryRoot, ref, { skillsEnabled });
+	}
+	async setAliasId(primaryRoot, ref, aliasId) {
+		return await this.setSkillsMetadata(primaryRoot, ref, { aliasId });
+	}
+	async setSkillsMetadata(primaryRoot, ref, patch) {
+		await this.ensureAuthority();
+		this.requireActive();
+		const key = canonicalRoot(primaryRoot);
+		return await this.serialize(key, async () => {
+			const statuses = this.reclassify(key);
+			const target = resolveRootIndex(statuses, ref);
+			if (patch.aliasId !== void 0) validateAliasId(patch.aliasId, statuses.filter((_row, index) => index !== target));
+			return await this.persist(key, statuses.map((row, index) => index === target ? {
+				...row,
+				...patch
+			} : row));
+		});
+	}
 	/**
 	* Move one registration within the display order.
 	* @param primaryRoot - the session workspace root the root belongs to.
@@ -705,12 +733,10 @@ var MultiRootRegistry = class extends Service {
 	*/
 	async persist(key, statuses) {
 		const table = this.requireTable();
+		const durable = persistedPrimaryRoot.parse({ roots: migrateRootSkills(statuses.map(toPersistedRoot)) });
 		if (statuses.length === 0) await table.delete(key);
-		else {
-			const durable = persistedPrimaryRoot.parse({ roots: statuses.map(toPersistedRoot) });
-			await table.put(key, durable);
-		}
-		const classified = statuses.length === 0 ? [] : classifyStoredRoots(key, statuses.map(toRegisteredRoot));
+		else await table.put(key, durable);
+		const classified = statuses.length === 0 ? [] : classifyStoredRoots(key, durable.roots.map(toRegisteredRoot));
 		this.cache.set(key, classified);
 		this.publish(key, classified);
 		return classified;
@@ -750,10 +776,22 @@ var MultiRootRegistry = class extends Service {
 	* under a shared byte budget, so a move must update the live scope immediately.
 	* Aliases and no-op moves still leave the signature unchanged.
 	*/
+	metadataPublished = /* @__PURE__ */ new Map();
 	publish(key, statuses) {
 		const withheld = statuses.filter((status) => status.state !== "available");
 		const signature = [...statuses.filter((status) => status.state === "available").map((status) => `available:${status.access}:${recordedGrantOf(status)}`), ...withheld.map((status) => `${status.state}:${status.invalidReason ?? ""}:${status.access}:${status.path}:${recordedGrantOf(status) ?? ""}`)].join("\n");
-		if ((this.published.get(key) ?? "") === signature) return;
+		const previousMetadata = this.metadataPublished.get(key);
+		const metadata = JSON.stringify(statuses.map((row) => [
+			row.id,
+			row.aliasId,
+			row.skillsEnabled,
+			row.state
+		]));
+		this.metadataPublished.set(key, metadata);
+		if ((this.published.get(key) ?? "") === signature) {
+			if (previousMetadata !== metadata && (previousMetadata !== void 0 || statuses.length > 0)) for (const listener of this.listeners) listener(key);
+			return;
+		}
 		this.published.set(key, signature);
 		const effective = statuses.flatMap((status) => {
 			const recorded = recordedGrantOf(status);
@@ -851,7 +889,17 @@ var MultiRootRegistry = class extends Service {
 		this.loggedContended = false;
 		this.cache.clear();
 		this.published.clear();
-		for (const [primaryRoot, record] of this.table.entries()) this.accept(primaryRoot, record);
+		for (const [primaryRoot, record] of this.table.entries()) await this.serialize(canonicalRoot(primaryRoot), async () => {
+			const migrated = { roots: migrateRootSkills(record.roots) };
+			let accepted = record;
+			if (JSON.stringify(migrated) !== JSON.stringify(record)) try {
+				await this.table.put(primaryRoot, migrated);
+				accepted = migrated;
+			} catch (error) {
+				this.ctx.logger.warn(`multi-root skills: metadata migration failed; Skills remain withheld: ${String(error)}`);
+			}
+			this.accept(primaryRoot, accepted);
+		});
 		this.ctx.multiRootScope.setRegistryAuthority(true);
 	}
 	/** Fail closed: empty scope, no table, contended state. */
@@ -879,6 +927,7 @@ var MultiRootRegistry = class extends Service {
 	withdrawPublished() {
 		for (const key of this.published.keys()) this.ctx.multiRootScope.setAdditionalRoots(key, []);
 		this.published.clear();
+		this.metadataPublished.clear();
 		this.cache.clear();
 	}
 	/**
@@ -966,6 +1015,8 @@ function toPersistedRoot(status) {
 		path: status.path,
 		...grant,
 		...status.alias === void 0 ? {} : { alias: status.alias },
+		...status.aliasId === void 0 ? {} : { aliasId: status.aliasId },
+		...status.skillsEnabled === void 0 ? {} : { skillsEnabled: status.skillsEnabled },
 		addedAt: status.addedAt
 	};
 }
@@ -993,6 +1044,8 @@ function toRegisteredRoot(entry) {
 		...entry.readOnlyRecordedPath === void 0 ? {} : { readOnlyRecordedPath: entry.readOnlyRecordedPath },
 		...entry.readWriteRecordedPath === void 0 ? {} : { readWriteRecordedPath: entry.readWriteRecordedPath },
 		...entry.alias === void 0 ? {} : { alias: entry.alias },
+		...entry.aliasId === void 0 ? {} : { aliasId: entry.aliasId },
+		...entry.skillsEnabled === void 0 ? {} : { skillsEnabled: entry.skillsEnabled },
 		addedAt: entry.addedAt
 	};
 }

package/lib/registry.js

@@ -1,2 +1,2 @@
-import { a as MultiRootRegistry, c as multiRootDomainSpec, i as MAX_ALIAS_LENGTH, n as DOMAIN_NAME, o as REGISTRY_CONTENDED_MESSAGE, r as MAX_ADDITIONAL_ROOTS_CEILING, s as TABLE_NAME, t as DEFAULT_MAX_ADDITIONAL_ROOTS } from "./registry-DCxC5Lay.js";
+import { a as MultiRootRegistry, c as multiRootDomainSpec, i as MAX_ALIAS_LENGTH, n as DOMAIN_NAME, o as REGISTRY_CONTENDED_MESSAGE, r as MAX_ADDITIONAL_ROOTS_CEILING, s as TABLE_NAME, t as DEFAULT_MAX_ADDITIONAL_ROOTS } from "./registry-KSsmU393.js";
 export { DEFAULT_MAX_ADDITIONAL_ROOTS, DOMAIN_NAME, MAX_ADDITIONAL_ROOTS_CEILING, MAX_ALIAS_LENGTH, MultiRootRegistry, MultiRootRegistry as default, REGISTRY_CONTENDED_MESSAGE, TABLE_NAME, multiRootDomainSpec };

package/lib/review-context-AH-SXHmj.js

@@ -0,0 +1,98 @@
+import { t as effectiveDirectory } from "./session-directory-BLOstut1.js";
+import { s as touchedPathOfToolCall } from "./instructions-MePoRigy.js";
+import { l as isCanonicallyUnder } from "./roots-Ca_W1S9n.js";
+import { createHash } from "node:crypto";
+import { resolve } from "node:path";
+import { Service } from "@deepseek-ai/cordis";
+import { canonicalPath } from "@deepseek-ai/dsh-sandbox";
+//#region src/compat/auto-review-contract.ts
+/** The companion's joint support contract is deliberately narrower than the ordinary bundle. */
+const AUTO_REVIEW_RELEASE = "0.2.1-rc.2";
+function assertAutoReviewRelease(release) {
+	if (release !== "0.2.1-rc.2") throw new Error(`multi-root Auto Review requires exactly DSH ${AUTO_REVIEW_RELEASE}`);
+}
+//#endregion
+//#region src/compat/review-session.ts
+/** Fingerprint only the native instruction producer's visible authority data. */
+function nativeInstructionFingerprint(session) {
+	const rows = [];
+	for (const seq of session.surface.nodes) {
+		const event = session.eventAt(seq);
+		if (event?.type === "user/message" && event.data.source.kind === "agent-instructions") rows.push(event.data);
+	}
+	return createHash("sha256").update(JSON.stringify(rows)).digest("hex");
+}
+//#endregion
+//#region src/review-context.ts
+/** Read-only, current host context for the optional Auto Review companion. */
+/** All authority remains in the existing Registry/scope and instruction index. */
+var MultiRootReviewContext = class extends Service {
+	static inject = [
+		"multiRootCompat",
+		"multiRootProviders",
+		"multiRootScope",
+		"multiRootRegistry",
+		"multiRootInstructions",
+		"sandboxPolicy",
+		"workingDirectory",
+		"fs"
+	];
+	constructor(ctx) {
+		super(ctx, "multiRootReviewContext");
+	}
+	assertCompatible() {
+		assertAutoReviewRelease(this.ctx.multiRootCompat.release);
+	}
+	async build(exec, signal) {
+		signal.throwIfAborted();
+		const agent = exec.agent;
+		if (agent === void 0) throw new Error("review-context: missing session");
+		const policy = this.ctx.sandboxPolicy.resolve({ session: agent.session });
+		const primary = canonicalPath(policy.workspaceRoot);
+		if (agent.session.header.cwd !== void 0 && canonicalPath(agent.session.header.cwd) !== primary) throw new Error("review-context: inconsistent session origin");
+		await this.ctx.multiRootRegistry.refresh(primary);
+		signal.throwIfAborted();
+		const cwd = effectiveDirectory(this.ctx, agent.session);
+		if (cwd === void 0) throw new Error("review-context: missing effective cwd");
+		const scope = this.ctx.multiRootScope.previewForTool(policy, exec.name);
+		const environment = {
+			sessionOrigin: scope.primaryRoot,
+			effectiveCwd: cwd,
+			sandboxMode: policy.mode,
+			registryAuthority: scope.authority,
+			roots: scope.roots.map((root) => ({
+				path: root.path,
+				access: root.access,
+				effectiveWritable: scope.writableRoots.includes(root.path) && !scope.deniedRoots.some((deny) => isCanonicallyUnder(root.path, deny))
+			})),
+			writableRoots: scope.writableRoots,
+			deniedRoots: scope.deniedRoots,
+			...scope.protectedHome === void 0 ? {} : { protectedHome: scope.protectedHome },
+			ambientWrites: policy.mode === "danger-full-access" && scope.authority === "available",
+			readConfinement: false,
+			primaryRootWritable: policy.mode !== "read-only" && !scope.deniedRoots.some((deny) => isCanonicallyUnder(scope.primaryRoot, deny)),
+			writeBoundary: scope.authority === "unavailable" && policy.mode !== "read-only" ? "primary-root-only; no shared temp grants; explicit denies take precedence" : policy.mode === "danger-full-access" ? "ambient host writes minus explicit deny boundaries; membership is not an access allowlist" : policy.mode === "workspace-write" ? "primary root, effective writable additional roots and upstream host temp grants; explicit denies take precedence" : "only effective writable additional roots; explicit denies take precedence"
+		};
+		const path = touchedPathOfToolCall(exec.name, JSON.stringify(exec.arguments));
+		const target = path === void 0 ? void 0 : this.ctx.fs.processPath(await this.ctx.fs.resolve(resolve(cwd, path), { signal }));
+		const constraints = await this.ctx.multiRootInstructions.snapshot(agent, scope.authority === "available" ? scope.additionalRoots : [], target, signal);
+		signal.throwIfAborted();
+		const payload = {
+			schemaVersion: 1,
+			environment,
+			instructionProvenanceRoots: [.../* @__PURE__ */ new Set([...scope.additionalRoots, ...this.ctx.multiRootInstructions.knownRoots(agent.session)])],
+			constraints,
+			completeness: "complete"
+		};
+		if (Buffer.byteLength(JSON.stringify(payload), "utf8") > 65536) throw new Error("review-context: context budget exceeded");
+		return {
+			...payload,
+			fingerprint: createHash("sha256").update(JSON.stringify([payload, nativeInstructionFingerprint(agent.session)])).digest("hex")
+		};
+	}
+	async assertCurrent(exec, snapshot, signal) {
+		if ((await this.build(exec, signal)).fingerprint !== snapshot.fingerprint) throw new Error("review-context: snapshot changed; retry the tool call");
+	}
+};
+//#endregion
+export { assertAutoReviewRelease as n, MultiRootReviewContext as t };

package/lib/review-context.js

@@ -0,0 +1,2 @@
+import { t as MultiRootReviewContext } from "./review-context-AH-SXHmj.js";
+export { MultiRootReviewContext, MultiRootReviewContext as default };

package/lib/{roots-B-0l8mNG.js → roots-Ca_W1S9n.js}

@@ -1,4 +1,4 @@
-import { i as isWindowsNetworkOrDevicePath } from "./windows-runner-contract-CEfmZzu0.js";
+import { i as isWindowsNetworkOrDevicePath } from "./windows-runner-contract-B5R2K3mM.js";
 import { statSync } from "node:fs";
 import { isAbsolute, join, sep } from "node:path";
 import { canonicalPath } from "@deepseek-ai/dsh-sandbox";

package/lib/{sandbox-CVAcT_gy.js → sandbox-CXk5h-ct.js}

@@ -1,9 +1,9 @@
-import { a as parseWindowsProfile, i as isWindowsNetworkOrDevicePath, n as assertWindowsDenyCapacity, t as DialectUnrecognizedError } from "./windows-runner-contract-CEfmZzu0.js";
-import { l as isCanonicallyUnder } from "./roots-B-0l8mNG.js";
+import { a as parseWindowsProfile, i as isWindowsNetworkOrDevicePath, n as assertWindowsDenyCapacity, t as DialectUnrecognizedError } from "./windows-runner-contract-B5R2K3mM.js";
+import { l as isCanonicallyUnder } from "./roots-Ca_W1S9n.js";
 import { brandMultiRootProvider } from "./providers.js";
 import { posix } from "node:path";
-import { fileURLToPath } from "node:url";
 import { SandboxUnavailableError, canonicalPath } from "@deepseek-ai/dsh-sandbox";
+import { fileURLToPath } from "node:url";
 import { LocalSandboxProvider } from "@deepseek-ai/dsh-sandbox-local";
 //#region src/compat/sandbox-confine.ts
 /** Whether a value is a thenable, i.e. whether the installed `confine` is async. */

package/lib/sandbox.js

@@ -1,3 +1,3 @@
-import { t as MultiRootSandboxProvider } from "./sandbox-CVAcT_gy.js";
+import { t as MultiRootSandboxProvider } from "./sandbox-CXk5h-ct.js";
 import "./providers.js";
 export { MultiRootSandboxProvider, MultiRootSandboxProvider as default };

package/lib/scope.js

@@ -1,10 +1,10 @@
 import { t as aroundTool } from "./tool-context-CpgIFcCB.js";
-import { r as effectiveRootAccess } from "./contract-DZ4zczDT.js";
-import { Service } from "@deepseek-ai/cordis";
+import { r as effectiveRootAccess } from "./contract-CStSEOcK.js";
 import { statSync } from "node:fs";
 import { isAbsolute } from "node:path";
-import { AsyncLocalStorage } from "node:async_hooks";
+import { Service } from "@deepseek-ai/cordis";
 import { canonicalPath } from "@deepseek-ai/dsh-sandbox";
+import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/scope.ts
 /**
 * The multi-root workspace scope: the plugin's single home for the question
@@ -210,8 +210,7 @@ var MultiRootScopeService = class extends Service {
 		if (dshHome !== void 0 && (typeof dshHome !== "string" || dshHome.trim() === "" || !isAbsolute(dshHome))) ctx.logger.error(`multi-root-workspace: invalid dshHome config (expected an absolute path, got ${JSON.stringify(dshHome)}); the DSH-home deny boundary is disabled`);
 		else this.dshHome = dshHome;
 		aroundTool(ctx, (exec, next) => {
-			const parent = toolCapStore.getStore();
-			return toolCapStore.run({ capped: parent?.capped === true || this.caps[exec.name] === "read-only" }, next);
+			return toolCapStore.run({ capped: this.capForTool(exec.name) }, next);
 		});
 		ctx.inject(["systemPrompt", "sandboxPolicy"], (scope) => {
 			scope.systemPrompt.context({
@@ -243,9 +242,19 @@ var MultiRootScopeService = class extends Service {
 	* @returns the canonical scope; `additionalRoots` is empty when none are registered.
 	*/
 	resolve(policy) {
+		return this.project(policy, this.capped());
+	}
+	/** Read-only pending-dispatch projection. Does not mint an ALS execution grant. */
+	previewForTool(policy, toolName) {
+		return this.project(policy, this.capForTool(toolName));
+	}
+	/** Execution and review use exactly the same parent-narrowing rule. */
+	capForTool(toolName) {
+		return this.capsInvalid || toolCapStore.getStore()?.capped === true || this.caps[toolName] === "read-only";
+	}
+	project(policy, capped) {
 		const primaryRoot = canonicalPath(policy.workspaceRoot);
 		const roots = this.membersOf(primaryRoot);
-		const capped = this.capped();
 		const writable = capped || this.registryAuthority === "unavailable" ? [] : roots.filter((root) => effectivelyWritable(policy.mode, root.access)).map((root) => root.path);
 		const denied = (this.rootsByPrimary.get(primaryRoot) ?? []).filter((root) => typeof root.recordedPath === "string" && root.recordedPath !== "" && root.recordedPath !== primaryRoot && (capped || !effectivelyWritable(policy.mode, root.access))).map((root) => root.recordedPath);
 		const deniedRoots = [...new Set(denied)];