better-dsh 0.3.0 → 0.3.1-a

package/lib/hmr.d.ts

@@ -1,32 +0,0 @@
-import Hmr, { HmrConfig } from "@deepseek-ai/dsh-hmr";
-import { Context } from "@deepseek-ai/cordis";
-
-//#region src/hmr.d.ts
-
-/**
- * Native runExclusive keeps a boolean in ALS. HTTP servers created while
- * replacing webServer inherit that boolean after the transaction finishes,
- * so subsequent native Plugin Manager requests are refused as nested.
- *
- * The public runExclusive/watchConfig APIs expose no selective context reset.
- * AsyncLocalStorage.snapshot() also resets AgentRegistry initiator attribution
- * and its teardown lineage, so it cannot safely repair this host transaction.
- * This compatibility bridge reads the native TS-private `executing` storage
- * after checking its runtime shape. It never replaces that storage or changes
- * upstream files: only exit() clears its inherited value while the unchanged
- * native method establishes the next transaction. Native queue, closing,
- * exact watchers, module reload and disposal retain their original semantics.
- *
- * The mutable token rejects nesting only while its operation is still active;
- * resources created by that operation can initiate later transactions.
- * A native implementation change fails initialization explicitly instead of
- * silently dropping queue or lifecycle guarantees.
- */
-declare class BetterHmr extends Hmr {
-  private readonly nativeTransactions;
-  private readonly liveTransactions;
-  constructor(ctx: Context, config: HmrConfig);
-  runExclusive<T>(operation: () => Promise<T>): Promise<T>;
-}
-//#endregion
-export { BetterHmr as default };

package/lib/hmr.js

@@ -1,49 +0,0 @@
-import { AsyncLocalStorage } from "node:async_hooks";
-import Hmr from "@deepseek-ai/dsh-hmr";
-
-//#region src/hmr.ts
-/**
-* Native runExclusive keeps a boolean in ALS. HTTP servers created while
-* replacing webServer inherit that boolean after the transaction finishes,
-* so subsequent native Plugin Manager requests are refused as nested.
-*
-* The public runExclusive/watchConfig APIs expose no selective context reset.
-* AsyncLocalStorage.snapshot() also resets AgentRegistry initiator attribution
-* and its teardown lineage, so it cannot safely repair this host transaction.
-* This compatibility bridge reads the native TS-private `executing` storage
-* after checking its runtime shape. It never replaces that storage or changes
-* upstream files: only exit() clears its inherited value while the unchanged
-* native method establishes the next transaction. Native queue, closing,
-* exact watchers, module reload and disposal retain their original semantics.
-*
-* The mutable token rejects nesting only while its operation is still active;
-* resources created by that operation can initiate later transactions.
-* A native implementation change fails initialization explicitly instead of
-* silently dropping queue or lifecycle guarantees.
-*/
-var BetterHmr = class extends Hmr {
-	nativeTransactions;
-	liveTransactions = new AsyncLocalStorage();
-	constructor(ctx, config) {
-		super(ctx, config);
-		const storage = this.executing;
-		if (!(storage instanceof AsyncLocalStorage) || typeof storage.getStore !== "function" || typeof storage.exit !== "function" || typeof storage.run !== "function") throw new Error("Better Dash HMR cannot reset this native HMR transaction context: expected executing AsyncLocalStorage");
-		this.nativeTransactions = storage;
-	}
-	runExclusive(operation) {
-		if (this.liveTransactions.getStore()?.active) return Promise.reject(/* @__PURE__ */ new Error("HMR transactions cannot be nested"));
-		return this.nativeTransactions.exit(() => super.runExclusive(() => {
-			const token = { active: true };
-			return this.liveTransactions.run(token, async () => {
-				try {
-					return await operation();
-				} finally {
-					token.active = false;
-				}
-			});
-		}));
-	}
-};
-
-//#endregion
-export { BetterHmr as default };

package/lib/kernel-bridge.py

