dsh-plugin-shop 0.8.4-beta.0 → 0.8.4

package/lib/index.js

@@ -1509,6 +1509,35 @@ function chain(profile, task) {
 	profileQueues.set(profile, next.catch(() => {}));
 	return next;
 }
+/** Run `task` in `profile`'s queue, after every command already in it: the
+* queue `spawnPluginCli` uses, shared with the plugin manager's runner so the
+* two paths are never concurrent in one profile. `ahead` is how many commands
+* were queued or running when the slot was taken. */
+function inProfileQueue(profile, task) {
+	return {
+		ahead: enterQueue(profile),
+		finished: chain(profile, task).finally(() => {
+			leaveQueue(profile);
+		})
+	};
+}
+/** An install record's log: the newest lines within MAX_LOG_LINES and
+* MAX_LOG_BYTES, never dropping the newest one. */
+function createBoundedLog() {
+	const lines = [];
+	let bytes = 0;
+	return {
+		push(line) {
+			lines.push(line);
+			bytes += Buffer.byteLength(line);
+			while ((lines.length > MAX_LOG_LINES || bytes > MAX_LOG_BYTES) && lines.length > 1) {
+				const oldest = lines.shift();
+				if (oldest !== void 0) bytes -= Buffer.byteLength(oldest);
+			}
+		},
+		lines: () => [...lines]
+	};
+}
 /**
 * Why a zero-exit install left `dsh.profile.bundles` without the entry.
 *
@@ -1617,7 +1646,8 @@ const FAILURE_LOG_NOISE = [
 ];
 /** The line dsh 0.1.7 opens a refused install with (dsh-plugin-manager's
 * `rejected`), and the exemption command its CLI prints after it, one per
-* refused package (`runPlugin`). */
+* refused package (`runPlugin`). The opener is exported for the plugin
+* manager's answer, whose output carries the same block. */
 const REFUSAL_OPENER = "dsh: installation rejected: ";
 const REFUSAL_COMMAND = /^dsh: to accept the risk, run: dsh plugin --profile .+ allow-version (.+)@([^@\s]+) --dsh-version (\S+) --accept-risk$/;
 const REFUSAL_FAILED = "dsh: plugin command failed";
