mason-context 0.13.0 → 0.14.0

package/dist/mason-auto.js

@@ -2398,7 +2398,7 @@ var init_evidence = __esm({
     init_dead_command();
     init_storage();
     exec7 = promisify7(execFile7);
-    engineVersion = true ? "0.13.0" : "development";
+    engineVersion = true ? "0.14.0" : "development";
     hash = (value) => createHash3("sha256").update(JSON.stringify(value)).digest("hex");
     internal = (file) => file === ".mason" || file === ".mason/reports" || file.startsWith(".mason/reports/");
     cacheSchema = z5.object({ version: z5.literal(1), entries: z5.record(z5.object({ key: z5.string(), result: checkResultSchema })), digest: z5.string() });
@@ -2747,7 +2747,8 @@ var init_model = __esm({
     runtimeSchema = z7.object({
       id: z7.string().regex(/^[a-f0-9]{24}$/),
       version: z7.string().regex(/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/),
-      hashes: z7.record(z7.string().regex(/^[a-f0-9]{64}$/))
+      hashes: z7.record(z7.string().regex(/^[a-f0-9]{64}$/)),
+      bundle: z7.object({ target: z7.string(), manifestHash: z7.string().regex(/^[a-f0-9]{64}$/) }).optional()
     });
     setupHostSchema = z7.object({
       runtime: runtimeSchema,
@@ -3905,18 +3906,55 @@ var init_files2 = __esm({
 });
 
 // src/setup/launcher.ts
-var BOOTSTRAP, mcpCommand, hookCommand, LAUNCHER;
+var BOOTSTRAP, POWERSHELL_BOOTSTRAP, mcpCommand, hookCommand, SHELL_LAUNCHER, POWERSHELL_LAUNCHER, LAUNCHER;
 var init_launcher = __esm({
   "src/setup/launcher.ts"() {
     "use strict";
     BOOTSTRAP = "require(require('node:path').join(require('node:child_process').execFileSync('git',['rev-parse','--show-toplevel'],{encoding:'utf8'}).trim(),'.mason','run.cjs'))";
-    mcpCommand = (host) => ({ command: "node", args: ["-e", BOOTSTRAP, "--", host, "mcp"] });
-    hookCommand = (host) => `node -e "${BOOTSTRAP}" -- ${host} auto`;
+    POWERSHELL_BOOTSTRAP = "& (Join-Path (git rev-parse --show-toplevel) '.mason/run.ps1')";
+    mcpCommand = (host, runtime) => !runtime?.bundle ? { command: "node", args: ["-e", BOOTSTRAP, "--", host, "mcp"] } : process.platform === "win32" ? { command: "powershell.exe", args: ["-NoProfile", "-NonInteractive", "-ExecutionPolicy", "Bypass", "-Command", POWERSHELL_BOOTSTRAP, host, "mcp"] } : { command: "sh", args: ["-c", 'exec sh "$(git rev-parse --show-toplevel)/.mason/run.sh" "$@"', "mason", host, "mcp"] };
+    hookCommand = (host, runtime) => !runtime?.bundle ? `node -e "${BOOTSTRAP}" -- ${host} auto` : process.platform === "win32" ? `powershell.exe -NoProfile -NonInteractive -ExecutionPolicy Bypass -Command "${POWERSHELL_BOOTSTRAP} ${host} auto"` : `sh "$(git rev-parse --show-toplevel)/.mason/run.sh" ${host} auto`;
+    SHELL_LAUNCHER = `#!/bin/sh
+set -eu
+advisory=0
+if [ "\${2-}" = auto ] && [ "\${3-}" = hook ]; then advisory=1; fi
+fail() {
+  if [ "$advisory" -eq 1 ]; then printf '%s\\n' '{"systemMessage":"Mason runtime unavailable. Rerun mason setup for this checkout; verification was not established."}'; exit 0; fi
+  echo 'Mason runtime unavailable. Rerun mason setup for this checkout.' >&2; exit 2
+}
+root=$(CDPATH= cd -- "$(dirname -- "$0")/.." && pwd) || fail
+case "\${1-}" in codex|claude) ;; *) fail ;; esac
+pointer="$root/.mason/runtime/$1.txt"
+[ -f "$pointer" ] || fail
+runtime=$(cat "$pointer") || fail
+case "$runtime" in ''|*[!0-9a-f]*) fail ;; esac
+[ "\${#runtime}" -eq 24 ] || fail
+[ -x "$root/.mason/runtime/$runtime/node" ] || fail
+if [ "$advisory" -eq 1 ]; then
+  "$root/.mason/runtime/$runtime/node" "$root/.mason/run.cjs" "$@" || fail
+else
+  exec "$root/.mason/runtime/$runtime/node" "$root/.mason/run.cjs" "$@"
+fi
+`;
+    POWERSHELL_LAUNCHER = `# Managed by mason setup; no system Node installation is used.
+$ErrorActionPreference = 'Stop'
+$advisory = $args.Count -ge 3 -and $args[1] -eq 'auto' -and $args[2] -eq 'hook'
+try {
+  if ($args.Count -lt 2 -or $args[0] -notin @('codex','claude')) { throw 'Invalid Mason host.' }
+  $runtime = (Get-Content -LiteralPath (Join-Path $PSScriptRoot ('runtime/' + $args[0] + '.txt')) -Raw).Trim()
+  if ($runtime -cnotmatch '^[a-f0-9]{24}$') { throw 'Invalid Mason runtime pointer.' }
+  & (Join-Path $PSScriptRoot ('runtime/' + $runtime + '/node.exe')) (Join-Path $PSScriptRoot 'run.cjs') @args
+  if ($LASTEXITCODE -ne 0) { throw 'Mason runtime failed.' }
+} catch {
+  if ($advisory) { Write-Output '{"systemMessage":"Mason runtime unavailable. Rerun mason setup for this checkout; verification was not established."}'; exit 0 }
+  [Console]::Error.WriteLine($_.Exception.Message); exit 2
+}
+`;
     LAUNCHER = `// Managed by mason-auto setup. Rerun setup to install this checkout's pinned runtime.
 const fs = require('node:fs');
 const path = require('node:path');
 const {pathToFileURL} = require('node:url');
-const launchArgs = process.argv.slice(1);
+const launchArgs = process.argv.slice(process.argv[1] && path.resolve(process.argv[1]) === __filename ? 2 : 1);
 (async () => {
   const root = path.dirname(__dirname);
   const args = launchArgs;
@@ -3925,7 +3963,13 @@ const launchArgs = process.argv.slice(1);
   const setup = JSON.parse(fs.readFileSync(path.join(__dirname, 'setup.json'), 'utf8'));
   const entry = setup.hosts?.[host];
   if (setup.version !== 1 || !entry || !/^[a-f0-9]{24}$/.test(entry.runtime?.id)) throw new Error('Mason is not configured for this host. Rerun mason-auto setup.');
-  const binary = path.join(__dirname, 'runtime', entry.runtime.id, 'node_modules', 'mason-context', 'dist', 'mason-' + command + '.js');
+  const base = path.join(__dirname, 'runtime', entry.runtime.id);
+  if (entry.runtime.bundle) {
+    const node = process.platform === 'win32' ? 'node.exe' : 'node';
+    if (fs.realpathSync(process.execPath) !== fs.realpathSync(path.join(base, node))) throw new Error('Mason runtime pointer differs from the configured version. Rerun setup.');
+  }
+  const binary = entry.runtime.bundle ? path.join(base, 'app', 'dist', 'mason-' + command + '.js')
+    : path.join(base, 'node_modules', 'mason-context', 'dist', 'mason-' + command + '.js');
   if (!fs.existsSync(binary)) throw new Error('The pinned Mason runtime is missing in this checkout. Rerun mason-auto setup --host ' + host + '.');
   process.env.MASON_SETUP_ROOT = root;
   process.env.MASON_SETUP_HOST = host;
@@ -3973,22 +4017,22 @@ async function instructionEdits(root, host) {
   }
   return edits;
 }
-function managedMcp(previous, host) {
+function managedMcp(previous, host, runtime) {
   const options = previous === void 0 ? {} : object.parse(previous);
   for (const key of ["command", "args", "url", "type", "headers", "http_headers", "env_http_headers", "bearer_token_env_var"]) delete options[key];
-  return { ...options, ...mcpCommand(host) };
+  return { ...options, ...mcpCommand(host, runtime) };
 }
-async function mcpEdit(root, host) {
+async function mcpEdit(root, host, runtime) {
   const file = mcpPath(host), before = await readText(root, file);
   if (host === "claude") {
     const config2 = before === null ? {} : object.parse(JSON.parse(before));
     const servers2 = object.parse(config2.mcpServers ?? {});
-    return { path: file, before, after: JSON.stringify({ ...config2, mcpServers: { ...servers2, mason: managedMcp(servers2.mason, host) } }, null, 2) + "\n" };
+    return { path: file, before, after: JSON.stringify({ ...config2, mcpServers: { ...servers2, mason: managedMcp(servers2.mason, host, runtime) } }, null, 2) + "\n" };
   }
   const config = parse(before ?? "");
   const managed = (before ?? "").includes(TOML_START);
   const servers = config.mcp_servers;
-  const desired = managedMcp(servers?.mason, host);
+  const desired = managedMcp(servers?.mason, host, runtime);
   let base = before ?? "";
   if (servers?.mason && !managed) {
     const headers = [...base.matchAll(/^\s*\[\[?.+?\]\]?[^\S\r\n]*(?:#.*)?$/gm)];
@@ -4002,10 +4046,10 @@ async function mcpEdit(root, host) {
   if (!isDeepStrictEqual(parsed, expected)) throw new Error("Could not safely configure the Mason MCP entry without changing other settings.");
   return { path: file, before, after };
 }
-async function hookEdits(root, host) {
+async function hookEdits(root, host, runtime) {
   const file = configPath(host), before = await readText(root, file);
   const { planAutomationInstall: planAutomationInstall2 } = await Promise.resolve().then(() => (init_install(), install_exports));
-  const plan = await planAutomationInstall2(root, host, hookCommand(host));
+  const plan = await planAutomationInstall2(root, host, hookCommand(host, runtime));
   return [
     { path: file, before, after: JSON.stringify(plan.config, null, 2) + "\n" },
     { path: ".mason/automation.json", before: await readText(root, ".mason/automation.json"), after: JSON.stringify(plan.record, null, 2) + "\n" }
@@ -4021,18 +4065,20 @@ async function ancillaryEdits(root) {
     if (error.code !== 1) throw error;
   }
   const retainParentRule = parentIgnored || !!ignore?.replace(/\r\n/g, "\n").includes("# mason:ignore:start\n!/.mason/\n/.mason/*");
-  const rules = [...retainParentRule ? ["!/.mason/", "/.mason/*"] : [], "!/.mason/decisions/", "!/.mason/decisions/**", "!/.mason/setup.json", "!/.mason/automation.json", "!/.mason/project.json", "!/.mason/run.cjs", "/.mason/reports/", "/.mason/runtime/"].join("\n");
+  const rules = [...retainParentRule ? ["!/.mason/", "/.mason/*"] : [], "!/.mason/decisions/", "!/.mason/decisions/**", "!/.mason/setup.json", "!/.mason/automation.json", "!/.mason/project.json", "!/.mason/run.cjs", "!/.mason/run.sh", "!/.mason/run.ps1", "/.mason/reports/", "/.mason/runtime/"].join("\n");
   return [
     { path: ".gitignore", before: ignore, after: managedBlock(ignore ?? "", "# mason:ignore:start", "# mason:ignore:end", rules) },
-    { path: ".mason/run.cjs", before: await readText(root, ".mason/run.cjs"), after: LAUNCHER }
+    { path: ".mason/run.cjs", before: await readText(root, ".mason/run.cjs"), after: LAUNCHER },
+    { path: ".mason/run.sh", before: await readText(root, ".mason/run.sh"), after: SHELL_LAUNCHER },
+    { path: ".mason/run.ps1", before: await readText(root, ".mason/run.ps1"), after: POWERSHELL_LAUNCHER }
   ];
 }
-async function inspectHostConfig(root, host, plannedMcp) {
+async function inspectHostConfig(root, host, plannedMcp, runtime) {
   const text2 = plannedMcp ?? await readText(root, mcpPath(host));
   const config = host === "codex" ? parse(text2 ?? "") : object.parse(JSON.parse(text2 ?? "{}"));
   const servers = host === "codex" ? config.mcp_servers : config.mcpServers;
   const hooks = automationConfigSchema.parse(JSON.parse(await readText(root, configPath(host)) ?? "{}"));
-  const expected = hookConfig(host, hookCommand(host));
+  const expected = hookConfig(host, hookCommand(host, runtime));
   const mcp = servers?.mason === void 0 ? null : object.parse(servers.mason);
   return {
     mcp,
@@ -4063,40 +4109,109 @@ var init_config = __esm({
   }
 });
 
-// src/setup/runtime.ts
+// src/distribution/bundle.ts
 import fs16 from "fs/promises";
 import path21 from "path";
+import { createHash as createHash4 } from "crypto";
+import { z as z16 } from "zod";
+async function readBundle(root) {
+  const bytes = await fs16.readFile(await storePath(root, "bundle.json"));
+  const manifest = bundleSchema.parse(JSON.parse(bytes.toString("utf8")));
+  const windows = manifest.target.startsWith("win32-");
+  for (const file of Object.keys(manifest.files)) {
+    if (file.includes("\\") || file.split("/").some((p) => !p || p === "." || p === "..") || path21.isAbsolute(file)) {
+      throw new Error("Unsafe path in Mason bundle: " + file);
+    }
+  }
+  for (const required of [windows ? "node.exe" : "node", "app/package.json", "app/dist/mason.js", "app/dist/mason-auto.js", "app/dist/mason-mcp.js"]) {
+    if (!manifest.files[required]) throw new Error("Incomplete Mason bundle: " + required);
+  }
+  return { manifest, manifestHash: sha256(bytes) };
+}
+async function verifyBundle(root, expectedHash) {
+  const bundle = await readBundle(root);
+  if (expectedHash && bundle.manifestHash !== expectedHash) throw new Error("Mason bundle manifest changed.");
+  if (bundle.manifest.target !== `${process.platform}-${process.arch}`) throw new Error("Mason bundle is for another platform. Install this platform's bundle and rerun setup.");
+  const files = Object.keys(bundle.manifest.files);
+  for (let i = 0; i < files.length; i += 8) await Promise.all(files.slice(i, i + 8).map(async (file) => {
+    if (sha256(await fs16.readFile(await storePath(root, file))) !== bundle.manifest.files[file]) throw new Error("Mason bundle checksum mismatch: " + file);
+  }));
+  return bundle;
+}
+var targets, digest2, bundleSchema, sha256;
+var init_bundle = __esm({
+  "src/distribution/bundle.ts"() {
+    "use strict";
+    init_storage();
+    targets = ["darwin-arm64", "darwin-x64", "linux-arm64", "linux-x64", "win32-arm64", "win32-x64"];
+    digest2 = z16.string().regex(/^[a-f0-9]{64}$/);
+    bundleSchema = z16.object({
+      format: z16.literal(1),
+      version: z16.string().regex(/^\d+\.\d+\.\d+(?:-[A-Za-z0-9.-]+)?$/),
+      target: z16.enum(targets),
+      nodeVersion: z16.string(),
+      files: z16.record(digest2)
+    }).strict();
+    sha256 = (bytes) => createHash4("sha256").update(bytes).digest("hex");
+  }
+});
+
+// src/setup/runtime.ts
+import fs17 from "fs/promises";
+import path22 from "path";
 import { fileURLToPath } from "url";
-import { randomUUID as randomUUID6, createHash as createHash4 } from "crypto";
+import { randomUUID as randomUUID6, createHash as createHash5 } from "crypto";
 import { execFile as execFile10 } from "child_process";
 import { promisify as promisify10 } from "util";
 async function packageRoot() {
-  let directory = path21.dirname(fileURLToPath(import.meta.url));
+  let directory = path22.dirname(fileURLToPath(import.meta.url));
   for (let i = 0; i < 8; i++) {
     try {
-      const pkg = JSON.parse(await fs16.readFile(path21.join(directory, "package.json"), "utf8"));
+      const pkg = JSON.parse(await fs17.readFile(path22.join(directory, "package.json"), "utf8"));
       if (pkg.name === "mason-context") return directory;
     } catch {
     }
-    directory = path21.dirname(directory);
+    directory = path22.dirname(directory);
   }
   throw new Error("Cannot locate the executing Mason distribution. Reinstall Mason and rerun setup.");
 }
 async function sourceRuntime() {
   const source = await packageRoot();
-  const pkg = JSON.parse(await fs16.readFile(path21.join(source, "package.json"), "utf8"));
-  const hashes = Object.fromEntries(await Promise.all(BINARIES.map(async (file) => [file, checksum(await fs16.readFile(path21.join(source, file)))])));
+  const pkg = JSON.parse(await fs17.readFile(path22.join(source, "package.json"), "utf8"));
+  const hashes = Object.fromEntries(await Promise.all(BINARIES.map(async (file) => [file, checksum(await fs17.readFile(path22.join(source, file)))])));
+  const bundleRoot = path22.dirname(source);
+  const bundleExists = await fs17.lstat(path22.join(bundleRoot, "bundle.json")).then(() => true, (error) => {
+    if (error.code === "ENOENT") return false;
+    throw error;
+  });
+  if (bundleExists) {
+    const { manifest, manifestHash } = await verifyBundle(bundleRoot);
+    if (manifest.version !== pkg.version) throw new Error("Mason package and bundle versions differ.");
+    return { source, bundleRoot, runtime: runtimeSchema.parse({
+      id: manifestHash.slice(0, 24),
+      version: pkg.version,
+      hashes,
+      bundle: { target: manifest.target, manifestHash }
+    }) };
+  }
   return { source, runtime: runtimeSchema.parse({ id: hash([pkg.version, pkg.dependencies, hashes]).slice(0, 24), version: pkg.version, hashes }) };
 }
 async function verifyRuntime(root, runtime) {
   try {
     const saved = await readStoreJson(root, `.mason/runtime/${runtime.id}/receipt.json`);
     if (JSON.stringify(saved) !== JSON.stringify(runtime)) return false;
+    if (runtime.bundle) {
+      const base2 = await storePath(root, `.mason/runtime/${runtime.id}`);
+      const { manifest } = await verifyBundle(base2, runtime.bundle.manifestHash);
+      if (manifest.version !== runtime.version || manifest.target !== runtime.bundle.target) return false;
+      for (const file of BINARIES) if (manifest.files["app/" + file] !== runtime.hashes[file]) return false;
+      return true;
+    }
     const base = `.mason/runtime/${runtime.id}/node_modules/mason-context/`;
     const pkg = await readStoreJson(root, base + "package.json");
     if (pkg?.name !== "mason-context" || pkg.version !== runtime.version) return false;
     for (const file of BINARIES) {
-      if (checksum(await fs16.readFile(await storePath(root, base + file))) !== runtime.hashes[file]) return false;
+      if (checksum(await fs17.readFile(await storePath(root, base + file))) !== runtime.hashes[file]) return false;
     }
     return true;
   } catch {
@@ -4109,30 +4224,42 @@ async function installRuntime(root, selected) {
   const relative = `.mason/runtime/${runtime.id}`;
   const target = await storePath(root, relative, true);
   const stage = await storePath(root, ".mason/runtime/.install-" + randomUUID6(), true);
-  await fs16.mkdir(stage);
+  await fs17.mkdir(stage);
   try {
-    const npm = process.platform === "win32" ? "npm.cmd" : "npm";
-    const options = { timeout: 12e4, maxBuffer: 2 * 1024 * 1024, windowsHide: true };
-    const packed = JSON.parse((await exec10(npm, ["pack", "--ignore-scripts", "--json", "--pack-destination", stage], { ...options, cwd: source })).stdout);
-    const filename = packed[0]?.filename;
-    if (typeof filename !== "string" || path21.basename(filename) !== filename) throw new Error("npm did not produce a Mason package archive.");
-    await fs16.rename(path21.join(stage, filename), path21.join(stage, "mason.tgz"));
-    await fs16.writeFile(path21.join(stage, "package.json"), JSON.stringify({ name: "mason-project-runtime", private: true, version: "1.0.0" }));
-    await exec10(npm, ["install", "--ignore-scripts", "--omit=dev", "--no-audit", "--no-fund", "--save-exact", "./mason.tgz"], { ...options, cwd: stage });
-    for (const file of BINARIES) {
-      if (checksum(await fs16.readFile(path21.join(stage, "node_modules/mason-context", file))) !== runtime.hashes[file]) throw new Error("Installed Mason binary differs from the selected distribution.");
+    if (runtime.bundle) {
+      if (!selected.bundleRoot) throw new Error("Standalone bundle source is missing.");
+      const { manifest } = await verifyBundle(selected.bundleRoot, runtime.bundle.manifestHash);
+      for (const file of ["bundle.json", ...Object.keys(manifest.files)]) {
+        const from = await storePath(selected.bundleRoot, file);
+        const to = await storePath(stage, file, true);
+        await fs17.copyFile(from, to);
+        await fs17.chmod(to, (await fs17.stat(from)).mode & 511);
+      }
+      await verifyBundle(stage, runtime.bundle.manifestHash);
+    } else {
+      const npm = process.platform === "win32" ? "npm.cmd" : "npm";
+      const options = { timeout: 12e4, maxBuffer: 2 * 1024 * 1024, windowsHide: true };
+      const packed = JSON.parse((await exec10(npm, ["pack", "--ignore-scripts", "--json", "--pack-destination", stage], { ...options, cwd: source })).stdout);
+      const filename = packed[0]?.filename;
+      if (typeof filename !== "string" || path22.basename(filename) !== filename) throw new Error("npm did not produce a Mason package archive.");
+      await fs17.rename(path22.join(stage, filename), path22.join(stage, "mason.tgz"));
+      await fs17.writeFile(path22.join(stage, "package.json"), JSON.stringify({ name: "mason-project-runtime", private: true, version: "1.0.0" }));
+      await exec10(npm, ["install", "--ignore-scripts", "--omit=dev", "--no-audit", "--no-fund", "--save-exact", "./mason.tgz"], { ...options, cwd: stage });
+      for (const file of BINARIES) {
+        if (checksum(await fs17.readFile(path22.join(stage, "node_modules/mason-context", file))) !== runtime.hashes[file]) throw new Error("Installed Mason binary differs from the selected distribution.");
+      }
     }
-    await fs16.writeFile(path21.join(stage, "receipt.json"), JSON.stringify(runtime, null, 2) + "\n");
+    await fs17.writeFile(path22.join(stage, "receipt.json"), JSON.stringify(runtime, null, 2) + "\n");
     try {
-      await fs16.rename(target, target + ".previous-" + randomUUID6());
+      await fs17.rename(target, target + ".previous-" + randomUUID6());
     } catch (error) {
       if (error.code !== "ENOENT") throw error;
     }
-    await fs16.rename(stage, target);
+    await fs17.rename(stage, target);
     if (!await verifyRuntime(root, runtime)) throw new Error("The installed Mason runtime could not be verified.");
     return runtime;
   } finally {
-    await fs16.rm(stage, { recursive: true, force: true });
+    await fs17.rm(stage, { recursive: true, force: true });
   }
 }
 var exec10, checksum, BINARIES;
@@ -4142,8 +4269,9 @@ var init_runtime2 = __esm({
     init_model();
     init_storage();
     init_evidence();
+    init_bundle();
     exec10 = promisify10(execFile10);
-    checksum = (bytes) => createHash4("sha256").update(bytes).digest("hex");
+    checksum = (bytes) => createHash5("sha256").update(bytes).digest("hex");
     BINARIES = ["dist/mason-auto.js", "dist/mason-mcp.js"];
   }
 });
@@ -4172,17 +4300,18 @@ async function setupStatus(dir) {
     };
   }
   const hosts = {};
-  const launcherCurrent = await readText(ws.root, ".mason/run.cjs") === LAUNCHER;
+  const commonLauncherCurrent = await readText(ws.root, ".mason/run.cjs") === LAUNCHER;
   const automation = await automationStatus(ws.root);
   for (const host of ["codex", "claude"]) {
     const entry = setup.hosts[host];
     if (!entry) continue;
+    const launcherCurrent = commonLauncherCurrent && (!entry.runtime.bundle || await readText(ws.root, ".mason/run.sh") === SHELL_LAUNCHER && await readText(ws.root, ".mason/run.ps1") === POWERSHELL_LAUNCHER && await readText(ws.root, `.mason/runtime/${host}.txt`) === entry.runtime.id + "\n");
     const instructions = await instructionEdits(ws.root, host);
     const instructionsCurrent = instructions.every((edit) => edit.before === edit.after);
     const installed = await verifyRuntime(ws.root, entry.runtime);
-    const config = await inspectHostConfig(ws.root, host);
-    const mcp = !config.mcpDisabled && hash(config.mcp) === entry.mcpFingerprint && isDeepStrictEqual2({ command: config.mcp?.command, args: config.mcp?.args }, mcpCommand(host));
-    const hooks = isDeepStrictEqual2(config.hooks, hookConfig(host, hookCommand(host)).hooks) && !config.disabled;
+    const config = await inspectHostConfig(ws.root, host, void 0, entry.runtime);
+    const mcp = !config.mcpDisabled && hash(config.mcp) === entry.mcpFingerprint && isDeepStrictEqual2({ command: config.mcp?.command, args: config.mcp?.args }, mcpCommand(host, entry.runtime));
+    const hooks = isDeepStrictEqual2(config.hooks, hookConfig(host, hookCommand(host, entry.runtime)).hooks) && !config.disabled;
     const local = await loadSetupReceipt(ws.root, ws.directory, host);
     const configured = local?.status === "configured" && local.root === ws.root && local.revision === entry.revision;
     const observation = await readObservation(ws.root, ws.directory, host, entry.revision);
@@ -4276,15 +4405,15 @@ async function setupProject(dir, options = {}) {
     const existing = await loadSetup(ws.root);
     const previousReceipt = await loadSetupReceipt(ws.root, ws.directory, host);
     const marker = await loadProjectMarker(ws.root);
+    const selected = await sourceRuntime();
     const instructions = await instructionEdits(ws.root, host);
-    const mcp = await mcpEdit(ws.root, host);
-    const hooks = await hookEdits(ws.root, host);
+    const mcp = await mcpEdit(ws.root, host, selected.runtime);
+    const hooks = await hookEdits(ws.root, host, selected.runtime);
     const ancillary = await ancillaryEdits(ws.root);
     const edits = [...ancillary, ...instructions, mcp, ...hooks];
     const setupBefore = await readText(ws.root, ".mason/setup.json");
-    const selected = await sourceRuntime();
-    const mcpFingerprint = hash((await inspectHostConfig(ws.root, host, mcp.after)).mcp);
-    const desiredHooks = hookConfig(host, hookCommand(host)).hooks;
+    const mcpFingerprint = hash((await inspectHostConfig(ws.root, host, mcp.after, selected.runtime)).mcp);
+    const desiredHooks = hookConfig(host, hookCommand(host, selected.runtime)).hooks;
     const fingerprint = hash({
       runtime: selected.runtime,
       launcher: LAUNCHER,
@@ -4312,6 +4441,10 @@ async function setupProject(dir, options = {}) {
       revision
     });
     await installRuntime(ws.root, selected);
+    if (selected.runtime.bundle) {
+      const pointer = `.mason/runtime/${host}.txt`;
+      await applyEdit(ws.root, { path: pointer, before: await readText(ws.root, pointer), after: selected.runtime.id + "\n" });
+    }
     const changedFiles = [];
     for (const edit of edits) if (await applyEdit(ws.root, edit)) changedFiles.push(edit.path);
     if (await applyEdit(ws.root, { path: ".mason/setup.json", before: setupBefore, after: JSON.stringify(setup, null, 2) + "\n" })) changedFiles.push(".mason/setup.json");
@@ -4320,7 +4453,7 @@ async function setupProject(dir, options = {}) {
       changedFiles.push(".mason/project.json");
     }
     const checked = await automate(ws.root, { event: "turn_start" });
-    const configured = await inspectHostConfig(ws.root, host);
+    const configured = await inspectHostConfig(ws.root, host, void 0, selected.runtime);
     await writeStoreJson(ws.root, receiptPath, {
       version: 1,
       host,