@@ -1,172 +0,0 @@
-#!/usr/bin/env python3
-"""stdio <-> ZeroMQ bridge for the DASHR REPL.
-
-The host (Node/TS) owns the kernel lifecycle but must not link a native ZMQ
-binding: `zeromq` was a hard npm dependency whose install script compiles C++
-inside the consumer's install transaction (and whose top-level import killed
-the whole plugin when the binding was missing). This process is the only ZMQ
-speaker on the host side; it speaks JSON lines on stdio to Node.
-
-    Node  ──stdio JSON lines──►  kernel-bridge.py  ──pyzmq/jupyter_client──►  ipykernel
-
-Requirements come from the kernel's own environment: `jupyter_client` and
-`pyzmq` are transitive dependencies of the `ipykernel` we provision (see
-`kernel-env.ts`), so nothing extra is fetched from any package manager.
-
-Protocol
---------
-stdin (one JSON object per line)::
-
-    {"op":"send","channel":"shell"|"control","header":{...},"content":{...}}
-    {"op":"interrupt"}
-    {"op":"shutdown"}
-
-stdout (one JSON object per line)::
-
-    {"ev":"ready"}
-    {"ev":"msg","channel":"shell"|"iopub"|"control"|"stdin","msg":{...}}
-    {"ev":"fatal","message":"..."}
-
-The caller-supplied `header` is passed to `Session.msg` verbatim, so the
-message id the host generated is the id on the wire — parent-matching and
-request/response correlation stay exactly as they were on the raw-socket path.
-"""
-from __future__ import annotations
-
-import json
-import queue
-import sys
-import threading
-
-CHANNELS = ("iopub", "shell", "control", "stdin")
-POLL_SECONDS = 0.2
-
-# Protocol output goes to the real stdout; anything a library prints must never
-# corrupt the byte stream the host parses, so sys.stdout is repointed to stderr.
-_PROTOCOL_OUT = sys.stdout
-sys.stdout = sys.stderr
-
-_write_lock = threading.Lock()
-
-
-def emit(payload: dict) -> None:
-    """Write one protocol line, atomically across the pump threads."""
-    # `default=str`: jupyter_client hands back parsed values (a header `date`
-    # arrives as `datetime`, for instance) that are not JSON-native; the host
-    # only reads msg_id/msg_type/content, so stringifying the rest is lossless
-    # for its purposes and keeps one pump thread from dying on a header field.
-    line = json.dumps(payload, ensure_ascii=False, default=str)
-    with _write_lock:
-        _PROTOCOL_OUT.write(line + "\n")
-        _PROTOCOL_OUT.flush()
-
-
-def _clean(value: object) -> object:
-    """Strip binary buffers: this protocol carries JSON only."""
-    if isinstance(value, dict):
-        return {key: _clean(item) for key, item in value.items() if key != "buffers"}
-    if isinstance(value, (list, tuple)):
-        return [_clean(item) for item in value]
-    if isinstance(value, bytes):
-        return value.decode("utf-8", "replace")
-    return value
-
-
-def pump(client, name: str, stop: threading.Event) -> None:
-    """Relay one client channel onto stdout until `stop` is set."""
-    channel = getattr(client, f"{name}_channel")
-    while not stop.is_set():
-        try:
-            message = channel.get_msg(timeout=POLL_SECONDS)
-        except queue.Empty:
-            continue
-        except Exception as error:  # channel torn down, or the socket died
-            if not stop.is_set():
-                emit({"ev": "fatal", "channel": name, "message": f"{type(error).__name__}: {error}"})
-        try:
-            emit({
-                "ev": "msg",
-                "channel": name,
-                "msg": {
-                    "header": message.get("header") or {},
-                    "parent_header": message.get("parent_header") or {},
-                    "content": _clean(message.get("content") or {}),
-                    "metadata": _clean(message.get("metadata") or {}),
-                },
-            })
-        except Exception as error:  # never let one message kill a channel pump
-            sys.stderr.write(f"kernel-bridge: cannot relay {name} message: {type(error).__name__}: {error}\n")
-            sys.stderr.flush()
-
-
-def main() -> int:
-    if len(sys.argv) != 2:
-        emit({"ev": "fatal", "message": "usage: kernel-bridge.py <connection-file>"})
-        return 2
-
-    try:
-        from jupyter_client import BlockingKernelClient
-    except Exception as error:  # the kernel environment is incomplete
-        emit({"ev": "fatal", "message": f"jupyter_client unavailable: {type(error).__name__}: {error}"})
-        return 3
-
-    try:
-        client = BlockingKernelClient(connection_file=sys.argv[1])
-        client.load_connection_file()
-        client.start_channels()
-    except Exception as error:
-        emit({"ev": "fatal", "message": f"cannot connect to the kernel: {type(error).__name__}: {error}"})
-        return 4
-
-    stop = threading.Event()
-    for name in CHANNELS:
-        threading.Thread(target=pump, args=(client, name, stop), name=f"pump-{name}", daemon=True).start()
-
-    emit({"ev": "ready"})
-
-    try:
-        for line in sys.stdin:
-            line = line.strip()
-            if not line:
-                continue
-            try:
-                request = json.loads(line)
-            except Exception:
-                continue
-            op = request.get("op")
-            if op == "send":
-                channel_name = request.get("channel")
-                if channel_name not in ("shell", "control"):
-                    emit({"ev": "fatal", "message": f"unknown send channel {channel_name!r}"})
-                    continue
-                channel = getattr(client, f"{channel_name}_channel")
-                try:
-                    header = request.get("header") or None
-                    message = client.session.msg(
-                        header["msg_type"] if header else "comm_msg",
-                        content=request.get("content") or {},
-                        header=header,
-                    )
-                    channel.send(message)
-                except Exception as error:
-                    emit({"ev": "fatal", "channel": channel_name, "message": f"send failed: {type(error).__name__}: {error}"})
-            elif op == "interrupt":
-                try:
-                    client.interrupt_kernel()
-                except Exception as error:
-                    emit({"ev": "fatal", "message": f"interrupt failed: {type(error).__name__}: {error}"})
-            elif op == "shutdown":
-                break
-    except (KeyboardInterrupt, BrokenPipeError):
-        pass
-    finally:
-        stop.set()
-        try:
-            client.stop_channels()
-        except Exception:
-            pass
-    return 0
-
-
-if __name__ == "__main__":
-    sys.exit(main())