@@ -1716,8 +1746,7 @@ function nativeAllocationAbortDetail(usable) {
 * Scanning from the end: a pnpm error code first, then any thrown error, then
 * the last line that is not noise.
 */
-function installFailureDetail(profile, log) {
-	const hint = `pnpm failed in the profile. Run: dsh plugin --profile ${profile} install`;
+function installFailureDetail(profile, log, hint = `pnpm failed in the profile. Run: dsh plugin --profile ${profile} install`) {
 	const usable = log.map((line) => line.replace(/\r+$/, "")).filter((line) => !FAILURE_LOG_NOISE.some((rx) => rx.test(line)));
 	const refusal = refusalDetail(profile, usable);
 	if (refusal !== null) return refusal;
@@ -1825,6 +1854,23 @@ function dshScript() {
 * the spawned command line is the one we add ourselves, after this gate. */
 const UNSAFE_TARGET = /[\s"'`|<>^$();\\{}]|[\u0000-\u001f\u007f]/;
 /**
+* The operand gate, one function for every caller: it refuses, by throwing,
+* an operand the dsh CLI would parse as a flag, and one carrying the shell
+* punctuation `UNSAFE_TARGET` names. A legitimate operand (a catalog name for
+* a removal; a `name@version`, `github:` or tarball spec for an install)
+* never begins with `-`, so the first refusal cannot reject a real install or
+* uninstall, and failing loudly beats letting the CLI reinterpret an operand
+* as an option. `spawnPluginCli` runs it before it spawns anything or takes a
+* queue slot; the gateway's plugin manager path runs it before a spec reaches
+* `installBundle` or the download phase, whose pump relies on it (see
+* `requestDownloadPhase`). Returns the operand, known to be present.
+*/
+function gateOperand(target) {
+	if (target === void 0 || target.startsWith("-")) throw new Error(`dsh-plugin-shop: refusing to spawn with a flag-like operand: ${target ?? "(none)"}`);
+	if (UNSAFE_TARGET.test(target)) throw new Error(`dsh-plugin-shop: refusing to spawn with an unsafe operand: ${JSON.stringify(target)}`);
+	return target;
+}
+/**
 * The operand as the downstream dsh must receive it for pnpm to see it whole.
 *
 * dsh spawns pnpm with `shell: process.platform === 'win32'`
@@ -1862,6 +1908,32 @@ function shellSafeTarget(target, platform) {
 	if (platform !== "win32" || !target.includes("&")) return target;
 	return `"${target}"`;
 }
+const DOWNLOAD_PHASE_FAILED_PREFIX = "dsh-plugin-shop: the download phase could not start — ";
+const DOWNLOAD_PHASE_NO_PNPM = "dsh-plugin-shop: no download phase — pnpm not found on PATH";
+const DOWNLOAD_PHASE_UNSUPPORTED = "dsh-plugin-shop: no download phase for this spec form; the install fetches it directly";
+/**
+* Ask the pump to warm `spec` while an operation waits its turn, and say in
+* that operation's log why there is no download phase when there is none.
+* Shared by the CLI executor and the plugin manager runner.
+*/
+function requestDownloadPhase(options) {
+	const { prefetcher, profile, spec, env, log } = options;
+	let prefetch;
+	try {
+		prefetch = prefetcher.request({
+			profile,
+			spec,
+			cwd: resolveProfileDir(profile, env?.DSH_HOME),
+			env,
+			log
+		});
+	} catch (error) {
+		log(`${DOWNLOAD_PHASE_FAILED_PREFIX}${error.message}`);
+		return null;
+	}
+	if (!prefetch.started) log(prefetch.reason === "no-pnpm" ? DOWNLOAD_PHASE_NO_PNPM : DOWNLOAD_PHASE_UNSUPPORTED);
+	return prefetch;
+}
 /** Run one `dsh plugin --profile <profile> <verb> <target>` and track it.
 * Never rolls back; a failure surfaces stderr verbatim plus the recovery hint
 * (§10). The shop never passes build-script flags: `allowBuilds` stays the
@@ -1878,14 +1950,11 @@ function shellSafeTarget(target, platform) {
 * package IS installed; it reports `done` with the restart fallback. */
 function spawnPluginCli(options) {
 	const { profile, argv, dshBin, env, platform = process.platform, beforeSpawn, prefetcher, confirm, afterDone, onStatus, timeoutMs = INSTALL_TIMEOUT_MS } = options;
-	const target = argv[1];
-	if (target === void 0 || target.startsWith("-")) throw new Error(`dsh-plugin-shop: refusing to spawn with a flag-like operand: ${target ?? "(none)"}`);
-	if (UNSAFE_TARGET.test(target)) throw new Error(`dsh-plugin-shop: refusing to spawn with an unsafe operand: ${JSON.stringify(target)}`);
+	const target = gateOperand(argv[1]);
 	const spawnArgv = [...argv];
 	spawnArgv[1] = shellSafeTarget(target, platform);
 	const installId = randomUUID();
-	const log = [];
-	let logBytes = 0;
+	const log = createBoundedLog();
 	const ahead = enterQueue(profile);
 	let state = "running";
 	let activationOnDone = "restart";
@@ -1893,7 +1962,7 @@ function spawnPluginCli(options) {
 	let detail;
 	const status = () => ({
 		state,
-		log: [...log],
+		log: log.lines(),
 		...state === "done" ? {
 			activation: activationOnDone,
 			...restartReason !== void 0 ? { restartReason } : {}
@@ -1903,11 +1972,6 @@ function spawnPluginCli(options) {
 	const append = (line) => {
 		if (isTerminalInstallState(state)) return;
 		log.push(line);
-		logBytes += Buffer.byteLength(line);
-		while ((log.length > MAX_LOG_LINES || logBytes > MAX_LOG_BYTES) && log.length > 1) {
-			const oldest = log.shift();
-			if (oldest !== void 0) logBytes -= Buffer.byteLength(oldest);
-		}
 		onStatus?.(status());
 	};
 	const failToStart = (error) => {
@@ -1917,19 +1981,14 @@ function spawnPluginCli(options) {
 		return status();
 	};
 	let prefetch = null;
-	if (ahead > 0 && prefetcher !== void 0) try {
-		prefetch = prefetcher.request({
-			profile,
-			spec: target,
-			cwd: resolveProfileDir(profile, env?.DSH_HOME),
-			env,
-			log: append
-		});
-	} catch (error) {
-		append(`dsh-plugin-shop: the download phase could not start — ${error.message}`);
-	}
+	if (ahead > 0 && prefetcher !== void 0) prefetch = requestDownloadPhase({
+		prefetcher,
+		profile,
+		spec: target,
+		env,
+		log: append
+	});
 	if (prefetch?.started === true) state = "downloading";
-	else if (prefetch !== null) append(prefetch.reason === "no-pnpm" ? "dsh-plugin-shop: no download phase — pnpm not found on PATH" : "dsh-plugin-shop: no download phase for this spec form; the install fetches it directly");
 	const finished = chain(profile, () => new Promise((resolve) => {
 		state = "running";
 		onStatus?.(status());
@@ -1998,7 +2057,7 @@ function spawnPluginCli(options) {
 				} else state = "done";
 			} else {
 				state = "failed";
-				detail = installFailureDetail(profile, log);
+				detail = installFailureDetail(profile, log.lines());
 			}
 			onStatus?.(status());
 			resolve(status());
@@ -3929,6 +3988,520 @@ async function readRunningHarness(script) {
 	}
 }
 //#endregion
+//#region src/host/plugin-manager.ts
+/**
+* dsh's `pluginManager` service (0.1.7 on), as far as this shop calls it:
+* design 2026-09-26-plugin-manager-delegation. Structural throughout: the
+* build compiles against the 0.1.1-rc.2 harness floor, where
+* `@deepseek-ai/dsh-plugin-manager` does not exist.
+*/
+const REQUIRED = [
+	"installBundle",
+	"removeBundle",
+	"setPluginEnabled",
+	"setBundleEnabled"
+];
+/** The service, when `service` offers every required operation; else null.
+* All or nothing: half a service would take an install and fail its
+* uninstall. */
+function asPluginManager(service) {
+	if (typeof service !== "object" || service === null) return null;
+	const candidate = service;
+	if (!REQUIRED.every((method) => typeof candidate[method] === "function")) return null;
+	if (candidate.cancelInstall !== void 0 && typeof candidate.cancelInstall !== "function") return null;
+	return service;
+}
+const text = (value) => typeof value === "string" ? value : null;
+const record = (value) => typeof value === "object" && value !== null ? value : {};
+function incompatibleList(value) {
+	if (!Array.isArray(value)) return [];
+	return value.flatMap((item) => {
+		const entry = record(item);
+		const name = text(entry.name);
+		const version = text(entry.version);
+		const runtimeVersion = text(entry.runtimeVersion);
+		if (name === null || version === null || runtimeVersion === null) return [];
+		return [{
+			name,
+			version,
+			runtimeVersion,
+			peers: Object.fromEntries(Object.entries(record(entry.peers)).filter((pair) => typeof pair[1] === "string"))
+		}];
+	});
+}
+/** Read one `ChangeResult`. Every field is optional: one a later harness
+* drops reads as absent, never as a crash. */
+function readChange(raw) {
+	const result = record(raw);
+	const error = record(result.error);
+	const run = record(result.packageResult);
+	const fromError = incompatibleList(error.incompatible);
+	return {
+		application: text(result.application),
+		stage: text(result.stage),
+		errorCode: text(error.code),
+		diagnostic: text(error.diagnostic),
+		incompatible: fromError.length > 0 ? fromError : incompatibleList(run.incompatible),
+		kind: text(run.kind),
+		output: text(run.output) ?? "",
+		pendingBuilds: Array.isArray(result.pendingBuilds) ? result.pendingBuilds.filter((name) => typeof name === "string") : [],
+		failedAt: text(result.failedAt),
+		changed: typeof result.changed === "boolean" ? result.changed : null,
+		truncated: run.truncated === true
+	};
+}
+/** True when `sentence` names a `dsh plugin` command. */
+function namesCliCommand(sentence) {
+	return sentence.includes("dsh plugin");
+}
+const isTerminal = (character) => character === "." || character === "!" || character === "?";
+const isSpace = (character) => /\s/.test(character);
+/** Splits `line` into sentences, each still carrying whatever whitespace
+* followed its `.`, `!` or `?`, so joining every piece back together
+* reproduces `line` exactly. A sentence ends after a run of terminal
+* punctuation that whitespace or the end of the line follows; the text after
+* the last such run is one more piece, so a line with no terminal
+* punctuation at all is one sentence spanning the whole line, and an empty
+* line gives none. One pass from left to right: the regex this replaced
+* backtracked quadratically on a long run of punctuation with no whitespace
+* after it, and dsh's output holds up to 16 KB of whatever pnpm printed. */
+function sentencesIn(line) {
+	const pieces = [];
+	let start = 0;
+	let index = 0;
+	while (index < line.length) {
+		if (!isTerminal(line.charAt(index))) {
+			index += 1;
+			continue;
+		}
+		let runEnd = index;
+		while (runEnd < line.length && isTerminal(line.charAt(runEnd))) runEnd += 1;
+		if (runEnd < line.length && !isSpace(line.charAt(runEnd))) {
+			index = runEnd;
+			continue;
+		}
+		let end = runEnd;
+		while (end < line.length && isSpace(line.charAt(end))) end += 1;
+		pieces.push(line.slice(start, end));
+		start = end;
+		index = end;
+	}
+	if (start < line.length) pieces.push(line.slice(start));
+	return pieces;
+}
+/** Where `sentence`'s terminator starts: its closing punctuation and the
+* whitespace after it. Scanned back from the end, so no run in dsh's output
+* can make it slow. */
+function terminatorStart(sentence) {
+	let end = sentence.length;
+	while (end > 0 && /\s/.test(sentence.charAt(end - 1))) end -= 1;
+	while (end > 0 && ".!?".includes(sentence.charAt(end - 1))) end -= 1;
+	return end;
+}
+/** `sentence`, with every clause that names a `dsh plugin` command removed.
+* A clause is a run between `; ` separators, and what is kept keeps the
+* sentence's terminator. A sentence with nothing to remove is returned
+* unchanged; one that loses every clause is dropped (null). */
+function scrubSentence(sentence) {
+	if (!namesCliCommand(sentence)) return sentence;
+	const end = terminatorStart(sentence);
+	const kept = sentence.slice(0, end).split("; ").filter((clause) => !namesCliCommand(clause));
+	return kept.length === 0 ? null : `${kept.join("; ")}${sentence.slice(end)}`;
+}
+/** `line`, with every clause that names a `dsh plugin` command removed (see
+* `scrubSentence`). A line with nothing to remove is returned unchanged (so
+* it stays exactly what it was); one that loses every sentence is dropped
+* (null). */
+function scrubLine(line) {
+	const sentences = sentencesIn(line);
+	if (sentences.length === 0) return line;
+	const kept = sentences.map(scrubSentence).filter((sentence) => sentence !== null);
+	return kept.length === 0 ? null : kept.join("");
+}
+function scrubText(value) {
+	return value.split("\n").map(scrubLine).filter((line) => line !== null).join("\n");
+}
+/** `change`, with every clause naming a `dsh plugin` command removed from
+* `diagnostic` and `output`: dsh's CLI refuses every `plugin` subcommand for
+* the desktop profile, so a step dsh wrote assuming that command exists must
+* not reach a reader there. Two dsh texts this exists for: dsh-app-boot's
+* `pluginCompatibilityWarning` ("... with `dsh plugin allow-version` or the
+* plugin manager ..."), whose sentence goes whole, and the restoration line
+* after a failed repair ("..., but node_modules could not be reinstalled;
+* run 'dsh plugin install'"), which keeps what it says dsh restored. A
+* clause is a run between `; ` separators within a sentence; a sentence left
+* with no clause is dropped, and so is a line left with no sentence. Every
+* other line stays untouched, and a diagnostic left empty afterward reads as
+* absent, the same way `codeReason` already treats one. */
+function forDesktopReader(change) {
+	return {
+		...change,
+		diagnostic: change.diagnostic === null ? null : scrubText(change.diagnostic),
+		output: scrubText(change.output)
+	};
+}
+/** The end of a detail that passes on what a service call threw: `: ` and
+* the message, scrubbed for a desktop reader as `forDesktopReader` scrubs
+* dsh's answer, since a thrown message is dsh's text as well. A message left
+* with nothing to say ends the detail with a period instead. */
+function thrownTail(message, desktop) {
+	const said = desktop ? scrubText(message) : message;
+	return said.trim() === "" ? "." : `: ${said}`;
+}
+/** What each management code means, in dsh 0.1.7-rc.2's own terms (the
+* implementation plan of 2026-09-27, Task 2, records where each is raised). */
+const CODE_SENTENCE = {
+	"unknown-plugin": "dsh lists no plugin entry by that id",
+	"invalid-spec": "dsh could not read the install spec",
+	"ambiguous-install": "dsh could not tell which package the install added",
+	"not-bundle": "the package is not a dsh bundle",
+	"not-removable": "dsh does not allow removing this bundle",
+	"stop-profile": "the bundle is running and this dsh cannot unload it live, so the profile has to be stopped first",
+	"bundle-in-use": "the bundle was switched off, but some of its plugins are still running",
+	"stale-approval": "a build approval names a package pnpm no longer holds",
+	"management-required": "the plugin belongs to dsh itself",
+	unaddressable: "the plugin is not a row of the profile's own patch, so dsh cannot address it",
+	"operation-error": "dsh hit an unexpected error"
+};
+/** What each classified pnpm failure was, as dsh classifies it. */
+const KIND_SENTENCE = {
+	"pnpm-missing": "pnpm could not be started",
+	timeout: "pnpm did not finish within dsh's own time bound",
+	"not-found": "no such package was found",
+	"no-matching-version": "no version matching the requested one was found",
+	network: "the network failed",
+	"disk-full": "the disk is full",
+	permission: "permission was denied",
+	integrity: "the downloaded package failed its integrity check"
+};
+const WHERE = {
+	registry: " at the registry",
+	"spec-host": " at the host the package is fetched from"
+};
+/** An own-property read of one of the three tables above. They are object
+* literals, so a bare index read answers for Object.prototype, and a code of
+* `toString` would publish a function's source as dsh's reason (R43). */
+const lookup = (table, key) => Object.hasOwn(table, key) ? table[key] : void 0;
+/** The pnpm-failure hint a desktop reader gets: it names no command, which
+* the CLI would refuse for that profile. */
+const DESKTOP_FAILURE_HINT = "pnpm failed in the profile";
+/** What dsh says it restored after refusing, from its own restoration line:
+* the first `dsh: ` line after the one opening the refusal
+* (dsh-plugin-manager's `rejected`), read as the CLI path's `refusalDetail`
+* reads it, capitalized and ending in dsh's own period. Null when the output
+* holds no such line, being empty or cut short. */
+function restorationSentence(output) {
+	const lines = output.split(/\r?\n/);
+	const start = lines.findIndex((line) => line.startsWith(REFUSAL_OPENER));
+	if (start === -1) return null;
+	const said = lines.slice(start + 1).find((later) => later.startsWith("dsh: "))?.slice(5).trim() ?? "";
+	return said === "" ? null : `${said.charAt(0).toUpperCase()}${said.slice(1)}`;
+}
+/** The refusal of a package the running dsh rejects on its peers, for the
+* operation dsh refused: an install, an update, or an uninstall whose pnpm
+* run touched an incompatible sibling. What dsh restored is dsh's to say,
+* so its restoration line is passed on. Without one, an install or update
+* says what dsh's own pre-check says, and an uninstall says nothing of it. */
+function versionRefusalDetail(context, change) {
+	const refused = change.incompatible.map((issue) => `${issue.name}@${issue.version} declares ${Object.entries(issue.peers).map(([peer, range]) => `${peer} ${range}`).join(", ")}, which dsh ${issue.runtimeVersion} does not satisfy`);
+	const restored = restorationSentence(change.output) ?? (context.operation === "uninstall" || change.truncated ? null : "Nothing was installed.");
+	const base = `dsh-plugin-shop: dsh refused the ${context.operation}: ${refused.join("; ")}.${restored === null ? "" : ` ${restored}`}`;
+	if (context.desktop) return `${base} dsh's CLI, which grants version exemptions, does not manage the desktop profile, and this shop grants none.`;
+	const commands = change.incompatible.map((issue) => allowVersionCommand(context.profile, issue)).filter((command) => command !== null);
+	if (commands.length === 0) return base;
+	return `${base} To accept the risk of crashes or data loss for ${commands.length === 1 ? "this exact version" : "these exact versions"}, run: ${commands.join("; ")} - then ${context.operation} again.`;
+}
+/** The sentence a management code gets, plus dsh's own diagnostic. The
+* diagnostic is trimmed and stripped of one trailing period so one that
+* already ends in a period is not doubled; empty after that reads as
+* absent. Exported: Task 7 builds the same tail for a non-terminal notice. */
+function codeReason(change, code) {
+	const sentence = lookup(CODE_SENTENCE, code);
+	const diagnostic = change.diagnostic !== null ? change.diagnostic.trim().replace(/\.$/, "") : "";
+	const said = diagnostic !== "" ? ` dsh reported: ${diagnostic}.` : "";
+	return `${sentence !== void 0 ? `: ${sentence}` : ""}.${said}`;
+}
+/** A desktop reader's detail for build scripts pnpm held. The app bundles
+* its own package manager, so `pnpm approve-builds` is no step for this
+* reader, and the shop never allows build scripts itself. dsh's own Plugins
+* page offers "Allow these scripts and retry" on the failed screen of an
+* install it runs, listing the held packages (dsh-client-ui-plugin-manager
+* 0.1.7-rc.2: `installApproveAndRetry` in lib/client.js, and its README), so
+* that is named, but only for an install whose held builds dsh listed. Its
+* Add plugin dialog refuses a name the profile already holds, so it cannot
+* rerun an update, and with no name listed it offers no such button. */
+function desktopBuildsDetail(context, change, held) {
+	const base = `dsh-plugin-shop: pnpm is holding the build scripts of ${held}, which it blocks by default, and this shop never allows them.`;
+	if (context.operation !== "install" || change.pendingBuilds.length === 0) return base;
+	return `${base} dsh's Plugins page offers "Allow these scripts and retry" when an install it runs stops on them.`;
+}
+/** What a `cancelled` answer means, for every reader: the shop's deadline
+* asked dsh to stop the operation, and dsh answers `cancelled` only once its
+* repository check or pnpm has exited and package.json and pnpm-lock.yaml
+* are back as they were (dsh-plugin-manager 0.1.7-rc.2: cancelInstall, and
+* InstallCancelledError, thrown after the files are restored). Nothing was
+* installed, so the detail names no command: the CLI's `install`, which the
+* CLI path's own timeout detail names, would no longer involve the package.
+* Only installBundle can be cancelled, so the operation is an install or an
+* update. */
+function cancelledDetail(context) {
+	const seconds = Math.max(1, Math.round(context.timeoutMs / 1e3));
+	return `dsh-plugin-shop: the ${context.operation} did not finish within ${seconds}s, so the shop cancelled it. dsh stopped it, restored the profile's package.json and pnpm-lock.yaml, and installed nothing. Try the ${context.operation} again from the shop.`;
+}
+/** A `ChangeResult` as the shop's terminal install record: design
+* 2026-09-26-plugin-manager-delegation, section 5, read by the first rule
+* that matches. A removal that failed after dsh changed the profile says,
+* after whichever rule read it, that the package is still installed and
+* switched off. */
+function managerOutcome(raw, context) {
+	const change = context.desktop ? forDesktopReader(readChange(raw)) : readChange(raw);
+	const outcome = outcomeByRule(change, context);
+	if (context.operation === "uninstall" && outcome.state === "failed" && change.changed === true) {
+		const switchedOff = `${context.name} is still installed, but dsh has switched it off.`;
+		if (outcome.detail === void 0) return {
+			...outcome,
+			detail: switchedOff
+		};
+		const needsPeriod = !/[.!?]$/.test(outcome.detail);
+		return {
+			...outcome,
+			detail: `${outcome.detail}${needsPeriod ? "." : ""} ${switchedOff}`
+		};
+	}
+	return outcome;
+}
+/** The section 5 rules, in order; the first that matches wins. */
+function outcomeByRule(change, context) {
+	if (change.errorCode === "incompatible-version" || change.errorCode === "operation-error" && change.incompatible.length > 0) return {
+		state: "failed",
+		detail: versionRefusalDetail(context, change)
+	};
+	if (change.application === "failed" && change.stage === "enable") {
+		const code = change.errorCode ?? "failed";
+		return {
+			state: "failed",
+			detail: `dsh-plugin-shop: ${context.name} is installed, but dsh could not enable it (${code})${codeReason(change, code)} Uninstall it from the shop to undo the install.`
+		};
+	}
+	if (change.application === "failed" && change.kind !== null && (change.errorCode === null || change.errorCode === "operation-error")) {
+		if (change.kind === "build-blocked") {
+			const held = change.pendingBuilds.length > 0 ? change.pendingBuilds.join(", ") : "a dependency";
+			if (context.desktop) return {
+				state: "failed",
+				detail: desktopBuildsDetail(context, change, held)
+			};
+			return {
+				state: "failed",
+				detail: `dsh-plugin-shop: pnpm is holding the build scripts of ${held}, which it blocks by default: run \`pnpm approve-builds\` in the profile directory to allow them, then ${context.operation} again.`
+			};
+		}
+		if (change.kind === "timeout" && change.failedAt === "spec-host") return {
+			state: "failed",
+			detail: `dsh-plugin-shop: the ${context.operation} failed at the host the package is fetched from: dsh checks that a GitHub repository is reachable before pnpm runs, and that check did not finish within its bound (5 s by default), so pnpm never ran.`
+		};
+		const sentence = lookup(KIND_SENTENCE, change.kind);
+		if (sentence !== void 0) {
+			const where = change.failedAt === null ? "" : lookup(WHERE, change.failedAt) ?? "";
+			return {
+				state: "failed",
+				detail: `dsh-plugin-shop: the ${context.operation} failed${where}: ${sentence}.`
+			};
+		}
+		const lines = change.output.split(/\r?\n/).filter((line) => line !== "");
+		return {
+			state: "failed",
+			detail: context.desktop ? installFailureDetail(context.profile, lines, DESKTOP_FAILURE_HINT) : installFailureDetail(context.profile, lines)
+		};
+	}
+	if (change.errorCode !== null) return {
+		state: "failed",
+		detail: `dsh-plugin-shop: dsh ${change.errorCode === "operation-error" ? `could not ${context.operation} ${context.name}` : `refused the ${context.operation} of ${context.name}`} (${change.errorCode})${codeReason(change, change.errorCode)}`
+	};
+	if (change.application === "cancelled") return {
+		state: "failed",
+		detail: cancelledDetail(context)
+	};
+	if (change.application === "restart-required") return context.operation === "update" ? {
+		state: "done",
+		activation: "restart",
+		restartReason: "already-loaded"
+	} : {
+		state: "done",
+		activation: "restart"
+	};
+	if (change.application === "applied" || change.application === "overridden") {
+		const note = change.application === "overridden" ? { detail: "Saved, but a higher-priority layer (the home or invocation patch) decides whether it runs." } : {};
+		if (context.operation !== "uninstall" && context.alreadyImported) return {
+			state: "done",
+			activation: "restart",
+			restartReason: "already-loaded",
+			...note
+		};
+		return {
+			state: "done",
+			activation: activationOf({
+				hostLive: true,
+				clientLive: true,
+				hasClientHalf: context.hasClientHalf
+			}),
+			...note
+		};
+	}
+	return {
+		state: "failed",
+		detail: `dsh-plugin-shop: dsh answered the ${context.operation} with "${change.application ?? "nothing"}", which this shop does not know how to read.`
+	};
+}
+//#endregion
+//#region src/host/manager-runner.ts
+/**
+* One package operation through dsh's `pluginManager` service, tracked as the
+* same `RunningInstall` the CLI executor produces: design
+* 2026-09-26-plugin-manager-delegation, section 6. It runs in the same
+* per-profile queue as CLI commands, so the two paths are never concurrent in
+* one profile.
+*/
+/** The first line of every record this runner writes. The shop's log panel
+* shows it and the 0.1.7 e2e asserts it, so a silent fall back to the CLI
+* fails a case instead of passing it. */
+const MECHANISM_PREFIX = "via dsh's plugin manager:";
+/** Routes the service's `plugin-manager/install-log` chunks to the record
+* whose request id they carry. A chunk for any other id is dropped. dsh
+* tags each chunk with the stream it came from; a non-string stream reads
+* as `stdout`, matching a harness that predates the tag. */
+var ManagerLogs = class {
+	sinks = /* @__PURE__ */ new Map();
+	open(requestId, sink) {
+		this.sinks.set(requestId, sink);
+		return () => {
+			this.sinks.delete(requestId);
+		};
+	}
+	chunk(requestId, text, stream) {
+		if (typeof requestId !== "string" || typeof text !== "string") return;
+		this.sinks.get(requestId)?.(text, typeof stream === "string" ? stream : "stdout");
+	}
+};
+/** What every value this cannot describe reads as. */
+const UNREADABLE = "an error with no readable message";
+/** What a thrown value says about itself, and total: describing an error is
+* never itself the reason a settle fails. An `Error` gives its `message`,
+* anything else `String(value)`. A message that is not a string, or a
+* description that throws anywhere, reads as one fixed string: a Proxy whose
+* getPrototypeOf trap throws defeats `instanceof` itself, a `message` getter
+* can throw, and a null-prototype object has no conversion to a string. */
+const messageOf = (error) => {
+	try {
+		const said = error instanceof Error ? error.message : String(error);
+		if (typeof said === "string") return said;
+	} catch {}
+	return UNREADABLE;
+};
+function startManagerOperation(options) {
+	const { profile, requestId, mechanism, logs, run, cancel, outcome, alsoConfirm, prefetcher, spec, env, desktop = false } = options;
+	const timeoutMs = options.timeoutMs ?? INSTALL_TIMEOUT_MS;
+	const mechanismLine = `${MECHANISM_PREFIX} ${mechanism}`;
+	const log = createBoundedLog();
+	let state = "running";
+	let settled = null;
+	let streamed = false;
+	const status = () => ({
+		state,
+		log: [mechanismLine, ...log.lines()],
+		...settled?.state === "done" && settled.activation !== void 0 ? { activation: settled.activation } : {},
+		...settled?.state === "done" && settled.restartReason !== void 0 ? { restartReason: settled.restartReason } : {},
+		...settled?.detail !== void 0 ? { detail: settled.detail } : {}
+	});
+	const append = (line) => {
+		if (isTerminalInstallState(state)) return;
+		log.push(line);
+	};
+	const streams = /* @__PURE__ */ new Map();
+	const streamFor = (stream) => {
+		let sink = streams.get(stream);
+		if (sink === void 0) {
+			sink = lineSink(append);
+			streams.set(stream, sink);
+		}
+		return sink;
+	};
+	const flushStreams = () => {
+		for (const sink of streams.values()) sink.flush();
+	};
+	const close = logs.open(requestId, (text, stream) => {
+		streamed = true;
+		streamFor(stream).write(Buffer.from(text, "utf8"));
+	});
+	const queued = inProfileQueue(profile, async () => {
+		state = "running";
+		let deadline;
+		if (cancel !== void 0) deadline = setTimeout(() => {
+			Promise.resolve().then(() => cancel(requestId)).catch(() => {});
+		}, timeoutMs);
+		let raw;
+		try {
+			raw = await run(requestId);
+		} catch (error) {
+			flushStreams();
+			settled = {
+				state: "failed",
+				detail: `dsh-plugin-shop: dsh's plugin manager failed${thrownTail(messageOf(error), desktop)}`
+			};
+			state = "failed";
+			return status();
+		} finally {
+			clearTimeout(deadline);
+		}
+		let result;
+		try {
+			flushStreams();
+			if (!streamed) {
+				for (const line of readChange(raw).output.split(/\r?\n/)) if (line !== "") append(line);
+			}
+			result = outcome(raw);
+		} catch (error) {
+			settled = {
+				state: "failed",
+				detail: `dsh-plugin-shop: the shop could not read dsh's answer: ${messageOf(error)}`
+			};
+			state = "failed";
+			return status();
+		}
+		if (result.state === "done" && alsoConfirm !== void 0) try {
+			const objection = alsoConfirm();
+			if (objection !== null) result = {
+				state: "failed",
+				detail: objection
+			};
+		} catch (error) {
+			result = {
+				state: "failed",
+				detail: `dsh-plugin-shop: the shop could not check what dsh installed: ${messageOf(error)}`
+			};
+		}
+		settled = result;
+		state = result.state;
+		return status();
+	});
+	if ((queued.ahead > 0 && prefetcher !== void 0 && spec !== void 0 ? requestDownloadPhase({
+		prefetcher,
+		profile,
+		spec,
+		env,
+		log: append
+	}) : null)?.started === true && !isTerminalInstallState(state)) state = "downloading";
+	const finished = queued.finished.finally(() => {
+		close();
+		if (prefetcher !== void 0 && spec !== void 0) prefetcher.release(profile, spec);
+	});
+	finished.catch(() => {});
+	return {
+		installId: requestId,
+		status,
+		finished
+	};
+}
+//#endregion
 //#region src/host/index.ts
 /** ShopGateway: the Host half of dsh-plugin-shop (§5.1). */
 var __runInitializers = function(thisArg, initializers, value) {
@@ -3991,6 +4564,15 @@ const RESTART_BLOCKED_DETAIL = {
 * the profile before any of them would run (`isDesktopProfile`), and the
 * failure that surfaced instead read "pnpm failed in the profile". */
 const DESKTOP_PROFILE_DETAIL = "dsh-plugin-shop: the desktop profile is managed by the DeepSeek Harness desktop app, and dsh refuses to change it from the command line the shop runs; add and remove its plugins from the app instead";
+/** Why a switch through dsh's `pluginManager` waits for an operation this
+* gateway started: dsh holds its profile lock for a whole install or removal
+* (`change()` wraps pnpm) and makes any other change wait for it up to its
+* `lockWaitMs`, 120 s, so a switch clicked mid-install would spin for two
+* minutes and then fail on the lock. The check is F-5's, `hasRunningCommand`.
+* The shop's own row writer takes no dsh lock, so what it writes alone (the
+* CLI path's switch, and switching a deselected package off) is not
+* refused. */
+const switchWhileBusyDetail = (name) => `dsh-plugin-shop: an install, update or uninstall is still running in this profile, and dsh holds the profile until it ends; switch ${name} after it finishes.`;
 /** How many bytes a release tarball may be at the integrity check. The
 * registry already refuses to publish a tarball over 32 MiB, so 64 MiB is
 * headroom, not a gate of its own. */
@@ -4063,8 +4645,12 @@ function ownDependencySpec(dependencies, name) {
 * process's: a gateway rebuilt inside a running dsh — a restarted shop fiber —
 * must not forget what the process imported before it existed. Every gateway
 * seeds it with the profile's dependencies at construction (the boot
-* composition) and extends it with every name the hot path mounts. Nothing is
-* ever removed: an uninstall disposes the fiber, not the module record.
+* composition) and extends it with every name the hot path mounts. It extends
+* it again with every name one of its own installs through dsh's
+* `pluginManager` brought to the enable stage, and with the profile's
+* dependencies whenever that service reports an install: dsh's own Plugins
+* page installs through it, and the report names no package. Nothing is ever
+* removed: an uninstall disposes the fiber, not the module record.
 */
 const importedThisProcess = /* @__PURE__ */ new Set();
 /** Remote-only service exposing the shop Remote methods of §7.3.
@@ -4244,6 +4830,11 @@ let ShopGateway = (() => {
 		exit;
 		restartExitDelayMs;
 		restartParentPid;
+		/** The restart this process committed, once it has: every later
+		* `shop/restart` answers with it. A page that lost the first answer to an
+		* HMR swap asks again (client/restart-monitor.ts), and inside the exit
+		* delay that ask reaches this same process. */
+		committedRestart = null;
 		latestVersion;
 		pinFs;
 		allowRestart;
@@ -4262,6 +4853,9 @@ let ShopGateway = (() => {
 		prefetcher;
 		/** What this process may already have imported (see `importedThisProcess`). */
 		imported;
+		/** Routes the output dsh's `pluginManager` streams to the record whose
+		* request id it carries (see the constructor). */
+		managerLogs;
 		/** The install gate runs against the last loaded snapshot, never a fresh
 		* fetch per request (§7.2: the Host's cached snapshot is the truth). */
 		/** Finished install records retained, so a poll sees the true terminal
@@ -4286,7 +4880,8 @@ let ShopGateway = (() => {
 		* promise, so concurrent first calls share one read; `readRunningHarness`
 		* never rejects, so there is no failure to retry. */
 		harnessRead = null;
-		/** Install records, running and finished; a poll finds one here or reports not found. */
+		/** Install records, running and finished, from the CLI and from dsh's
+		* `pluginManager` alike; a poll finds one here or reports not found. */
 		installs = /* @__PURE__ */ new Map();
 		/** Every install id in insertion order, oldest first; finished-record eviction walks this from the front. */
 		installOrder = [];
@@ -4322,7 +4917,16 @@ let ShopGateway = (() => {
 			this.fetchTarball = options.fetchTarball ?? ((url) => fetch(url));
 			this.prefetcher = options.prefetcher ?? createPrefetcher();
 			this.imported = options.importedModules ?? importedThisProcess;
-			for (const name of Object.keys(this.profileDependenciesOrNone() ?? {})) this.imported.add(name);
+			this.recordDependenciesImported();
+			this.managerLogs = new ManagerLogs();
+			const on = this.ctx.on;
+			on?.call(this.ctx, "plugin-manager/install-log", (payload) => {
+				const chunk = payload;
+				this.managerLogs.chunk(chunk?.requestId, chunk?.text, chunk?.stream);
+			});
+			on?.call(this.ctx, "plugin-manager/changed", (payload) => {
+				if (payload?.reason === "install") this.recordDependenciesImported();
+			});
 			try {
 				cleanHotDir(this.profileDirResolved());
 			} catch {}
@@ -4390,14 +4994,15 @@ let ShopGateway = (() => {
 			const service = this.ctx.get?.("pluginPackages");
 			return typeof service?.packageOf === "function" ? service : null;
 		}
-		/** dsh's `pluginManager` service, when the running harness provides one
-		* (0.1.7 and later), else null. Read on each use, like `pluginPackages`.
-		* It is the only way back for a bundle its Plugins page deselected: the
-		* 0.1.7 CLI does not select an installed package again on `add`, while
-		* 0.1.5's does (both measured 2026-09-27). */
+		/** dsh's `pluginManager` service, when the running harness provides all of
+		* it (0.1.7 and later), else null. Never cached across calls, like
+		* `pluginPackages`, but read once per RPC, at its start, and passed down:
+		* read again after an await, a service disposed in between would let a
+		* desktop mutation past the desktop gate and onto the CLI path, which dsh
+		* refuses for that profile. Design 2026-09-26-plugin-manager-delegation,
+		* section 3.1. */
 		pluginManager() {
-			const service = this.ctx.get?.("pluginManager");
-			return typeof service?.setBundleEnabled === "function" ? service : null;
+			return asPluginManager(this.ctx.get?.("pluginManager"));
 		}
 		/** "Does this installation provide `spec`?", asked from `anchor`: the
 		* harness's own resolution in front of the walk where the harness has one,
@@ -4495,6 +5100,13 @@ let ShopGateway = (() => {
 			const dependencies = this.profileDependenciesOrNone();
 			return dependencies === void 0 ? void 0 : ownDependencySpec(dependencies, name);
 		}
+		/** Add every dependency the profile manifest holds to the `imported`
+		* record (see `importedThisProcess`): each is a package dsh's loader may
+		* have loaded in this process, at boot or by an install since. An
+		* unreadable manifest adds nothing. */
+		recordDependenciesImported() {
+			for (const name of Object.keys(this.profileDependenciesOrNone() ?? {})) this.imported.add(name);
+		}
 		ownedEntryIdsOrNone(packageName) {
 			try {
 				return ownedEntryIds({
@@ -4564,6 +5176,7 @@ let ShopGateway = (() => {
 				ok: false,
 				detail: `dsh-plugin-shop: ${args.name} is part of the harness chain and cannot be toggled from the shop`
 			};
+			const manager = this.pluginManager();
 			const profileDir = this.profileDirResolved();
 			const manifest = readProfileManifest("dsh-plugin-shop", profileDir);
 			if (!Object.hasOwn(manifest.dependencies ?? {}, args.name)) return {
@@ -4587,12 +5200,59 @@ let ShopGateway = (() => {
 				detail: `dsh-plugin-shop: ${args.name} contributes no plugin entries, so there is nothing to enable or disable`
 			};
 			const selected = this.runningProfileBundles(profileDir);
-			if (selected !== null && !selected.includes(args.name)) return this.setDeselectedEnabled(args.name, args.enabled, profileDir, owned);
+			if (selected !== null && !selected.includes(args.name)) return this.setDeselectedEnabled(args.name, args.enabled, profileDir, owned, manager);
 			const ownedSet = new Set(owned.map((entry) => entry.id));
-			if ((await this.listInventory()).filter((entry) => ownsEntryId(ownedSet, entry.entryId)).length === 0) return {
+			const live = (await this.listInventory()).filter((entry) => ownsEntryId(ownedSet, entry.entryId));
+			if (live.length === 0) return {
 				ok: false,
 				detail: `dsh-plugin-shop: ${args.name} is installed but its entries are not in the running plugin tree; restart dsh to compose them`
 			};
+			if (manager !== null) {
+				if (this.hasRunningCommand()) return {
+					ok: false,
+					detail: switchWhileBusyDetail(args.name)
+				};
+				let restart = false;
+				let switched = 0;
+				const failed = (detail) => {
+					if (switched === 0) return {
+						ok: false,
+						detail
+					};
+					return {
+						ok: false,
+						detail: `${/[.!?]$/.test(detail) ? detail : `${detail}.`} ${switched} of its ${live.length} plugins had already switched ${args.enabled ? "on" : "off"}.`
+					};
+				};
+				for (const entry of live) {
+					let raw;
+					try {
+						raw = await manager.setPluginEnabled(entry.entryId, args.enabled);
+					} catch (error) {
+						return failed(`dsh-plugin-shop: dsh could not switch ${args.name}${thrownTail(messageOf(error), isDesktopProfile(this.profile))}`);
+					}
+					const { change, failure } = this.readManagerAnswer(raw, {
+						act: `switch ${args.name}`,
+						request: `the switch for ${args.name}`,
+						stays: args.enabled ? "off" : "on"
+					});
+					if (failure !== null) return failed(failure);
+					switched += 1;
+					if (change.application === "restart-required") restart = true;
+				}
+				if (restart) return {
+					ok: true,
+					activation: "restart"
+				};
+				return {
+					ok: true,
+					activation: activationOf({
+						hostLive: true,
+						clientLive: true,
+						hasClientHalf: this.packageHasClientHalf(args.name)
+					})
+				};
+			}
 			setUserLayerRows({
 				profileDir,
 				rows: owned.map(({ id, name }) => ({
@@ -4623,7 +5283,7 @@ let ShopGateway = (() => {
 		* not printed: it selects the bundle again only on 0.1.5, and it lets pnpm
 		* float a registry package to `latest`.
 		*/
-		async setDeselectedEnabled(name, enabled, profileDir, owned) {
+		async setDeselectedEnabled(name, enabled, profileDir, owned, manager) {
 			const rows = owned.map(({ id, name: moduleName }) => ({
 				id,
 				disabled: !enabled,
@@ -4639,23 +5299,31 @@ let ShopGateway = (() => {
 					activation: "live"
 				};
 			}
-			const manager = this.pluginManager();
 			if (manager === null) return {
 				ok: false,
 				detail: `dsh-plugin-shop: ${name} is installed but switched off at the bundle level: dsh.profile.bundles in ${join(profileDir, "package.json")} does not list it, so dsh composes none of it, and a restart will not change that. This dsh has no pluginManager service to select it again: add "${name}" back to that list and restart dsh, or uninstall it and install it again from the shop.`
 			};
-			let change;
+			if (this.hasRunningCommand()) return {
+				ok: false,
+				detail: switchWhileBusyDetail(name)
+			};
+			let raw;
 			try {
-				change = await manager.setBundleEnabled(name, true);
+				raw = await manager.setBundleEnabled(name, true);
 			} catch (error) {
 				return {
 					ok: false,
-					detail: `dsh-plugin-shop: dsh could not select ${name} again: ${String(error)}`
+					detail: `dsh-plugin-shop: dsh could not select ${name} again${thrownTail(messageOf(error), isDesktopProfile(this.profile))}`
 				};
 			}
-			if (change.application === "failed" || change.application === "cancelled" || change.error !== void 0) return {
+			const { change, failure } = this.readManagerAnswer(raw, {
+				act: `select ${name} again`,
+				request: `the selection of ${name}`,
+				stays: "off"
+			});
+			if (failure !== null) return {
 				ok: false,
-				detail: `dsh-plugin-shop: dsh refused to select ${name} again (${typeof change.error?.code === "string" ? change.error.code : String(change.application)})${typeof change.error?.diagnostic === "string" ? `: ${change.error.diagnostic}` : ""}`
+				detail: failure
 			};
 			setUserLayerRows({
 				profileDir,
@@ -4674,6 +5342,47 @@ let ShopGateway = (() => {
 				})
 			};
 		}
+		/**
+		* dsh's answer to a switch or a bundle selection, read the one way both
+		* callers need it (R32): the change, scrubbed for a desktop reader, and the
+		* detail that fails the request, or null when dsh applied it. `act` is what
+		* was asked, as "switch <name>", `request` names the request itself, as
+		* "the switch for <name>", and `stays` is the state the plugin keeps when
+		* the request does not take effect. An application this shop does not know
+		* fails rather than reading as applied: a later harness may answer
+		* something new.
+		*
+		* `overridden` fails too (R39). dsh answers it when, after it wrote the row
+		* and reloaded, the live entry still differs from the request
+		* (dsh-plugin-manager 0.1.7-rc.2, setPluginEnabled), and its README names
+		* what outranks the profile's own patch: home and invocation patches keep
+		* their higher priority. The change is saved and the plugin runs as it
+		* did, so a success would flip the client's switch over a plugin that did
+		* not change, and that switch never re-reads the live state.
+		* setBundleEnabled never answers it; a selection reads it the same way.
+		*/
+		readManagerAnswer(raw, words) {
+			const change = isDesktopProfile(this.profile) ? forDesktopReader(readChange(raw)) : readChange(raw);
+			if (change.application === "failed" || change.application === "cancelled" || change.errorCode !== null) {
+				const code = change.errorCode ?? change.application ?? "failed";
+				return {
+					change,
+					failure: `dsh-plugin-shop: dsh ${code === "operation-error" ? "could not" : "refused to"} ${words.act} (${code})${codeReason(change, code)}`
+				};
+			}
+			if (change.application === "overridden") return {
+				change,
+				failure: `dsh-plugin-shop: dsh saved ${words.request}, but a home or invocation patch, which outranks the profile's own, keeps it ${words.stays}.`
+			};
+			if (change.application === "applied" || change.application === "restart-required") return {
+				change,
+				failure: null
+			};
+			return {
+				change,
+				failure: `dsh-plugin-shop: dsh answered ${words.request} with "${change.application ?? "nothing"}", which this shop does not know how to read.`
+			};
+		}
 		rowConfig() {
 			if (this.options.catalogUrl !== void 0 && this.options.cacheDir !== void 0) return {
 				catalogUrl: this.options.catalogUrl,
@@ -4866,7 +5575,8 @@ let ShopGateway = (() => {
 		* passing request reaches the executor.
 		*/
 		async install(args) {
-			if (isDesktopProfile(this.profile)) return {
+			const manager = this.pluginManager();
+			if (isDesktopProfile(this.profile) && manager === null) return {
 				ok: false,
 				code: "desktop-profile",
 				detail: DESKTOP_PROFILE_DETAIL
@@ -4897,31 +5607,29 @@ let ShopGateway = (() => {
 				};
 				spec = `github:${entry.repo}#${args.version}${entry.subdir !== void 0 ? `&path:${entry.subdir}` : ""}`;
 			} else spec = `${args.name}@${args.version}`;
-			const alreadyImported = installedSpec !== void 0 || this.imported.has(args.name);
+			const isUpdate = installedSpec !== void 0;
+			const alreadyImported = isUpdate || this.imported.has(args.name);
 			const harness = await this.runningHarness();
+			if (manager !== null) {
+				const running = this.startManagerInstall(manager, spec, `install ${spec}`, (raw) => {
+					if (!isUpdate && readChange(raw).stage === "enable") this.imported.add(args.name);
+					return managerOutcome(raw, this.outcomeContext(args.name, isUpdate ? "update" : "install", alreadyImported, this.packageHasClientHalf(args.name)));
+				}, () => this.postInstallHazard(args.name, harness, " It is on disk: uninstall it from the shop to undo this install."));
+				this.track(running);
+				this.recordGithubPin(entry);
+				return {
+					ok: true,
+					installId: running.installId,
+					state: running.status().state
+				};
+			}
 			const running = startInstall({
 				profile: this.profile,
 				spec,
 				dshBin: this.dshBin,
 				expectedName: args.name,
 				prefetcher: this.prefetcher,
-				alsoConfirm: () => {
-					const clash = collidingEntryId({
-						profileDir: this.profileDirResolved(),
-						packageName: args.name,
-						dependencies: Object.keys(this.profileDependenciesOrNone() ?? {})
-					});
-					const undo = ` It is on disk: run \`dsh plugin --profile ${this.profile} remove ${args.name}\` to undo this install.`;
-					if (clash !== null) return `dsh-plugin-shop: ${args.name} declares the loader entry id "${clash.id}", which ${clash.holder} already declares. dsh refuses to load a plugin tree holding a duplicate entry id, so the profile would not start.` + undo;
-					switch (patchDeclarationHazard(declaredBundlePatch({
-						profileDir: this.profileDirResolved(),
-						packageName: args.name
-					}), harness.patchLists)) {
-						case null: return null;
-						case "list-unsupported": return `dsh-plugin-shop: ${args.name} lists its bundle patch as several files, which dsh reads from 0.1.7 on; this dsh${harness.dshVersion === null ? "" : ` (${harness.dshVersion})`} reads one and would not start with it installed.` + undo;
-						case "malformed": return `dsh-plugin-shop: ${args.name} declares its bundle patch as neither a file path nor a list of them, which dsh refuses to load, so the profile would not start.` + undo;
-					}
-				},
+				alsoConfirm: () => this.postInstallHazard(args.name, harness, ` It is on disk: run \`dsh plugin --profile ${this.profile} remove ${args.name}\` to undo this install.`),
 				afterDone: async () => {
 					if (alreadyImported) return {
 						activation: "restart",
@@ -4944,22 +5652,116 @@ let ShopGateway = (() => {
 					}) };
 				}
 			});
-			if (entry.source === "github") {
-				const pins = readRepoPins(this.pinFs, this.pinsPath());
-				writeRepoPins(this.pinFs, this.pinsPath(), {
-					...pins,
-					[identityKey(entry)]: entry.version
-				});
-			}
-			this.installs.set(running.installId, running);
-			this.installOrder.push(running.installId);
-			this.evictFinishedInstalls();
+			this.recordGithubPin(entry);
+			this.track(running);
 			return {
 				ok: true,
 				installId: running.installId,
 				state: running.status().state
 			};
 		}
+		/**
+		* What would stop the profile from starting now that `name`'s files are on
+		* disk, or null: an entry id another installed package already declares,
+		* or a bundle patch declaration this dsh cannot read. Neither is knowable
+		* before the files land. The package stays on disk either way, so each
+		* detail ends with `undo`, the sentence that says how to take the install
+		* back on the path that made it.
+		*/
+		postInstallHazard(name, harness, undo) {
+			const clash = collidingEntryId({
+				profileDir: this.profileDirResolved(),
+				packageName: name,
+				dependencies: Object.keys(this.profileDependenciesOrNone() ?? {})
+			});
+			if (clash !== null) return `dsh-plugin-shop: ${name} declares the loader entry id "${clash.id}", which ${clash.holder} already declares. dsh refuses to load a plugin tree holding a duplicate entry id, so the profile would not start.` + undo;
+			switch (patchDeclarationHazard(declaredBundlePatch({
+				profileDir: this.profileDirResolved(),
+				packageName: name
+			}), harness.patchLists)) {
+				case null: return null;
+				case "list-unsupported": return `dsh-plugin-shop: ${name} lists its bundle patch as several files, which dsh reads from 0.1.7 on; this dsh${harness.dshVersion === null ? "" : ` (${harness.dshVersion})`} reads one and would not start with it installed.` + undo;
+				case "malformed": return `dsh-plugin-shop: ${name} declares its bundle patch as neither a file path nor a list of them, which dsh refuses to load, so the profile would not start.` + undo;
+			}
+		}
+		/** Remember a github entry's pinned commit: the manifest records only
+		* `github:owner/slug`, so the pins file is how `installed()` reports
+		* outdated honestly. A failed install leaves a pin behind, but the
+		* manifest presence gate keeps it invisible. */
+		recordGithubPin(entry) {
+			if (entry.source !== "github") return;
+			const pins = readRepoPins(this.pinFs, this.pinsPath());
+			writeRepoPins(this.pinFs, this.pinsPath(), {
+				...pins,
+				[identityKey(entry)]: entry.version
+			});
+		}
+		/** Forget an uninstalled package's pins: its own, and its identity pin when
+		* a catalog row matched the installed spec. Both uninstall paths call this
+		* once their operation has started, so a stale pin never outlives the
+		* uninstall in the shop's cache either way. The plugin manager path tracks
+		* its record first, so a write here that throws cannot hide an operation
+		* already queued. */
+		forgetPins(name, installedEntry) {
+			const pins = readRepoPins(this.pinFs, this.pinsPath());
+			const stalePins = [name, ...installedEntry === void 0 ? [] : [identityKey(installedEntry)]];
+			let forgot = false;
+			for (const key of stalePins) {
+				if (pins[key] === void 0) continue;
+				delete pins[key];
+				forgot = true;
+			}
+			if (forgot) writeRepoPins(this.pinFs, this.pinsPath(), pins);
+		}
+		/** What `managerOutcome` reads dsh's answer against. The gateway's own
+		* facts are set here once, for every operation through the service: the
+		* profile, whether it is the desktop one, and the deadline a timeout
+		* detail names. */
+		outcomeContext(name, operation, alreadyImported, hasClientHalf) {
+			return {
+				profile: this.profile,
+				name,
+				operation,
+				alreadyImported,
+				hasClientHalf,
+				desktop: isDesktopProfile(this.profile),
+				timeoutMs: INSTALL_TIMEOUT_MS
+			};
+		}
+		/**
+		* One install-shaped operation through dsh's `pluginManager` (design
+		* 2026-09-26-plugin-manager-delegation, section 6): `installBundle(spec)`
+		* under the record's own id as its request id, so the output dsh streams
+		* for it reaches this record, in the profile's queue with the download
+		* phase the CLI path has. At the shop's deadline dsh is asked to cancel it;
+		* a service that offers no `cancelInstall` gets no deadline, and its record
+		* settles when dsh answers. `install` and `updateStart` differ only in the
+		* mechanism line and in how they read the answer.
+		*/
+		startManagerInstall(manager, spec, mechanism, outcome, alsoConfirm) {
+			gateOperand(spec);
+			const cancel = manager.cancelInstall?.bind(manager);
+			return startManagerOperation({
+				profile: this.profile,
+				requestId: randomUUID(),
+				mechanism,
+				logs: this.managerLogs,
+				run: (requestId) => manager.installBundle(spec, { requestId }),
+				...cancel !== void 0 ? { cancel } : {},
+				outcome,
+				...alsoConfirm !== void 0 ? { alsoConfirm } : {},
+				prefetcher: this.prefetcher,
+				spec,
+				desktop: isDesktopProfile(this.profile)
+			});
+		}
+		/** Keep a started record where `installStatus`, the restart gate and
+		* eviction find it, then bound the finished ones. */
+		track(running) {
+			this.installs.set(running.installId, running);
+			this.installOrder.push(running.installId);
+			this.evictFinishedInstalls();
+		}
 		/** Bound retained finished records at MAX_FINISHED_INSTALLS, evicting the
 		* oldest finished ones (insertion order, oldest first). Live records —
 		* running AND queued — are never evicted; an id absent from the map reports
@@ -5100,7 +5902,8 @@ let ShopGateway = (() => {
 		* dependencies the shop does not manage (the base bundle, the shop
 		* itself). The same install records/polling serve the client. */
 		async uninstall(args) {
-			if (isDesktopProfile(this.profile)) return {
+			const manager = this.pluginManager();
+			if (isDesktopProfile(this.profile) && manager === null) return {
 				ok: false,
 				detail: DESKTOP_PROFILE_DETAIL
 			};
@@ -5117,6 +5920,23 @@ let ShopGateway = (() => {
 			const installedEntry = named.find((entry) => installedSpecMatches(entry, spec));
 			const priorEntryIds = this.ownedEntryIdsOrNone(args.name);
 			const hadClientHalf = this.packageHasClientHalf(args.name);
+			if (manager !== null) {
+				const running = startManagerOperation({
+					profile: this.profile,
+					requestId: randomUUID(),
+					mechanism: `remove ${args.name}`,
+					logs: this.managerLogs,
+					run: () => manager.removeBundle(args.name),
+					outcome: (raw) => managerOutcome(raw, this.outcomeContext(args.name, "uninstall", false, hadClientHalf)),
+					desktop: isDesktopProfile(this.profile)
+				});
+				this.track(running);
+				this.forgetPins(args.name, installedEntry);
+				return {
+					ok: true,
+					installId: running.installId
+				};
+			}
 			const running = startUninstall({
 				profile: this.profile,
 				name: args.name,
@@ -5133,18 +5953,8 @@ let ShopGateway = (() => {
 					}) };
 				}
 			});
-			const pins = readRepoPins(this.pinFs, this.pinsPath());
-			const stalePins = [args.name, ...installedEntry === void 0 ? [] : [identityKey(installedEntry)]];
-			let forgot = false;
-			for (const key of stalePins) {
-				if (pins[key] === void 0) continue;
-				delete pins[key];
-				forgot = true;
-			}
-			if (forgot) writeRepoPins(this.pinFs, this.pinsPath(), pins);
-			this.installs.set(running.installId, running);
-			this.installOrder.push(running.installId);
-			this.evictFinishedInstalls();
+			this.forgetPins(args.name, installedEntry);
+			this.track(running);
 			return {
 				ok: true,
 				installId: running.installId
@@ -5156,6 +5966,10 @@ let ShopGateway = (() => {
 		* response is out. The browser monitors the origin and refreshes when the
 		* new server answers. Refusals are issued before anything is torn down. */
 		async restart() {
+			if (this.committedRestart !== null) return {
+				ok: true,
+				logFile: this.committedRestart.logFile
+			};
 			if (this.hasRunningCommand()) return {
 				ok: false,
 				detail: "dsh-plugin-shop: an install is still running in this profile; a restart now would boot the new dsh against a half-written profile. Wait for it to finish and try again."
@@ -5189,6 +6003,7 @@ let ShopGateway = (() => {
 					detail: `dsh-plugin-shop: restart could not be started: ${error.message}`
 				};
 			}
+			this.committedRestart = { logFile };
 			setTimeout(() => this.exit(0), this.restartExitDelayMs);
 			return {
 				ok: true,
@@ -5237,7 +6052,8 @@ let ShopGateway = (() => {
 		* version is re-validated as plain semver at the boundary — the spec
 		* `dsh-plugin-shop@<version>` is built here, never from the wire. */
 		async updateStart(args) {
-			if (isDesktopProfile(this.profile)) return {
+			const manager = this.pluginManager();
+			if (isDesktopProfile(this.profile) && manager === null) return {
 				ok: false,
 				detail: DESKTOP_PROFILE_DETAIL
 			};
@@ -5245,16 +6061,24 @@ let ShopGateway = (() => {
 				ok: false,
 				detail: `dsh-plugin-shop: ${args.version} is not a valid version`
 			};
+			const spec = `dsh-plugin-shop@${args.version}`;
+			if (manager !== null) {
+				const running = this.startManagerInstall(manager, spec, `update ${spec}`, (raw) => managerOutcome(raw, this.outcomeContext("dsh-plugin-shop", "update", true, true)));
+				this.track(running);
+				return {
+					ok: true,
+					installId: running.installId,
+					state: running.status().state
+				};
+			}
 			const running = startInstall({
 				profile: this.profile,
-				spec: `dsh-plugin-shop@${args.version}`,
+				spec,
 				dshBin: this.dshBin,
 				expectedName: "dsh-plugin-shop",
 				prefetcher: this.prefetcher
 			});
-			this.installs.set(running.installId, running);
-			this.installOrder.push(running.installId);
-			this.evictFinishedInstalls();
+			this.track(running);
 			return {
 				ok: true,
 				installId: running.installId,