machine-bridge-mcp 2.0.0 → 3.0.0-beta.11

package/scripts/coverage-check.mjs

@@ -16,6 +16,7 @@ const tests = [
   "tests/runtime-handler-matrix-test.mjs",
   "tests/cli-entrypoint-test.mjs",
   "tests/cli-service-test.mjs",
+  "tests/service-restart-handoff-test.mjs",
   "tests/local-self-test.mjs",
   "tests/runtime-self-test.mjs",
   "tests/numbers-test.mjs",
@@ -31,6 +32,12 @@ const tests = [
   "tests/managed-jobs-test.mjs",
   "tests/account-admin-test.mjs",
   "tests/monotonic-deadline-test.mjs",
+  "tests/device-auth-test.mjs",
+  "tests/operation-authorization-test.mjs",
+  "tests/security-audit-log-test.mjs",
+  "tests/delegated-process-sandbox-test.mjs",
+  "tests/dpop-test.mjs",
+  "tests/worker-security-boundaries-test.mjs",
 ];
 
 try {
@@ -50,17 +57,31 @@ try {
 
   const coverage = collectCoverage(coverageDir);
   const thresholds = {
+    "src/local/authority-context.mjs": [85, 55],
+    "src/local/device-identity.mjs": [90, null],
+    "src/local/operation-authorization.mjs": [85, 45],
+    "src/local/operation-risk.mjs": [85, 60],
+    "src/local/operation-state-lock.mjs": [100, 7],
+    "src/local/security-audit-log.mjs": [85, 55],
+    "src/local/delegated-process-sandbox.mjs": [80, 45],
+    "src/shared/device-session-auth.mjs": [100, null],
     "src/local/policy.mjs": [90, 65],
     "src/local/errors.mjs": [70, 50],
     "src/local/call-registry.mjs": [85, 55],
     "src/local/tool-executor.mjs": [90, 40],
+    "src/local/tool-result-boundary.mjs": [100, 75],
     "src/local/observability.mjs": [95, 40],
     "src/local/process-tracker.mjs": [65, 35],
     "src/local/log.mjs": [60, 40],
     "src/local/runtime.mjs": [75, 55],
     "src/local/runtime-paths.mjs": [90, 50],
     "src/local/cli.mjs": [48, 21.9],
-    "src/local/cli-service.mjs": [90, 65],
+    "src/local/cli-service.mjs": [100, 75],
+    "src/local/service-convergence.mjs": [100, 75],
+    "src/local/service-status.mjs": [100, 75],
+    "src/local/service-ownership.mjs": [100, 75],
+    "src/local/service-restart-scheduler.mjs": [100, 70],
+    "src/local/service-restart-handoff.mjs": [100, 60],
     "src/local/cli-options.mjs": [65, 35],
     "src/local/cli-policy.mjs": [70, 35],
     "src/local/numbers.mjs": [100, 100],
@@ -91,7 +112,14 @@ try {
     "src/local/browser-request-registry.mjs": [95, 35],
     "src/local/browser-broker-routes.mjs": [85, 55],
     "src/local/browser-broker-server.mjs": [80, 50],
-    "src/worker/oauth-controller.ts": [85, 65],
+    "src/worker/account-admin.ts": [70, 35],
+    "src/worker/daemon-auth.ts": [85, 45],
+    "src/worker/dpop.ts": [90, 30],
+    "src/worker/nonce-store.ts": [85, 50],
+    "src/worker/oauth-client-admin.ts": [75, 45],
+    "src/worker/oauth-refresh-families.ts": [70, 35],
+    "src/worker/oauth-tokens.ts": [70, 35],
+    "src/worker/oauth-controller.ts": [84, 65],
     "src/worker/oauth-authorization-page.ts": [90, 60],
     "src/worker/pending-calls.ts": [90, 35],
     "src/worker/policy.ts": [100, 25],

package/scripts/github-push.mjs

@@ -1,10 +1,13 @@
 #!/usr/bin/env node
 
 import { spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
 import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { verifyCurrentReleaseAcceptance } from "./release-acceptance.mjs";
 import { assertGitHubBacklogReady } from "./github-backlog.mjs";
+import { parseReleaseVersion, requiresSoakForStable } from "./release-channel.mjs";
+import { verifyCurrentStableSoak } from "./release-soak.mjs";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 
@@ -25,6 +28,14 @@ try {
     console.log(`Verified interactive local candidate acceptance for ${acceptance.metadata.filename}.`);
   }
 
+  const releaseVersion = parseReleaseVersion(JSON.parse(readFileSync(resolve(root, "package.json"), "utf8")).version);
+  if (!releaseVersion.prerelease && requiresSoakForStable(releaseVersion.raw)) {
+    const soak = verifyCurrentStableSoak(root);
+    const path = `release-soak/v${releaseVersion.raw}.json`;
+    run("git", ["ls-files", "--error-unmatch", path], { capture: true });
+    console.log(`Verified stable promotion from soaked ${soak.record.prerelease_version}.`);
+  }
+
   run("git", ["push", "--set-upstream", "origin", "HEAD"]);
   console.log(`Pushed accepted branch ${branch} to origin.`);
 } catch (error) {

package/scripts/github-release.mjs

@@ -13,6 +13,8 @@ import { runNetworkCommand } from "./network-retry.mjs";
 import { requireSuccessfulWorkflowRun } from "./release-ci.mjs";
 import { tagSyncError } from "./release-state.mjs";
 import { verifyCurrentReleaseAcceptance } from "./release-acceptance.mjs";
+import { parseReleaseVersion, requiresSoakForStable } from "./release-channel.mjs";
+import { verifyCurrentStableSoak } from "./release-soak.mjs";
 import { fileURLToPath } from "node:url";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
@@ -179,7 +181,9 @@ function releaseInfo(tag) {
 
 function assertCoreSync({ requireReleaseAsset }) {
   const pkg = packageMetadata();
+  const parsedVersion = parseReleaseVersion(pkg.version);
   assertLocalAcceptance();
+  if (requiresSoakForStable(pkg.version)) assertStableSoak();
   const tag = `v${pkg.version}`;
   const head = output("git", ["rev-parse", "HEAD"]);
   const originMain = output("git", ["rev-parse", "origin/main"]);
@@ -197,8 +201,10 @@ function assertCoreSync({ requireReleaseAsset }) {
   if (remoteTagError) fail(remoteTagError);
 
   const release = releaseInfo(tag);
-  if (!release || release.isDraft || release.isPrerelease) {
-    fail(`published GitHub Release ${tag} is missing or not final`);
+  if (!release || release.isDraft || release.isPrerelease !== parsedVersion.prerelease) {
+    fail(parsedVersion.prerelease
+      ? `published GitHub prerelease ${tag} is missing or not marked as prerelease`
+      : `published GitHub Release ${tag} is missing or not final`);
   }
 
   if (requireReleaseAsset) {
@@ -250,7 +256,7 @@ function normalizePackRecord(value, packageName) {
   return Object.values(value).find((item) => item && typeof item === "object") ?? null;
 }
 
-function ensureRelease(tag, version, assetPath, latest) {
+function ensureRelease(tag, version, assetPath, { latest, prerelease }) {
   const temp = dirname(assetPath);
   const notes = writeNotesFile(temp, version);
   const existing = releaseInfo(tag);
@@ -266,6 +272,7 @@ function ensureRelease(tag, version, assetPath, latest) {
       "--title",
       title,
       latest ? "--latest" : "--latest=false",
+      prerelease ? "--prerelease" : "--prerelease=false",
     ];
     if (notes) args.push("--notes-file", notes);
     else args.push("--generate-notes");
@@ -279,13 +286,14 @@ function ensureRelease(tag, version, assetPath, latest) {
       "--title",
       title,
       latest ? "--latest" : "--latest=false",
+      prerelease ? "--prerelease" : "--prerelease=false",
       ...(notes ? ["--notes-file", notes] : []),
     ]);
     runNetwork("gh", ["release", "upload", tag, assetPath, "--clobber"]);
   }
 }
 
-function publishCurrent() {
+function publishCurrent({ prereleaseMode = false } = {}) {
   ensureClean();
   fetchRemote();
 
@@ -293,6 +301,13 @@ function publishCurrent() {
   if (branch !== "main") fail(`release must run from main, not ${branch || "detached HEAD"}`);
 
   const pkg = packageMetadata();
+  const parsedVersion = parseReleaseVersion(pkg.version);
+  if (prereleaseMode !== parsedVersion.prerelease) {
+    fail(parsedVersion.prerelease
+      ? "prerelease versions must use npm run prerelease:release"
+      : "stable versions must use npm run release");
+  }
+  if (!parsedVersion.prerelease && requiresSoakForStable(pkg.version)) assertStableSoak();
   const tag = `v${pkg.version}`;
   if (!changelogBody(pkg.version)) {
     fail(`CHANGELOG.md has no section for ${pkg.version}`);
@@ -329,7 +344,10 @@ function publishCurrent() {
   const temp = mkdtempSync(join(tmpdir(), "machine-bridge-mcp-release-"));
   try {
     const assetPath = packReleaseAsset(temp, pkg);
-    ensureRelease(tag, pkg.version, assetPath, true);
+    ensureRelease(tag, pkg.version, assetPath, {
+      latest: !parsedVersion.prerelease,
+      prerelease: parsedVersion.prerelease,
+    });
   } finally {
     rmSync(temp, { recursive: true, force: true });
   }
@@ -338,6 +356,17 @@ function publishCurrent() {
   assertCoreSync({ requireReleaseAsset: true });
 }
 
+function assertStableSoak() {
+  try {
+    const result = verifyCurrentStableSoak(root);
+    if (result.required) {
+      console.log(`Stable promotion matches soaked ${result.record.prerelease_version} (${result.promotionDigest}).`);
+    }
+  } catch (error) {
+    fail(String(error?.message || error));
+  }
+}
+
 function assertLocalAcceptance() {
   try {
     const result = verifyCurrentReleaseAcceptance(root);
@@ -405,9 +434,11 @@ if (mode === "--check") {
   fetchRemote();
   assertCoreSync({ requireReleaseAsset: true });
 } else if (mode === "--publish") {
-  publishCurrent();
+  publishCurrent({ prereleaseMode: false });
+} else if (mode === "--publish-prerelease") {
+  publishCurrent({ prereleaseMode: true });
 } else if (mode === "--backfill") {
   backfillMissingReleases();
 } else {
-  fail("usage: node scripts/github-release.mjs [--check|--publish|--backfill]");
+  fail("usage: node scripts/github-release.mjs [--check|--publish|--publish-prerelease|--backfill]");
 }

package/scripts/install-published-prerelease.mjs

@@ -0,0 +1,167 @@
+#!/usr/bin/env node
+
+import { spawnSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath } from "node:url";
+import { defaultStateRoot, expandHome } from "../src/local/state.mjs";
+import { writePrereleaseActivation } from "./prerelease-activation.mjs";
+import { computePromotionContentDigest } from "./promotion-digest.mjs";
+import { readPublishedNpmPrerelease } from "./published-release.mjs";
+import { verifyCurrentReleaseAcceptance } from "./release-acceptance.mjs";
+import { assertSoakEligiblePrerelease } from "./release-channel.mjs";
+
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const npmCli = process.env.npm_execpath;
+let previousInstallation = null;
+let installedPrerelease = "";
+if (!npmCli) fail("published prerelease installation must run through npm");
+
+try {
+  if (!process.argv.includes("--allow-worker-deploy")) {
+    throw new Error("published prerelease activation updates the global package, same-name Worker, and login daemon; rerun with --allow-worker-deploy");
+  }
+  const pkg = JSON.parse(readFileSync(join(root, "package.json"), "utf8"));
+  const requested = argumentValue("--version") || pkg.version;
+  const prerelease = assertSoakEligiblePrerelease(requested);
+  if (pkg.version !== prerelease.raw) {
+    throw new Error(`source checkout version ${pkg.version} does not match requested prerelease ${prerelease.raw}`);
+  }
+  const acceptance = verifyCurrentReleaseAcceptance(root);
+  if (!acceptance.required || acceptance.metadata.package_version !== prerelease.raw) {
+    throw new Error("published prerelease installation requires the locally accepted exact prerelease source");
+  }
+  const promotionDigest = computePromotionContentDigest(root);
+  if (acceptance.record.promotion_content_sha256 !== promotionDigest) {
+    throw new Error("current source promotion digest does not match local candidate acceptance");
+  }
+  const published = readPublishedNpmPrerelease(pkg.name, prerelease.raw, prerelease.npmTag);
+  if (published.integrity !== acceptance.metadata.integrity || published.shasum !== acceptance.metadata.shasum) {
+    throw new Error("npm prerelease bytes do not match the locally accepted candidate");
+  }
+
+  previousInstallation = currentGlobalInstallation(pkg.name);
+  runNpm([
+    "install", "--global", "--omit=optional",
+    "--allow-scripts=esbuild,workerd,sharp,fsevents",
+    `${pkg.name}@${prerelease.raw}`,
+  ]);
+  const installed = currentGlobalInstallation(pkg.name);
+  if (!installed || installed.version !== prerelease.raw) {
+    throw new Error(`global prerelease installation did not converge on ${prerelease.raw}`);
+  }
+  installedPrerelease = prerelease.raw;
+
+  const stateRoot = resolve(expandHome(argumentValue("--state-dir") || defaultStateRoot()));
+  const forwarded = forwardedActivationArgs();
+  const activation = runActivation(installed.entry, ["activate", ...forwarded, "--state-dir", stateRoot, "--json"]);
+  if (activation.version !== prerelease.raw || activation.daemon?.version !== prerelease.raw || activation.worker?.health?.version !== prerelease.raw) {
+    throw new Error("published prerelease activation did not converge on the exact registry version");
+  }
+  const recordPath = writePrereleaseActivation({
+    schema_version: 1,
+    package_name: pkg.name,
+    package_version: prerelease.raw,
+    source: "npm-prerelease",
+    shasum: published.shasum,
+    integrity: published.integrity,
+    promotion_content_sha256: promotionDigest,
+    activated_at: new Date().toISOString(),
+    published_at: published.publishedAt,
+    npm_dist_tag: prerelease.npmTag,
+    workspace_hash: workspaceHash(activation.workspace),
+    runtime_entry: installed.entry,
+    ...(previousInstallation ? { previous: previousInstallation } : {}),
+  }, stateRoot);
+
+  console.log(`Published prerelease activated: ${prerelease.raw}`);
+  console.log(`Worker and login daemon version: ${activation.version}`);
+  console.log(`Soak activation record: ${recordPath}`);
+  console.log("Use this prerelease normally. Any blocking issue requires a new beta/rc version and restarts the soak clock.");
+} catch (error) {
+  const message = boundedDiagnostic(error?.message || error);
+  if (installedPrerelease) {
+    const previousVersion = previousInstallation?.version || "unknown";
+    fail(`${message}. The global package is now ${installedPrerelease}, but Worker/service activation may not have converged. Previous global version: ${previousVersion}. Preserve state and logs; fix forward with the exact prerelease or restore package, Worker, service definition, browser extension, and state as one verified unit.`);
+  }
+  fail(message);
+}
+
+function currentGlobalInstallation(packageName) {
+  try {
+    const globalRoot = runNpm(["root", "--global"]).stdout.trim();
+    const packageRoot = join(globalRoot, packageName);
+    const packagePath = join(packageRoot, "package.json");
+    const entry = join(packageRoot, "bin", "machine-mcp.mjs");
+    if (!existsSync(packagePath) || !existsSync(entry)) return null;
+    const value = JSON.parse(readFileSync(packagePath, "utf8"));
+    return { version: String(value.version || ""), entry };
+  } catch {
+    return null;
+  }
+}
+
+function runActivation(entry, args) {
+  const result = spawnSync(process.execPath, [entry, ...args], {
+    cwd: root,
+    env: process.env,
+    encoding: "utf8",
+    timeout: 300_000,
+    windowsHide: true,
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error(`prerelease runtime activation failed: ${boundedDiagnostic(result.stderr || result.stdout)}`);
+  try { return JSON.parse(result.stdout); } catch { throw new Error("prerelease runtime activation did not return valid JSON"); }
+}
+
+function runNpm(args) {
+  const result = spawnSync(process.execPath, [npmCli, ...args], {
+    cwd: root,
+    env: process.env,
+    encoding: "utf8",
+    timeout: 300_000,
+    windowsHide: true,
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error(`npm ${args[0]} failed: ${boundedDiagnostic(result.stderr || result.stdout)}`);
+  return result;
+}
+
+function forwardedActivationArgs() {
+  const out = [];
+  const skipWithValue = new Set(["--version", "--state-dir"]);
+  for (let index = 2; index < process.argv.length; index += 1) {
+    const value = process.argv[index];
+    if (value === "--allow-worker-deploy") continue;
+    if (skipWithValue.has(value)) { index += 1; continue; }
+    if (["--version=", "--state-dir="].some((prefix) => value.startsWith(prefix))) continue;
+    if (value === "--json" || value.startsWith("--json=")) continue;
+    out.push(value);
+  }
+  return out;
+}
+
+function argumentValue(name) {
+  const exact = process.argv.find((value) => value.startsWith(`${name}=`));
+  if (exact) return exact.slice(name.length + 1);
+  const index = process.argv.indexOf(name);
+  return index >= 0 ? process.argv[index + 1] : "";
+}
+
+function workspaceHash(workspace) {
+  const value = process.platform === "win32" ? String(workspace).toLowerCase() : String(workspace);
+  return createHash("sha256").update(value).digest("hex").slice(0, 24);
+}
+
+function boundedDiagnostic(value) {
+  const home = String(process.env.HOME || process.env.USERPROFILE || "");
+  let text = String(value || "unknown error").replace(/[\r\n\t]+/g, " ").trim();
+  if (home) text = text.split(home).join("<home>");
+  return text.slice(0, 1600);
+}
+
+function fail(message) {
+  console.error(`published prerelease installation failed: ${message}`);
+  process.exit(1);
+}

package/scripts/local-release-acceptance.mjs

@@ -5,14 +5,13 @@ import {
   mkdtempSync,
   readFileSync,
   rmSync,
-  writeFileSync,
 } from "node:fs";
 import { spawnSync } from "node:child_process";
 import { tmpdir } from "node:os";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import {
-  ACCEPTANCE_CONFIRMATION,
+  acceptanceConfirmationForVersion,
   ACCEPTANCE_SCHEMA_VERSION,
   acceptancePath,
   packProject,
@@ -21,6 +20,10 @@ import {
   verifyCurrentReleaseAcceptance,
   verifyTarball,
 } from "./release-acceptance.mjs";
+import { computePromotionContentDigest } from "./promotion-digest.mjs";
+import { parseReleaseVersion } from "./release-channel.mjs";
+import { validateCandidateManifest } from "./release-candidate-manifest.mjs";
+import { replaceFileAtomicallySync } from "../src/local/exclusive-file.mjs";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const candidateDirectory = join(root, ".release-candidate");
@@ -48,14 +51,16 @@ function prepareCandidate() {
     schema_version: ACCEPTANCE_SCHEMA_VERSION,
     result: "pending",
     ...metadata,
+    promotion_content_sha256: computePromotionContentDigest(root),
     prepared_at: new Date().toISOString(),
   };
-  writeFileSync(candidateManifestPath, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
+  replaceFileAtomicallySync(candidateManifestPath, `${JSON.stringify(manifest, null, 2)}\n`, { mode: 0o600 });
   const phrase = confirmationPhrase(pkg.name, pkg.version);
   console.log(`Release candidate created: ${join(candidateDirectory, metadata.filename)}`);
-  console.log("After the repository owner explicitly authorizes this exact candidate in the active conversation, the coding agent starts it through Machine Bridge with:");
-  console.log("npm run release:candidate:start -- --allow-worker-deploy");
-  console.log("The owner does not need to run a terminal authorization command. The coding agent keeps the candidate running while verifying connection readiness and representative functionality through Machine Bridge.");
+  console.log("The repository owner activates this exact candidate with one persistent owner-side command:");
+  parseReleaseVersion(pkg.version);
+  console.log("npm run release:candidate:activate -- --allow-worker-deploy");
+  console.log("The owner runs this one command. It installs the exact candidate in the private state root, updates the same-name Worker, verifies candidate relay readiness, replaces the login daemon, verifies the background handoff, and exits while the service remains active.");
   console.log("After that observed live verification succeeds, the coding agent records acceptance with:");
   console.log(`npm run release:accept -- --confirm \"${phrase}\"`);
   console.log("Automated tests alone do not authorize acceptance or the first GitHub push.");
@@ -68,10 +73,10 @@ function recordAcceptance() {
   if (supplied !== expected) {
     throw new Error(`interactive candidate verification confirmation must exactly match: ${expected}`);
   }
-  const pending = readJson(candidateManifestPath, "release candidate manifest");
-  if (pending.result !== "pending" || pending.package_name !== pkg.name || pending.package_version !== pkg.version) {
-    throw new Error("release candidate manifest does not match the current package");
-  }
+  const pending = validateCandidateManifest(readJson(candidateManifestPath, "release candidate manifest"), {
+    packageName: pkg.name,
+    packageVersion: pkg.version,
+  });
   verifyTarball(join(candidateDirectory, pending.filename), pending);
 
   const verificationDirectory = join(candidateDirectory, "verification");
@@ -84,10 +89,15 @@ function recordAcceptance() {
     }
   }
 
+  const promotionDigest = computePromotionContentDigest(root);
+  if (pending.promotion_content_sha256 !== promotionDigest) {
+    throw new Error("source changed after candidate preparation: promotion content digest no longer matches");
+  }
+
   const record = {
     schema_version: ACCEPTANCE_SCHEMA_VERSION,
     result: "passed",
-    confirmation: ACCEPTANCE_CONFIRMATION,
+    confirmation: acceptanceConfirmationForVersion(pkg.version),
     package_name: current.package_name,
     package_version: current.package_version,
     filename: current.filename,
@@ -95,11 +105,12 @@ function recordAcceptance() {
     integrity: current.integrity,
     accepted_at: new Date().toISOString(),
     package_content_sha256: computePortablePackageDigest(),
+    promotion_content_sha256: promotionDigest,
   };
   verifyAcceptanceRecord(record, current);
   const path = acceptancePath(root, pkg.version);
   mkdirSync(dirname(path), { recursive: true });
-  writeFileSync(path, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+  replaceFileAtomicallySync(path, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o644 });
   console.log(`Interactive local candidate acceptance recorded: ${path}`);
   console.log("Commit this record with the candidate. Any packaged-file change invalidates it.");
 }

package/scripts/npm-publication-policy.mjs

@@ -0,0 +1,16 @@
+#!/usr/bin/env node
+
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { assertPublishTag, parseReleaseVersion } from "./release-channel.mjs";
+
+try {
+  const pkg = JSON.parse(readFileSync(resolve("package.json"), "utf8"));
+  const parsed = parseReleaseVersion(pkg.version);
+  const configured = String(process.env.npm_config_tag || "latest").trim().toLowerCase() || "latest";
+  assertPublishTag(parsed.raw, configured);
+  console.log(`npm publication channel verified: ${parsed.raw} -> ${parsed.npmTag}`);
+} catch (error) {
+  console.error(`npm publication policy failed: ${error?.message || error}`);
+  process.exit(1);
+}

package/scripts/prerelease-activation.mjs

@@ -0,0 +1,79 @@
+import { existsSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { defaultStateRoot, expandHome } from "../src/local/state.mjs";
+import { replaceFileAtomicallySync } from "../src/local/exclusive-file.mjs";
+import { ensureOwnerOnlyDirectorySync, readBoundedRegularFileSync } from "../src/local/secure-file.mjs";
+import { assertSoakEligiblePrerelease } from "./release-channel.mjs";
+
+export const ACTIVATION_SCHEMA_VERSION = 1;
+const MAX_ACTIVATION_BYTES = 64 * 1024;
+const SOURCES = new Set(["local-candidate", "npm-prerelease"]);
+
+export function prereleaseActivationPath(version, stateRoot = defaultStateRoot()) {
+  const parsed = assertSoakEligiblePrerelease(version);
+  return join(resolve(expandHome(stateRoot)), "release-channels", "activations", `v${parsed.raw}.json`);
+}
+
+export function writePrereleaseActivation(record, stateRoot = defaultStateRoot()) {
+  const normalized = validatePrereleaseActivation(record);
+  const file = prereleaseActivationPath(normalized.package_version, stateRoot);
+  ensureOwnerOnlyDirectorySync(dirname(file));
+  replaceFileAtomicallySync(file, `${JSON.stringify(normalized, null, 2)}\n`, { mode: 0o600 });
+  return file;
+}
+
+export function readPrereleaseActivation(version, stateRoot = defaultStateRoot()) {
+  const file = prereleaseActivationPath(version, stateRoot);
+  if (!existsSync(file)) throw new Error(`prerelease activation record is missing: ${file}`);
+  let value;
+  try { value = JSON.parse(readBoundedRegularFileSync(file, MAX_ACTIVATION_BYTES, "prerelease activation record", { verifyPathIdentity: true }).toString("utf8")); }
+  catch (error) { throw new Error(`prerelease activation record is unavailable or invalid: ${error.message}`); }
+  return validatePrereleaseActivation(value);
+}
+
+export function validatePrereleaseActivation(value) {
+  if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error("prerelease activation record must be an object");
+  if (value.schema_version !== ACTIVATION_SCHEMA_VERSION) throw new Error("unsupported prerelease activation schema");
+  const parsed = assertSoakEligiblePrerelease(value.package_version);
+  if (value.package_name !== "machine-bridge-mcp") throw new Error("prerelease activation package name is invalid");
+  if (!SOURCES.has(value.source)) throw new Error("prerelease activation source is invalid");
+  if (!/^[0-9a-f]{40}$/.test(String(value.shasum || ""))) throw new Error("prerelease activation SHA-1 is invalid");
+  if (!/^sha512-[A-Za-z0-9+/]+={0,2}$/.test(String(value.integrity || ""))) throw new Error("prerelease activation integrity is invalid");
+  if (!/^[0-9a-f]{64}$/.test(String(value.promotion_content_sha256 || ""))) throw new Error("prerelease activation promotion digest is invalid");
+  const activatedAt = Date.parse(String(value.activated_at || ""));
+  if (!Number.isFinite(activatedAt)) throw new Error("prerelease activation timestamp is invalid");
+  if (value.source === "npm-prerelease") {
+    if (value.npm_dist_tag !== parsed.npmTag) throw new Error("prerelease activation npm dist-tag is invalid");
+    const publishedAt = Date.parse(String(value.published_at || ""));
+    if (!Number.isFinite(publishedAt) || publishedAt > activatedAt + 5 * 60 * 1000) throw new Error("prerelease activation publication timestamp is invalid");
+  }
+  const workspaceHash = String(value.workspace_hash || "");
+  if (workspaceHash && !/^[0-9a-f]{24}$/.test(workspaceHash)) throw new Error("prerelease activation workspace hash is invalid");
+  const runtimeEntry = String(value.runtime_entry || "");
+  if (runtimeEntry && !isAbsolute(runtimeEntry)) throw new Error("prerelease activation runtime entry must be absolute");
+  let previous;
+  if (value.previous !== undefined) {
+    if (!value.previous || typeof value.previous !== "object" || Array.isArray(value.previous)) throw new Error("prerelease activation previous runtime is invalid");
+    const previousVersion = String(value.previous.version || "");
+    const previousEntry = String(value.previous.entry || "");
+    if (!previousVersion || !previousEntry || !isAbsolute(previousEntry)) throw new Error("prerelease activation previous runtime is invalid");
+    previous = { version: previousVersion, entry: previousEntry };
+  }
+  return Object.freeze({
+    schema_version: ACTIVATION_SCHEMA_VERSION,
+    package_name: value.package_name,
+    package_version: parsed.raw,
+    source: value.source,
+    shasum: value.shasum,
+    integrity: value.integrity,
+    promotion_content_sha256: value.promotion_content_sha256,
+    activated_at: new Date(activatedAt).toISOString(),
+    ...(value.source === "npm-prerelease" ? {
+      npm_dist_tag: value.npm_dist_tag,
+      published_at: new Date(Date.parse(value.published_at)).toISOString(),
+    } : {}),
+    ...(workspaceHash ? { workspace_hash: workspaceHash } : {}),
+    ...(runtimeEntry ? { runtime_entry: runtimeEntry } : {}),
+    ...(previous ? { previous } : {}),
+  });
+}

package/scripts/privacy-check.mjs

@@ -3,9 +3,11 @@ import { existsSync, readFileSync, readdirSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { readBoundedRegularFileSync } from "../src/local/secure-file.mjs";
+import { createTrustedGitResolver } from "../src/local/trusted-git-executable.mjs";
 
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "..");
 const selfPath = "scripts/privacy-check.mjs";
+const gitExecutable = createTrustedGitResolver({ workspace: root });
 const requestedOptions = new Set(process.argv.slice(2));
 for (const option of requestedOptions) {
   if (option !== "--history") throw new Error(`unknown privacy-check option: ${option}`);
@@ -68,7 +70,7 @@ process.stderr.write(`privacy check ok (${candidates.length} tracked/unignored f
 
 function collectCandidateFiles(directory) {
   try {
-    return execFileSync("git", ["-C", directory, "ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
+    return execFileSync(gitExecutable(), ["-C", directory, "ls-files", "-z", "--cached", "--others", "--exclude-standard"], {
       encoding: "buffer",
       maxBuffer: 32 * 1024 * 1024,
       stdio: ["ignore", "pipe", "ignore"],
@@ -98,7 +100,7 @@ function collectCandidateFiles(directory) {
 function scanReachableHistory(directory, entries, out) {
   let listing;
   try {
-    listing = execFileSync("git", ["-C", directory, "rev-list", "--objects", "--all", "-z"], {
+    listing = execFileSync(gitExecutable(), ["-C", directory, "rev-list", "--objects", "--all", "-z"], {
       encoding: "buffer",
       maxBuffer: 64 * 1024 * 1024,
       stdio: ["ignore", "pipe", "pipe"],
@@ -130,7 +132,7 @@ function scanReachableHistory(directory, entries, out) {
   const hashes = [...objectPaths.keys()];
   let metadata;
   try {
-    metadata = execFileSync("git", ["-C", directory, "cat-file", "--batch-check=%(objectname) %(objecttype) %(objectsize)"], {
+    metadata = execFileSync(gitExecutable(), ["-C", directory, "cat-file", "--batch-check=%(objectname) %(objecttype) %(objectsize)"], {
       input: `${hashes.join("\n")}\n`,
       encoding: "utf8",
       maxBuffer: 64 * 1024 * 1024,
@@ -162,7 +164,7 @@ function scanReachableHistory(directory, entries, out) {
     }
     let buffer;
     try {
-      buffer = execFileSync("git", ["-C", directory, "cat-file", "blob", hash], {
+      buffer = execFileSync(gitExecutable(), ["-C", directory, "cat-file", "blob", hash], {
         encoding: "buffer",
         maxBuffer: 6 * 1024 * 1024,
         stdio: ["ignore", "pipe", "pipe"],
@@ -194,7 +196,7 @@ function scanReachableHistory(directory, entries, out) {
 function scanReachableCommitMessages(directory, entries, out) {
   let output;
   try {
-    output = execFileSync("git", ["-C", directory, "log", "--all", "--format=%H%x00%B%x00"], {
+    output = execFileSync(gitExecutable(), ["-C", directory, "log", "--all", "--format=%H%x00%B%x00"], {
       encoding: "buffer",
       maxBuffer: 64 * 1024 * 1024,
       stdio: ["ignore", "pipe", "pipe"],