package/lib/kernel-env-D8UOWeji.js

@@ -1,195 +0,0 @@
-import { execFile } from "node:child_process";
-import { dirname, join, resolve } from "node:path";
-import { fileURLToPath } from "node:url";
-import { existsSync, mkdirSync } from "node:fs";
-import { promisify } from "node:util";
-
-//#region src/kernel-env.ts
-const execFileAsync = promisify(execFile);
-/** The installed package root (where `lib/` and `src/` live): the default home of the managed venv. */
-const PACKAGE_ROOT = resolve(dirname(fileURLToPath(import.meta.url)), "..");
-/** The config value meaning "no explicit interpreter — auto-manage a venv". */
-const AUTO_PYTHON_SENTINEL = "python3";
-/** Preferred CPython version for a managed venv. */
-const DEFAULT_KERNEL_PYTHON_VERSION = "3.11";
-/** Pinned, tested `ipykernel` version (2026-09-02 tested value; upgrade = explicit change + regression). */
-const IPYKERNEL_VERSION = "7.3.0";
-/** Pinned, tested `dill` version. */
-const DILL_VERSION = "0.4.1";
-/** A probe that never imports user modules and reports exactly what we need. */
-const PROBE_CODE = [
-	"import json, sys",
-	"r = {\"version\": sys.version.split()[0], \"ipykernel\": False, \"dill\": False}",
-	"try:",
-	"    import ipykernel  # noqa: F401",
-	"    r[\"ipykernel\"] = True",
-	"except Exception:",
-	"    pass",
-	"try:",
-	"    import dill  # noqa: F401",
-	"    r[\"dill\"] = True",
-	"except Exception:",
-	"    pass",
-	"print(json.dumps(r))"
-].join("\n");
-async function probePython(python) {
-	try {
-		const { stdout } = await execFileAsync(python, ["-c", PROBE_CODE], { timeout: 15e3 });
-		const parsed = JSON.parse(stdout.trim());
-		return {
-			version: typeof parsed.version === "string" && parsed.version.length > 0 ? parsed.version : "unknown",
-			ipykernel: parsed.ipykernel === true,
-			dill: parsed.dill === true
-		};
-	} catch {
-		return null;
-	}
-}
-/** The venv interpreter path for this platform. */
-function venvPythonPath(venvDir) {
-	return process.platform === "win32" ? join(venvDir, "Scripts", "python.exe") : join(venvDir, "bin", "python");
-}
-async function commandExists(cmd) {
-	try {
-		await execFileAsync(cmd, ["--version"], { timeout: 1e4 });
-		return true;
-	} catch {
-		return false;
-	}
-}
-/** Tool-cache env for uv: caches live NEXT TO the venv (plugin territory), so a read-only home can never block provisioning. */
-function uvToolEnv(venvDir) {
-	const cacheDir = join(dirname(venvDir), ".uv-cache");
-	return {
-		...process.env,
-		UV_CACHE_DIR: cacheDir,
-		UV_PYTHON_INSTALL_DIR: join(cacheDir, "python"),
-		UV_LINK_MODE: "copy"
-	};
-}
-/** uv venv arguments (pure; unit-tested). */
-function uvVenvArgs(venvDir, pythonVersion) {
-	return [
-		"venv",
-		venvDir,
-		"--python",
-		pythonVersion
-	];
-}
-/** python3 -m venv fallback arguments (pure; cache-free by construction). */
-function venvFallbackArgs(venvDir) {
-	return [
-		"-m",
-		"venv",
-		venvDir
-	];
-}
-/** uv pip install arguments with pinned versions (pure; unit-tested). */
-function uvInstallArgs(python) {
-	return [
-		"pip",
-		"install",
-		"--python",
-		python,
-		"--quiet",
-		`ipykernel==${IPYKERNEL_VERSION}`,
-		`dill==${DILL_VERSION}`
-	];
-}
-/** pip install arguments with pinned versions for the venv interpreter (pure). */
-function pipInstallArgs() {
-	return [
-		"-m",
-		"pip",
-		"install",
-		"--quiet",
-		"--disable-pip-version-check",
-		`ipykernel==${IPYKERNEL_VERSION}`,
-		`dill==${DILL_VERSION}`
-	];
-}
-/** Create the venv (when absent) and return its interpreter path. */
-async function createVenv(venvDir, pythonVersion) {
-	const python = venvPythonPath(venvDir);
-	if (existsSync(python)) return python;
-	if (await commandExists("uv")) {
-		mkdirSync(join(dirname(venvDir), ".uv-cache"), { recursive: true });
-		await execFileAsync("uv", uvVenvArgs(venvDir, pythonVersion), {
-			timeout: 12e4,
-			env: uvToolEnv(venvDir)
-		});
-	} else await execFileAsync("python3", venvFallbackArgs(venvDir), { timeout: 12e4 });
-	return python;
-}
-/** Install pinned `ipykernel` + `dill` into the venv interpreter. */
-async function installDeps(python, venvDir) {
-	if (await commandExists("uv")) await execFileAsync("uv", uvInstallArgs(python), {
-		timeout: 18e4,
-		env: uvToolEnv(venvDir)
-	});
-	else await execFileAsync(python, pipInstallArgs(), { timeout: 18e4 });
-}
-/** Provision (or repair) the managed venv so it has `ipykernel` + `dill`. */
-async function ensureVenv(venvDir, pythonVersion, log) {
-	const python = venvPythonPath(venvDir);
-	const existing = existsSync(python) ? await probePython(python) : null;
-	if (existing?.ipykernel === true && existing.dill === true) return python;
-	await createVenv(venvDir, pythonVersion);
-	if (!existsSync(python)) throw new Error(`dashr-repl: managed kernel venv was not created at ${venvDir} (no interpreter at ${python})`);
-	log?.("info", `dashr-repl: provisioning kernel venv at ${venvDir} (ipykernel + dill)`);
-	await installDeps(python, venvDir);
-	return python;
-}
-/**
-* Resolve the kernel interpreter, provisioning a managed venv when no
-* explicit interpreter is configured. Throws when the resolved interpreter
-* cannot run `ipykernel`; a missing `dill` only disables snapshots (warned).
-*/
-async function resolveKernelEnv(options = {}) {
-	const log = options.log;
-	const explicit = options.python !== void 0 && options.python !== "" && options.python !== AUTO_PYTHON_SENTINEL ? options.python : void 0;
-	if (explicit !== void 0) {
-		const probe$1 = await probePython(explicit);
-		if (probe$1 === null) throw new Error(`dashr-repl: kernel python ${JSON.stringify(explicit)} could not be executed — check the path`);
-		if (!probe$1.ipykernel) throw new Error(`dashr-repl: kernel python ${JSON.stringify(explicit)} has no ipykernel — install it (pip install ipykernel) or set python to a managed venv`);
-		if (!probe$1.dill) log?.("warn", `dashr-repl: kernel python ${JSON.stringify(explicit)} has no dill — namespace snapshots are DISABLED (install it: pip install dill)`);
-		return {
-			python: explicit,
-			managed: false,
-			venvDir: void 0,
-			dill: probe$1.dill,
-			ipykernel: true,
-			version: probe$1.version
-		};
-	}
-	const venvDir = options.venvDir ?? join(PACKAGE_ROOT, ".venv-kernel");
-	const python = venvPythonPath(venvDir);
-	if (options.autoInstall === false) {
-		const probe$1 = await probePython(python);
-		if (probe$1 === null || !probe$1.ipykernel) throw new Error(`dashr-repl: managed kernel venv is missing or incomplete at ${venvDir} — run 'npm run kernel:venv' in the dashr package, or set kernelAutoInstall: true (or python to a prepared interpreter)`);
-		if (!probe$1.dill) log?.("warn", `dashr-repl: kernel venv at ${venvDir} has no dill — namespace snapshots are DISABLED (run 'npm run kernel:venv' to reinstall)`);
-		return {
-			python,
-			managed: true,
-			venvDir,
-			dill: probe$1.dill,
-			ipykernel: true,
-			version: probe$1.version
-		};
-	}
-	const resolved = await ensureVenv(venvDir, options.pythonVersion ?? DEFAULT_KERNEL_PYTHON_VERSION, log);
-	const probe = await probePython(resolved);
-	if (probe === null || !probe.ipykernel) throw new Error(`dashr-repl: managed kernel venv at ${venvDir} still has no ipykernel after provisioning — check uv/python3-venv availability and retry`);
-	if (!probe.dill) log?.("warn", `dashr-repl: managed kernel venv at ${venvDir} has no dill after provisioning — namespace snapshots are DISABLED`);
-	return {
-		python: resolved,
-		managed: true,
-		venvDir,
-		dill: probe.dill,
-		ipykernel: true,
-		version: probe.version
-	};
-}
-
-//#endregion
-export { PACKAGE_ROOT as a, uvInstallArgs as c, venvFallbackArgs as d, IPYKERNEL_VERSION as i, uvToolEnv as l, DEFAULT_KERNEL_PYTHON_VERSION as n, pipInstallArgs as o, DILL_VERSION as r, resolveKernelEnv as s, AUTO_PYTHON_SENTINEL as t, uvVenvArgs as u };

