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

package/lib/command.js

@@ -1,2 +1,2 @@
-import { a as renderRootsReport, i as parseFoldersCommand, n as apply, o as resolvePanelPrimaryRoot, r as inject, s as revealArgv, t as COMMAND_NAME } from "./command-CTdNvwt1.js";
-export { COMMAND_NAME, apply, inject, parseFoldersCommand, renderRootsReport, resolvePanelPrimaryRoot, revealArgv };
+import { a as renderRootsReport, c as revealArgv, i as parseFoldersCommand, n as apply, o as resolvePanelPrimaryRoot, r as inject, s as revealAccepted, t as COMMAND_NAME } from "./command-CESuwlVt.js";
+export { COMMAND_NAME, apply, inject, parseFoldersCommand, renderRootsReport, resolvePanelPrimaryRoot, revealAccepted, revealArgv };

package/lib/compat-DR2LvmYZ.js

@@ -0,0 +1,600 @@
+import { createRequire } from "node:module";
+import { Service } from "@deepseek-ai/cordis";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { dirname, join, sep } from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/compat/dsh-version.ts
+/**
+* The DSH compatibility contract: which upstream releases this plugin is
+* actually verified against, and how an installation is judged against that
+* list.
+*
+* This module is the ONE place the support matrix is spelled out. It is
+* deliberately pure — no cordis, no logging, no process exit — so that the
+* runtime gate (`src/compat.ts`), the static gate (`scripts/check-dsh-compat.mjs`)
+* and the tests all judge an installation by the same code instead of three
+* drifting copies of the same list.
+*
+* Why a contract exists at all: this plugin replaces `ctx.fs` and `ctx.sandbox`
+* with subclasses of the upstream providers, and `src/dialects.ts` recognizes
+* the kernel-sandbox profile by OBSERVING the argv shape `super.confine`
+* produced (ADR-0003). Both couplings are to pre-stable upstream internals that
+* carry no semver promise. An npm range like `>=0.1.2-alpha.4 <0.2.0` therefore
+* promises far more than the code was ever verified against; the allowlist
+* below promises exactly what CI has run.
+*
+* @module @dsh-electron/dsh-plugin-multi-root-workspace/compat/dsh-version
+*/
+/**
+* The releases this plugin is verified against, as EXACT version strings.
+*
+* Not a semver range, on purpose: a range is a prediction about releases that
+* do not exist yet, and this plugin's coupling to upstream argv shapes makes
+* that prediction unsafe. Adding an entry is always a human act performed after
+* the upgrade smoke passed on that exact version — a green CI run on an
+* unlisted release is evidence, not authorization (ADR-0009).
+*/
+const SUPPORTED_DSH_RELEASES = [
+	"0.1.5-rc.2",
+	"0.1.6-alpha.1",
+	"0.1.6-alpha.2",
+	"0.1.7-alpha.1",
+	"0.1.7-alpha.2",
+	"0.1.7-rc.1",
+	"0.1.7-rc.2",
+	"0.2.0-rc.1",
+	"0.2.0-rc.2",
+	"0.2.1-alpha.1",
+	"0.2.1-alpha.2",
+	"0.2.1-alpha.3",
+	"0.2.1-alpha.4",
+	"0.2.1-alpha.5",
+	"0.2.1-rc.1",
+	"0.2.1-rc.2"
+];
+/**
+* Packages whose absence means this plugin cannot function at all: every one of
+* them is either subclassed, imported for a value, or the owner of a service
+* key the providers inject.
+*/
+const REQUIRED_CORE_PACKAGES = [
+	"@deepseek-ai/dsh-fs",
+	"@deepseek-ai/dsh-fs-local",
+	"@deepseek-ai/dsh-sandbox",
+	"@deepseek-ai/dsh-sandbox-local",
+	"@deepseek-ai/dsh-sandbox-policy",
+	"@deepseek-ai/dsh-storage-domain"
+];
+/**
+* Packages a full composition provides and a minimal one legitimately omits.
+* Absence is fine; a version that DISAGREES with the required packages is not —
+* that is the mixed-installation failure this contract exists to catch.
+*/
+const OPTIONAL_CORE_PACKAGES = [
+	"@deepseek-ai/dsh-tools",
+	"@deepseek-ai/dsh-working-directory",
+	"@deepseek-ai/dsh-lsp",
+	"@deepseek-ai/dsh-lsp-stdio",
+	"@deepseek-ai/dsh-api-workspace-files",
+	"@deepseek-ai/dsh-typert-protocol",
+	"@deepseek-ai/dsh-sandbox-windows-acl",
+	"@deepseek-ai/dsh-agent",
+	"@deepseek-ai/dsh-agent-instructions",
+	"@deepseek-ai/dsh-client-connection",
+	"@deepseek-ai/dsh-commands",
+	"@deepseek-ai/dsh-llm",
+	"@deepseek-ai/dsh-session",
+	"@deepseek-ai/dsh-subprocess",
+	"@deepseek-ai/dsh-system-prompt"
+];
+/**
+* The optional packages this plugin loads itself at run time, through dynamic
+* `import()`s inside this package's own modules. The copy this module resolves
+* IS the copy that would execute, so every resolvable hit testifies — a
+* private copy inside this package's own tree genuinely loads, and a version
+* that disagrees with the host is a real mixed installation, not a phantom.
+*/
+const RUNTIME_OPTIONAL_PACKAGES = [
+	"@deepseek-ai/dsh-agent-instructions",
+	"@deepseek-ai/dsh-llm",
+	"@deepseek-ai/dsh-session",
+	"@deepseek-ai/dsh-typert-protocol"
+];
+/**
+* The optional packages this plugin consumes only as mounted host services or
+* ambient types — it never imports them, so a copy inside this package's own
+* tree can never execute. The only version that testifies is the one the
+* COMPOSITION resolves (the installation or the profile): a resolution that
+* lands inside this package's own root is a private development or bundled
+* copy and must be reported absent — otherwise a `link:`-installed checkout
+* whose devDependencies carry a newer release phantom-mixes every supported
+* host it is developed against (the report that motivated this split:
+* `dsh-lsp`/`dsh-lsp-stdio`/`dsh-working-directory` resolving to the plugin's
+* devDependencies on a `0.2.0-rc.2` host produced a `mixed` verdict on a
+* uniformly `0.2.0-rc.2` installation).
+*/
+const HOST_SERVICE_PACKAGES = [
+	"@deepseek-ai/dsh-agent",
+	"@deepseek-ai/dsh-api-workspace-files",
+	"@deepseek-ai/dsh-client-connection",
+	"@deepseek-ai/dsh-commands",
+	"@deepseek-ai/dsh-lsp",
+	"@deepseek-ai/dsh-lsp-stdio",
+	"@deepseek-ai/dsh-subprocess",
+	"@deepseek-ai/dsh-system-prompt",
+	"@deepseek-ai/dsh-tools",
+	"@deepseek-ai/dsh-working-directory"
+];
+/**
+* Optional packages this plugin executes that are resolved through an anchor
+* OTHER than this module. The standalone Windows ACL runner
+* (`src/windows-runner.ts`) imports `@deepseek-ai/dsh-sandbox-windows-acl` by
+* self-reference from the upstream runner's own install location — a file the
+* installed `dsh-sandbox-local` points at in its confined argv — so the copy
+* that testifies is the one sibling to that required package, not whatever
+* this module can reach. Neither the self-resolution hit nor the
+* `@deepseek-ai/dsh` host anchor reflects execution here: if sandbox-local's
+* own anchor cannot see the package, the runner cannot load it either, and
+* absent is the honest answer.
+*/
+const RUNNER_ANCHORED_PACKAGES = ["@deepseek-ai/dsh-sandbox-windows-acl"];
+/** The required package whose tree produces the upstream runner argv. */
+const RUNNER_ANCHOR_PACKAGE = "@deepseek-ai/dsh-sandbox-local";
+/** Every package the contract inspects, required first. */
+const CORE_PACKAGES = [...REQUIRED_CORE_PACKAGES, ...OPTIONAL_CORE_PACKAGES];
+/** The environment variable that relaxes the gate. */
+const COMPAT_ENFORCEMENT_ENV = "DSH_MULTI_ROOT_COMPAT";
+/**
+* Resolve one package's `package.json` path through a require, or `undefined`
+* when it cannot be resolved. The path — not just the version — matters: the
+* caller needs to know WHERE the copy lives to judge whether it belongs to the
+* inspected installation.
+* @param require - the require to resolve through.
+* @param packageName - the package to locate.
+* @returns the manifest path, or `undefined`.
+*/
+function resolvePackageJson(require, packageName) {
+	try {
+		return require.resolve(`${packageName}/package.json`);
+	} catch {
+		return;
+	}
+}
+/** Read `version` off a resolved manifest path; a broken manifest is absent. */
+function versionOfManifest(manifestPath) {
+	try {
+		const manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+		return typeof manifest.version === "string" ? manifest.version : void 0;
+	} catch {
+		return;
+	}
+}
+/**
+* The second resolution anchor: a require rooted at the installed
+* `@deepseek-ai/dsh` meta package. Host-internal packages that never appear as
+* plugin peers are only reachable this way (the pattern the retired
+* `HOST_RESOLVED_PACKAGES` list carved out for `dsh-working-directory`,
+* generalized here to every host-service package).
+* @param require - this module's require, used to locate the meta package.
+* @returns the host-rooted require, or `undefined` when `dsh` itself cannot be
+*   resolved.
+*/
+function hostAnchorRequire(require) {
+	const anchor = resolvePackageJson(require, "@deepseek-ai/dsh");
+	return anchor === void 0 ? void 0 : createRequire(anchor);
+}
+/**
+* This package's own install root — the boundary between a copy that belongs
+* to the inspected installation and a private copy only this package can see.
+* @param require - this module's require; self-reference through the package's
+*   `exports` is tried first, then a walk up from this module's file.
+* @returns the package root, or `undefined` when neither anchor works.
+*/
+function pluginPackageRoot(require) {
+	try {
+		return dirname(require.resolve("@dsh-electron/dsh-plugin-multi-root-workspace/package.json"));
+	} catch {
+		let dir = dirname(fileURLToPath(import.meta.url));
+		while (true) {
+			if (existsSync(join(dir, "package.json"))) return dir;
+			const parent = dirname(dir);
+			if (parent === dir) return void 0;
+			dir = parent;
+		}
+	}
+}
+/**
+* Whether a resolved manifest path lives inside this package's own root — the
+* mark of a private copy no composition can mount. An unknown root cannot
+* exclude anything, so it answers `false` rather than guessing.
+*/
+function insidePackageRoot(manifestPath, root) {
+	return root !== void 0 && (manifestPath === root || manifestPath.startsWith(`${root}${sep}`));
+}
+/**
+* Read one package's declared version through Node resolution.
+*
+* Resolution runs from THIS module — for required and runtime-loaded packages
+* the copy found here is the copy that would execute, which is what makes the
+* answer meaningful: the upstream packages are peer dependencies, so they
+* resolve to the single copy the host provides — the same copy the providers
+* will subclass at runtime.
+*
+* {@link HOST_SERVICE_PACKAGES} are different: the plugin never imports them,
+* so a copy inside this package's own tree can never execute, and counting it
+* would report a mixed installation out of a linked checkout's devDependencies
+* alone. Only a hit OUTSIDE this package's root — a copy the composition could
+* mount — testifies; when this module cannot reach the package at all, the
+* `@deepseek-ai/dsh` host manifest supplies a second anchor for host-internal
+* packages that are never plugin peers.
+*
+* {@link RUNNER_ANCHORED_PACKAGES} are a third policy: executed, but resolved
+* from the upstream-runner anchor rather than this module, so only a hit
+* sibling to the installed `dsh-sandbox-local` testifies.
+*
+* A package that cannot be resolved in either place is reported absent rather
+* than throwing, because "not installed" is a legitimate answer for every
+* optional package.
+* @param packageName - the package to inspect.
+* @returns the declared version, or `undefined` when the package or its
+*   manifest cannot be resolved.
+*/
+function readInstalledVersion(packageName) {
+	const require = createRequire(import.meta.url);
+	if (RUNNER_ANCHORED_PACKAGES.includes(packageName)) {
+		const anchor = resolvePackageJson(require, RUNNER_ANCHOR_PACKAGE);
+		const hit = anchor === void 0 ? void 0 : resolvePackageJson(createRequire(anchor), packageName);
+		return hit === void 0 ? void 0 : versionOfManifest(hit);
+	}
+	if (!HOST_SERVICE_PACKAGES.includes(packageName)) {
+		const hit = resolvePackageJson(require, packageName);
+		return hit === void 0 ? void 0 : versionOfManifest(hit);
+	}
+	const root = pluginPackageRoot(require);
+	const selfHit = resolvePackageJson(require, packageName);
+	if (selfHit !== void 0 && !insidePackageRoot(selfHit, root)) return versionOfManifest(selfHit);
+	const host = hostAnchorRequire(require);
+	const hostHit = host === void 0 ? void 0 : resolvePackageJson(host, packageName);
+	return hostHit === void 0 || insidePackageRoot(hostHit, root) ? void 0 : versionOfManifest(hostHit);
+}
+/**
+* Judge one installation against the contract.
+*
+* The three checks run in this order, and the first failure wins, because each
+* later check would report nonsense about an installation that failed an
+* earlier one: a missing required package has no version to compare, and a
+* mixed installation has no single version to look up in the allowlist.
+* @param readVersion - version reader; defaults to Node resolution. Tests and
+*   the static checker pass their own.
+* @returns the report; never throws.
+*/
+function classifyInstallation(readVersion = readInstalledVersion) {
+	const packages = CORE_PACKAGES.map((name) => ({
+		name,
+		version: readVersion(name),
+		required: REQUIRED_CORE_PACKAGES.includes(name)
+	}));
+	const missing = packages.filter((entry) => entry.required && entry.version === void 0);
+	if (missing.length > 0) return report("incomplete", void 0, packages, [
+		"multi-root workspace: required DSH packages are not installed.",
+		"",
+		...missing.map((entry) => `  missing: ${entry.name}`)
+	]);
+	const releases = [...new Set(packages.flatMap((entry) => entry.version === void 0 ? [] : [entry.version]))].sort();
+	const [release, ...extra] = releases;
+	if (release === void 0) return report("incomplete", void 0, packages, ["multi-root workspace: no DSH package could be inspected."]);
+	if (extra.length > 0) return report("mixed", void 0, packages, [
+		"multi-root workspace: this installation mixes several DSH releases.",
+		"",
+		"The filesystem fence and the kernel-sandbox dialects must agree on one upstream",
+		"release; a mixed installation means one half of the sandbox was verified against a",
+		"shape the other half no longer produces. Align every @deepseek-ai/dsh* package on",
+		"one release.",
+		"",
+		`  releases found: ${releases.join(", ")}`
+	]);
+	if (!SUPPORTED_DSH_RELEASES.includes(release)) return report("unsupported", release, packages, [
+		`multi-root workspace: DSH ${release} is not a supported release.`,
+		"",
+		"This plugin replaces the workspace filesystem fence and the kernel-sandbox provider,",
+		"and it recognizes the sandbox profile by the argv shape the upstream provider produces.",
+		"Upstream makes no semver promise, so the plugin refuses to grant additional roots on a",
+		"release it has never been verified against rather than guess at that shape.",
+		"",
+		`  supported: ${SUPPORTED_DSH_RELEASES.join(", ")}`,
+		`  installed: ${release}`
+	]);
+	return report("supported", release, packages, [`multi-root workspace: DSH ${release} is a supported release.`]);
+}
+/**
+* Read the enforcement mode.
+*
+* `warn` exists for exactly one caller: the upgrade smoke, which must run the
+* whole behavior matrix against a release that is deliberately NOT on the
+* allowlist yet — that run is how a release earns its place on the list. It is
+* not a production escape hatch, and the warning says so.
+* @param env - the environment to read; defaults to this process's.
+* @returns `warn` only when explicitly requested, `enforce` otherwise.
+*/
+function compatEnforcement(env = process.env) {
+	return env["DSH_MULTI_ROOT_COMPAT"] === "warn" ? "warn" : "enforce";
+}
+/** Compose a report, appending the package inventory and the recovery pointer. */
+function report(verdict, release, packages, lines) {
+	return {
+		verdict,
+		release,
+		packages,
+		message: (verdict === "supported" ? [...lines] : [
+			...lines,
+			"",
+			"Inspected packages:",
+			...packages.map((entry) => `  ${entry.name} ${entry.version ?? "(not installed)"}`),
+			"",
+			"See docs/troubleshooting/unsupported-dsh-release.md"
+		]).join("\n")
+	};
+}
+//#endregion
+//#region src/compat/pty-marker.ts
+/**
+* Boot-time probe for the agent-PTY marker contract.
+*
+* `multi-root-process-fence` tells an agent terminal from the user's own by
+* one env fact: every supported `dsh-terminal-bash` backend stamps
+* `DSH_PTY_SESSION_ID` (alongside `DSH_SESSION_ID`) into the PTY spawn spec,
+* while the panel's terminal controller stamps only `DSH_SESSION_ID`. That
+* marker is the ONLY discriminator — a backend that ever stops stamping it
+* would reclassify agent PTYs as user terminals and pass them through
+* unconfined under a restricted `danger-full-access`, which is a silent
+* fail-open on a security boundary.
+*
+* The marker is an env key inside upstream's emitted code, not an exported
+* symbol, so the honest structural probe is content: the installed backend
+* package must still write the marker. This module is called from the
+* `multi-root-compat` gate (`src/compat.ts`) BEFORE the service registers —
+* like the version verdict it is a precondition, not a diagnostic, and a
+* breach refuses the composition the same way `mixed`/`incomplete` do: it is
+* not relaxable by `DSH_MULTI_ROOT_COMPAT=warn`.
+*
+* Resolution follows the optional-peer precedent (`agent-instructions.ts`):
+* the backend is not a peer of this plugin, so the plugin anchor is tried
+* first (flat layouts) and the `@deepseek-ai/dsh` host anchor second — the
+* same host-anchor fallback pattern as `dsh-version.ts` — because the
+* backend rides inside the harness meta package's own dependency tree.
+*
+* @module @dsh-electron/dsh-plugin-multi-root-workspace/compat/pty-marker
+*/
+/** The env key that identifies an agent-launched PTY spawn spec. */
+const AGENT_PTY_MARKER = "DSH_PTY_SESSION_ID";
+/** The upstream package whose backend owns the marker stamp. */
+const TERMINAL_BACKEND = "@deepseek-ai/dsh-terminal-bash";
+/** The harness meta package the backend rides inside (its dependency). */
+const HOST_ANCHOR = "@deepseek-ai/dsh/package.json";
+/** Scan budget: enough for any plausible backend layout, bounded forever. */
+const MAX_SOURCE_FILES = 256;
+const MAX_TOTAL_BYTES = 8388608;
+/**
+* Raised when the installed terminal backend does not uphold the marker
+* contract. Thrown from `apply` like `DshCompatUnsupportedError`, so it
+* surfaces as a plugin load failure with the diagnosis attached.
+*/
+var PtyMarkerContractError = class extends Error {
+	/** The resolved backend path when one was found. */
+	backend;
+	constructor(message, backend) {
+		super(message);
+		this.name = "PtyMarkerContractError";
+		this.backend = backend;
+	}
+};
+/**
+* Resolve the backend package root through the two anchors the contract can
+* reach: this module first (flat layouts where the backend is a direct
+* install), then the `@deepseek-ai/dsh` host manifest (pnpm-style layouts
+* where it is the meta package's own dependency — the
+* host-anchor fallback pattern in `dsh-version.ts`). A resolution failure that is not a
+* genuine NOT_FOUND propagates: a resolvable-but-broken specifier is not
+* evidence of absence.
+*/
+function resolveBackendRoot() {
+	const self = createRequire(import.meta.url);
+	const anchors = [self];
+	try {
+		anchors.push(createRequire(self.resolve(HOST_ANCHOR)));
+	} catch (error) {
+		if (!isNotFound(error)) throw error;
+	}
+	for (const anchor of anchors) try {
+		return dirname(anchor.resolve(`${TERMINAL_BACKEND}/package.json`));
+	} catch (error) {
+		if (!isNotFound(error)) throw error;
+	}
+}
+function isNotFound(error) {
+	const code = error?.code;
+	return code === "MODULE_NOT_FOUND" || code === "ERR_MODULE_NOT_FOUND";
+}
+/** Recursively collect `.js` sources under the package root, within budget. */
+function listSources(root) {
+	const files = [];
+	const visit = (dir) => {
+		for (const entry of readdirSync(dir, { withFileTypes: true })) {
+			if (files.length >= MAX_SOURCE_FILES) return;
+			const path = join(dir, entry.name);
+			if (entry.isDirectory() && entry.name !== "node_modules") visit(path);
+			else if (entry.isFile() && entry.name.endsWith(".js")) files.push(path);
+		}
+	};
+	visit(root);
+	return files;
+}
+const defaultIo = {
+	resolveBackendRoot,
+	listSources,
+	read: (path) => readFileSync(path, "utf8")
+};
+/**
+* Judge the installed terminal backend against the marker contract.
+*
+* Never throws: every outcome — absent package, unreadable source, missing
+* marker — is folded into the verdict so the caller's reaction is a policy
+* decision in one place.
+* @param io - filesystem seams; tests inject them, production uses real fs.
+* @returns the verdict.
+*/
+function agentPtyMarkerVerdict(io = defaultIo) {
+	let root;
+	try {
+		root = io.resolveBackendRoot();
+	} catch {
+		return "unverifiable";
+	}
+	if (root === void 0) return "uninstalled";
+	let files;
+	try {
+		files = io.listSources(root);
+	} catch {
+		return "unverifiable";
+	}
+	let remaining = MAX_TOTAL_BYTES;
+	for (const file of files) {
+		let content;
+		try {
+			content = io.read(file);
+		} catch {
+			return "unverifiable";
+		}
+		if (content.length > remaining) return "unverifiable";
+		if (content.includes("DSH_PTY_SESSION_ID")) return "stamped";
+		remaining -= content.length;
+	}
+	return "unverifiable";
+}
+/**
+* Enforce the contract: refuse when the marker cannot be confirmed.
+*
+* @param io - filesystem seams; tests inject them.
+* @throws {PtyMarkerContractError} on `unverifiable`.
+*/
+function assertAgentPtyMarker(io = defaultIo) {
+	if (agentPtyMarkerVerdict(io) !== "unverifiable") return;
+	let backend;
+	try {
+		backend = io.resolveBackendRoot();
+	} catch {}
+	throw new PtyMarkerContractError(`multi-root workspace: the installed ${TERMINAL_BACKEND} does not stamp ${AGENT_PTY_MARKER} on agent PTY spawns, or its sources cannot be verified. That marker is the only fact that separates an agent terminal from the user's own — without it the process fence cannot confine a restricted danger-full-access agent PTY without confining the user's terminal too. The plugin refuses to run rather than let agent terminals pass unconfined. See docs/decisions/ADR-0017-three-state-root-access-and-sandbox-modes.md.`, backend);
+}
+//#endregion
+//#region src/compat.ts
+/**
+* `multi-root-compat`: the startup gate that turns the DSH compatibility
+* contract from documentation into a precondition.
+*
+* Every widened-authority row of this bundle — `multi-root-providers`,
+* `multi-root-registry`, `multi-root-instructions`, `multi-root-lsp`,
+* `multi-root-workspace-files`, `multi-root-process-fence` — injects
+* `multiRootCompat`. Cordis will not start a plugin whose injected service is
+* absent, so this row is what decides whether they run at all:
+*
+* ```text
+* compat check passes  →  ctx.multiRootCompat exists  →  the gated rows start
+* compat check fails   →  the row throws             →  they never start
+* ```
+*
+* The two PROVIDER rows (`multi-root-fs`, `multi-root-sandbox`) deliberately
+* do NOT inject the gate: their widening is scope-driven, and the gated
+* registry can never populate the scope on a refused installation — so they
+* degenerate to the upstream providers. That is what keeps a refused gate a
+* loud degradation (the plugin's features absent, the profile intact) instead
+* of a dead profile: upstream `fs-sandbox`/`sandbox` are already disabled by
+* the patch, so holding `ctx.fs`/`ctx.sandbox` back would take `ctx.shell`,
+* `permissionPresets` and every confining tool down with them.
+*
+* That is why the gate is a plain `apply` and not a `Service` subclass mounted
+* directly: the check has to be able to fail BEFORE the service exists. A
+* `Service` constructor has already run `super(ctx, name)` — and therefore
+* already claimed the service key — by the time it could inspect anything.
+*
+* The verdict itself, and the allowlist it is judged against, live in
+* `./compat/dsh-version.ts`. This module owns only the reaction to it.
+*
+* @module @dsh-electron/dsh-plugin-multi-root-workspace/compat
+*/
+/**
+* Raised when the installed DSH release is not one this plugin is verified
+* against. It is thrown from `apply`, so it surfaces as a plugin load failure
+* with the full diagnosis attached — never as a silently degraded sandbox.
+*/
+var DshCompatUnsupportedError = class extends Error {
+	/** The report that produced the refusal. */
+	report;
+	constructor(report) {
+		super(report.message);
+		this.name = "DshCompatUnsupportedError";
+		this.report = report;
+	}
+};
+/**
+* The `ctx.multiRootCompat` service: the resolved compatibility verdict, held
+* where the gated providers can read it.
+*
+* It intentionally exposes no per-version capability flags. The adapters under
+* `./compat/` detect the shape they need STRUCTURALLY — whether a return value
+* is a thenable, which export name a module carries — because a structural
+* probe also survives upstream reshaping something within one release, while a
+* version comparison does not. The release string here is for the gate and for
+* diagnostics.
+*/
+var MultiRootCompatService = class extends Service {
+	/** The verdict this composition started under. */
+	report;
+	constructor(ctx, report) {
+		super(ctx, "multiRootCompat");
+		this.report = report;
+	}
+	/** The single DSH release every inspected core package agreed on. */
+	get release() {
+		return this.report.release;
+	}
+	/** Whether the installation is on the allowlist. */
+	get supported() {
+		return this.report.verdict === "supported";
+	}
+};
+/** This row needs nothing: it is the thing everything else waits for. */
+const inject = [];
+/**
+* Apply the gate policy to one report.
+*
+* Under `DSH_MULTI_ROOT_COMPAT=warn` exactly one verdict is relaxed: an
+* `unsupported` release that every inspected package agrees on. That is the
+* only shape the upgrade smoke probes — a coherent tree on a release the
+* allowlist does not name yet, which is how a release earns its place there.
+* `mixed` and `incomplete` describe an installation the contract cannot judge
+* at all, so they are refused in either mode; production deployments leave the
+* variable unset and get the refusal for everything.
+* @param report - the verdict to act on.
+* @param enforcement - how to react to a non-`supported` verdict.
+* @returns the warning to log, or `undefined` when there is nothing to say.
+* @throws {DshCompatUnsupportedError} when refusing to run.
+*/
+function assertSupportedInstallation(report, enforcement) {
+	if (report.verdict === "supported") return void 0;
+	if (enforcement === "enforce" || report.verdict !== "unsupported") throw new DshCompatUnsupportedError(report);
+	return `${report.message}\n\nProceeding anyway because ${COMPAT_ENFORCEMENT_ENV}=warn. This is an upgrade-smoke mode: additional workspace roots are about to be granted through a sandbox profile shape that has not been verified on this release. Supported releases: ${SUPPORTED_DSH_RELEASES.join(", ")}.`;
+}
+/**
+* Judge the installation, then either refuse to provide the service or provide
+* it.
+* @param ctx - the row's context.
+*/
+function apply(ctx) {
+	const report = classifyInstallation();
+	const warning = assertSupportedInstallation(report, compatEnforcement());
+	if (warning !== void 0) ctx.logger.warn(warning);
+	assertAgentPtyMarker();
+	ctx.plugin(MultiRootCompatService, report);
+}
+//#endregion
+export { classifyInstallation as _, inject as a, agentPtyMarkerVerdict as c, HOST_SERVICE_PACKAGES as d, OPTIONAL_CORE_PACKAGES as f, SUPPORTED_DSH_RELEASES as g, RUNTIME_OPTIONAL_PACKAGES as h, assertSupportedInstallation as i, assertAgentPtyMarker as l, RUNNER_ANCHORED_PACKAGES as m, MultiRootCompatService as n, AGENT_PTY_MARKER as o, REQUIRED_CORE_PACKAGES as p, apply as r, PtyMarkerContractError as s, DshCompatUnsupportedError as t, CORE_PACKAGES as u, compatEnforcement as v, readInstalledVersion as y };

package/lib/compat.js

@@ -1,2 +1,2 @@
-import { a as inject, i as assertSupportedInstallation, n as MultiRootCompatService, r as apply, t as DshCompatUnsupportedError } from "./compat-B6ZqbQBy.js";
+import { a as inject, i as assertSupportedInstallation, n as MultiRootCompatService, r as apply, t as DshCompatUnsupportedError } from "./compat-DR2LvmYZ.js";
 export { DshCompatUnsupportedError, MultiRootCompatService, apply, assertSupportedInstallation, inject };