package/lib/webserver.d.ts

@@ -1,10 +0,0 @@
-import { Service } from "@deepseek-ai/cordis";
-import { WebServer } from "@deepseek-ai/dsh-host-webserver";
-
-//#region src/webserver.d.ts
-declare class BetterWebServer extends WebServer {
-  static inject: string[];
-  [Service.init](): Promise<void>;
-}
-//#endregion
-export { BetterWebServer as default };

package/lib/webserver.js

@@ -1,19 +0,0 @@
-import { Service } from "@deepseek-ai/cordis";
-import { WebServer } from "@deepseek-ai/dsh-host-webserver";
-
-//#region src/webserver.ts
-var BetterWebServer = class extends WebServer {
-	static inject = ["loader"];
-	async [Service.init]() {
-		const welcome = [...this.ctx.loader.entries()].find((entry) => entry.options.id === "dashr-welcome-notice");
-		if (welcome !== void 0 && !welcome.disabled) {
-			if (welcome.fiber === void 0) await welcome.init();
-			await welcome.fiber?.await();
-		}
-		this.ctx.fiber.assertActive();
-		await super[Service.init]();
-	}
-};
-
-//#endregion
-export { BetterWebServer as default };

package/scripts/kernel-provision.mjs

@@ -1,35 +0,0 @@
-#!/usr/bin/env node
-/**
- * Best-effort kernel provisioning entry — the single code path behind BOTH
- * `postinstall` and `npm run kernel:venv`.
- *
- * Fail-open by design (2026-09-03 ruling): any failure logs a remedy hint and
- * exits 0. The installation must NEVER fail because the kernel could not be
- * provisioned here — the daemon spin-up check (primary path) and first-use
- * lazy provisioning (final fallback) complete the three-trigger ladder.
- */
-import { access } from 'node:fs/promises'
-
-const libUrl = new URL('../lib/kernel-env.js', import.meta.url)
-
-try {
-  await access(libUrl)
-} catch {
-  // Dev checkout before the first build, or a pruned install: nothing to call.
-  console.log('[dashr] kernel-env build output not present yet — skipping install-time pre-provision (the daemon spin-up check will provision on start)')
-  process.exit(0)
-}
-
-const { resolveKernelEnv } = await import(libUrl)
-
-try {
-  const env = await resolveKernelEnv({
-    autoInstall: true,
-    log: (level, message) => console[level === 'warn' ? 'warn' : 'log'](`[dashr] ${message}`),
-  })
-  console.log(`[dashr] kernel ready: python ${env.version} at ${env.python}${env.dill ? '' : ' (dill missing — snapshots disabled)'}`)
-} catch (error) {
-  console.warn(`[dashr] kernel pre-provision failed (non-blocking): ${error instanceof Error ? error.message : String(error)}`)
-  console.warn('[dashr] remedies: run "npm run kernel:venv" in the dashr package; or rely on the daemon spin-up check / first-use auto-install; or set python to a prepared interpreter')
-  process.exit(0)
-}

package/scripts/register-bundle.mjs

@@ -1,80 +0,0 @@
-// Separate-process entry for the SAME native package operations used by dsh plugin.
-// No shell interpolation, package scripts, upstream edits, or companion registry lookup.
-import { createRequire } from 'node:module'
-import { createHash } from 'node:crypto'
-import { readFile, realpath } from 'node:fs/promises'
-import { dirname, join, relative, resolve, isAbsolute, sep } from 'node:path'
-import { pathToFileURL } from 'node:url'
-let input = ''
-for await (const bytes of process.stdin) input += bytes
-const {profile,archive,expected} = JSON.parse(input)
-const require = createRequire(profile.installAnchor)
-const {runProfilePnpm} = await import(pathToFileURL(require.resolve('@deepseek-ai/dsh-plugin-manager/operations')).href)
-const {withFileLock} = await import(pathToFileURL(require.resolve('@deepseek-ai/dsh-atomic-write')).href)
-const abort = new AbortController()
-process.once('SIGTERM', () => abort.abort())
-const json = async path => JSON.parse(await readFile(path, 'utf8'))
-const hash = bytes => createHash('sha256').update(bytes).digest('hex')
-async function contained(root, path) {
-  if (typeof path !== 'string' || isAbsolute(path)) throw new Error('Pack delivery path must be relative')
-  const base = await realpath(root), file = await realpath(resolve(base, path)), rel = relative(base, file)
-  if (rel === '..' || rel.startsWith('..' + sep) || isAbsolute(rel)) throw new Error('Pack delivery path escapes its owner')
-  return file
-}
-const skipped = disposition => ({ exitCode: 0, disposition })
-// Complete each native acquisition/release before observing cancellation;
-// exiting during its async lock-file write can strand incomplete lock metadata.
-async function withCancellableProfileLock(operation) {
-  const path = join(profile.dir, 'package.json'), deadline = Date.now() + 120000
-  for (;;) {
-    abort.signal.throwIfAborted()
-    let acquired = false
-    try {
-      return await withFileLock(path, async () => {
-        acquired = true
-        abort.signal.throwIfAborted()
-        return operation()
-      }, { waitMs: Math.min(250, Math.max(0, deadline - Date.now())) })
-    } catch (error) {
-      abort.signal.throwIfAborted()
-      if (acquired || Date.now() >= deadline
-        || error.message !== `atomic-write: timed out waiting for the writer lock at ${path}.lock`) throw error
-    }
-  }
-}
-const result = await withCancellableProfileLock(async () => {
-  abort.signal.throwIfAborted()
-  const current = await json(join(profile.dir, 'package.json'))
-  if (typeof expected.ownerSpec !== 'string' || current.dependencies?.[expected.owner] !== expected.ownerSpec) return skipped('owner-changed')
-  const ownerDir = join(profile.dir, 'node_modules', expected.owner)
-  let owner, descriptorPath, descriptor
-  try {
-    owner = await json(join(ownerDir, 'package.json'))
-    if (owner.dependencies?.[expected.companion.name] !== expected.companion.version || owner.superd?.delivery === undefined) return skipped('owner-changed')
-    descriptorPath = await contained(ownerDir, owner.superd.delivery)
-    descriptor = await json(descriptorPath)
-  } catch (error) {
-    if (error.code === 'ENOENT') return skipped('owner-changed')
-    throw error
-  }
-  const item = descriptor.companions?.find(item => item.name === expected.companion.name)
-  if (item?.version !== expected.companion.version || item.sha256 !== expected.companion.sha256
-    || hash(await readFile(await contained(dirname(descriptorPath), item.tarball))) !== expected.companion.sha256) return skipped('owner-changed')
-  const prior = current.dependencies?.[item.name]
-  if (prior !== expected.priorSpec) return skipped(prior === undefined && expected.priorSpec !== undefined ? 'companion-removed' : 'companion-changed')
-  if (hash(await readFile(archive)) !== item.sha256) throw new Error('Cached companion SHA256 mismatch')
-  abort.signal.throwIfAborted()
-  // Same public operation and writer lock used by the native Plugin Manager;
-  // intent is checked after acquisition, before a queued install can undo removal.
-  const operation = await runProfilePnpm({profile:profile.name,dir:profile.dir,installAnchor:profile.installAnchor,cwd:profile.dir,home:profile.home}, ['add','file:'+archive,'--ignore-scripts'], {
-    ...profile.packageManager, execution:'service', signal:abort.signal, outputBytes:16384,
-    lookupTimeoutMs:120000, idleTimeoutMs:120000,
-  })
-  if (operation.exitCode === 0) {
-    const installed = await json(join(profile.dir, 'node_modules', item.name, 'package.json'))
-    const after = await json(join(profile.dir, 'package.json'))
-    if (installed.name !== item.name || installed.version !== item.version || after.dependencies?.[item.name] !== 'file:' + archive) throw new Error('Native companion registration did not install the exact local artifact')
-  }
-  return { exitCode: operation.exitCode, logPath: operation.logPath, disposition: 'installed' }
-})
-process.stdout.write(JSON.stringify(result)+'\n')