machine-bridge-mcp 3.0.0-beta.21 → 3.0.0-beta.26

package/scripts/coverage-check.mjs

@@ -5,6 +5,7 @@ import { dirname, isAbsolute, relative, resolve, sep } from "node:path";
 import { fileURLToPath } from "node:url";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+const CRITICAL_SCRIPT_FILES = new Set(["scripts/release-publication-guard.mjs"]);
 const coverageDir = mkdtempSync(resolve(tmpdir(), "machine-bridge-coverage-"));
 const tests = [
   "tests/policy-test.mjs",
@@ -12,12 +13,19 @@ const tests = [
   "tests/runtime-boundaries-test.mjs",
   "tests/worker-runtime-infrastructure-test.mjs",
   "tests/mcp-resumption-test.mjs",
+  "tests/mcp-protocol-test.mjs",
+  "tests/mcp-modern-controller-test.mjs",
+  "tests/tool-argument-validation-test.mjs",
   "tests/worker-oauth-controller-test.mjs",
   "tests/logging-structure-test.mjs",
   "tests/runtime-handler-matrix-test.mjs",
   "tests/cli-entrypoint-test.mjs",
   "tests/cli-service-test.mjs",
   "tests/service-restart-handoff-test.mjs",
+  "tests/service-platform-test.mjs",
+  "tests/process-lock-test.mjs",
+  "tests/runtime-activation-test.mjs",
+  "tests/release-publication-guard-test.mjs",
   "tests/local-self-test.mjs",
   "tests/runtime-self-test.mjs",
   "tests/numbers-test.mjs",
@@ -28,6 +36,7 @@ const tests = [
   "tests/agent-context-test.mjs",
   "tests/agent-boundaries-test.mjs",
   "tests/capability-ranking-test.mjs",
+  "tests/execution-routing-test.mjs",
   "tests/browser-bridge-test.mjs",
   "tests/relay-connection-test.mjs",
   "tests/managed-jobs-test.mjs",
@@ -67,6 +76,9 @@ try {
     "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/shared/mcp-protocol.mjs": [90, 70],
+    "src/shared/mcp-subscriptions.mjs": [95, 75],
+    "src/shared/tool-argument-validation.mjs": [90, 70],
     "src/local/policy.mjs": [90, 65],
     "src/local/errors.mjs": [70, 50],
     "src/local/call-registry.mjs": [85, 55],
@@ -86,6 +98,12 @@ try {
     "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/service-owner.mjs": [100, 85],
+    "src/local/service-runtime.mjs": [100, 80],
+    "src/local/windows-service-convergence.mjs": [100, 95],
+    "src/local/runtime-activation.mjs": [90, 70],
+    "scripts/release-publication-guard.mjs": [100, 80],
+    "src/local/child-process-settlement.mjs": [100, 85],
     "src/local/cli-options.mjs": [65, 35],
     "src/local/cli-policy.mjs": [70, 35],
     "src/local/numbers.mjs": [100, 100],
@@ -100,10 +118,12 @@ try {
     "src/local/agent-skill-discovery.mjs": [85, 60],
     "src/local/agent-text-file.mjs": [90, 60],
     "src/local/capability-ranking.mjs": [95, 70],
+    "src/local/execution-routing.mjs": [95, 70],
     "src/local/browser-extension-protocol.mjs": [95, 35],
     "src/local/browser-operation-service.mjs": [80, 50],
     "src/local/runtime-reporting.mjs": [95, 75],
     "src/local/runtime-diagnostics.mjs": [75, 65],
+    "src/local/system-network-route.mjs": [90, 75],
     "src/local/runtime-capabilities.mjs": [75, 45],
     "src/local/monotonic-deadline.mjs": [100, 100],
     "src/local/path-inspection.mjs": [100, 60],
@@ -112,12 +132,15 @@ try {
     "src/local/managed-jobs.mjs": [85, 50],
     "src/local/managed-job-projection.mjs": [90, 60],
     "src/local/managed-job-storage.mjs": [75, 50],
+    "src/local/managed-job-runner-claim.mjs": [90, 60],
     "src/local/managed-job-runner.mjs": [80, 50],
     "src/local/browser-bridge.mjs": [80, 55],
     "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/account-admin.ts": [70, 35],
+    "src/worker/tool-timeout.ts": [95, 85],
+    "src/worker/tool-catalog.ts": [95, 80],
     "src/worker/daemon-auth.ts": [85, 45],
     "src/worker/dpop.ts": [90, 30],
     "src/worker/nonce-store.ts": [85, 50],
@@ -130,6 +153,12 @@ try {
     "src/worker/policy.ts": [100, 25],
     "src/worker/errors.ts": [100, 40],
     "src/worker/mcp-jsonrpc.ts": [95, 55],
+    "src/worker/mcp-tool-call-input.ts": [100, 75],
+    "src/worker/mcp-http-contract.ts": [90, 70],
+    "src/worker/mcp-modern-controller.ts": [90, 70],
+    "src/worker/mcp-modern-proxy.ts": [90, 70],
+    "src/worker/mcp-modern-stream.ts": [100, null],
+    "src/worker/worker-mcp-config.ts": [100, 75],
     "src/worker/mcp-resumption-config.ts": [100, 80],
     "src/worker/mcp-resumption-records.ts": [90, 65],
     "src/worker/mcp-stream-proxy.ts": [85, 55],
@@ -175,7 +204,7 @@ function collectCoverage(directory) {
       const repositoryRelative = relative(root, absolute);
       if (!repositoryRelative || repositoryRelative === ".." || repositoryRelative.startsWith(`..${sep}`) || isAbsolute(repositoryRelative)) continue;
       const file = repositoryRelative.split(sep).join("/");
-      if (!file.startsWith("src/")) continue;
+      if (!file.startsWith("src/") && !CRITICAL_SCRIPT_FILES.has(file)) continue;
       let entry = scripts.get(file);
       if (!entry) {
         entry = { functions: new Map(), blocks: new Map() };

package/scripts/foreground-daemon-recovery.mjs

@@ -0,0 +1,88 @@
+import { readFileSync, realpathSync, statSync } from "node:fs";
+import path from "node:path";
+import { inspectProcessInstance, processCommandLine, splitProcessCommandLine } from "../src/local/process-identity.mjs";
+import {
+  daemonLockPathForState, loadState, readDaemonLockOwner, resolveWorkspace, selectedWorkspace,
+} from "../src/local/state.mjs";
+
+const FOREGROUND_PID = /foreground daemon is active \(pid (\d+)\)/i;
+
+export function discoverForegroundDaemonRecovery({ output, stateRoot, workspace = "", dependencies = {} } = {}) {
+  const pid = foregroundPid(output);
+  if (!pid || typeof stateRoot !== "string" || !stateRoot) return null;
+  const selectWorkspace = dependencies.selectedWorkspace || selectedWorkspace;
+  const resolve = dependencies.resolveWorkspace || resolveWorkspace;
+  const load = dependencies.loadState || loadState;
+  const readOwner = dependencies.readDaemonOwner || readDaemonLockOwner;
+  const lockPath = dependencies.daemonLockPathForState || daemonLockPathForState;
+  const inspect = dependencies.inspectProcessInstance || inspectProcessInstance;
+  const readCommand = dependencies.processCommandLine || processCommandLine;
+  const splitCommand = dependencies.splitProcessCommandLine || splitProcessCommandLine;
+  const canonical = dependencies.realpathSync || realpathSync;
+  const fileInfo = dependencies.statSync || statSync;
+  const readFile = dependencies.readFileSync || readFileSync;
+  let targetWorkspace;
+  let canonicalStateRoot;
+  let state;
+  let owner;
+  try {
+    targetWorkspace = resolve(workspace || selectWorkspace(stateRoot));
+    canonicalStateRoot = canonical(path.resolve(stateRoot));
+    state = load(targetWorkspace, { stateDir: canonicalStateRoot });
+    owner = readOwner(lockPath(state));
+  } catch {
+    return null;
+  }
+  if (Number(owner?.pid) !== pid || owner?.mode !== "foreground" || owner?.purpose !== "daemon") return null;
+  if (inspect(owner)?.current !== true) return null;
+  if (!sameCanonical(owner.workspace, targetWorkspace, canonical)) return null;
+  let entry;
+  let argv;
+  try {
+    entry = canonical(String(owner.entryScript || ""));
+    if (!fileInfo(entry).isFile()) return null;
+    argv = splitCommand(readCommand(pid));
+  } catch {
+    return null;
+  }
+  const entryIndex = argv.findIndex(value => sameCanonical(value, entry, canonical));
+  if (entryIndex < 0 || argv[entryIndex + 1] !== "start" || argv.includes("--daemon-only")) return null;
+  const commandWorkspace = commandFlagValue(argv, "--workspace");
+  const commandStateRoot = commandFlagValue(argv, "--state-dir");
+  if (!sameCanonical(commandWorkspace, targetWorkspace, canonical)
+      || !sameCanonical(commandStateRoot, canonicalStateRoot, canonical)) return null;
+  const packageRoot = path.dirname(path.dirname(entry));
+  let pkg;
+  try {
+    pkg = JSON.parse(readFile(path.join(packageRoot, "package.json"), "utf8"));
+  } catch {
+    return null;
+  }
+  if (pkg?.name !== "machine-bridge-mcp" || pkg.version !== owner.version) return null;
+  if (!["machine-mcp", "machine-mcp.mjs"].includes(path.basename(entry))) return null;
+  return { pid, cli: entry, version: owner.version, workspace: targetWorkspace, stateRoot: canonicalStateRoot };
+}
+
+export function foregroundPid(output) {
+  const match = FOREGROUND_PID.exec(String(output || ""));
+  const pid = Number(match?.[1]);
+  return Number.isSafeInteger(pid) && pid > 0 ? pid : 0;
+}
+
+function commandFlagValue(argv, name) {
+  const exact = argv.find(value => value.startsWith(`${name}=`));
+  if (exact) return exact.slice(name.length + 1);
+  const index = argv.indexOf(name);
+  return index >= 0 && index + 1 < argv.length ? argv[index + 1] : "";
+}
+
+function sameCanonical(left, right, canonical) {
+  if (typeof left !== "string" || typeof right !== "string" || !left || !right) return false;
+  try {
+    const a = canonical(path.resolve(left));
+    const b = canonical(path.resolve(right));
+    return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+  } catch {
+    return false;
+  }
+}

package/scripts/github-release.mjs

@@ -15,14 +15,14 @@ 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 { assertOwnerTerminalPublication, withGithubPublicationLock } from "./release-publication-guard.mjs";
 import { fileURLToPath } from "node:url";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 process.chdir(root);
 
 function fail(message) {
-  console.error(`release error: ${message}`);
-  process.exit(1);
+  throw new Error(String(message || "release failed"));
 }
 
 function run(command, args, options = {}) {
@@ -304,8 +304,8 @@ function publishCurrent({ prereleaseMode = false } = {}) {
   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");
+      ? "prerelease versions must use npm run prerelease:release -- --owner-terminal-confirm"
+      : "stable versions must use npm run release -- --owner-terminal-confirm");
   }
   if (!parsedVersion.prerelease && requiresSoakForStable(pkg.version)) assertStableSoak();
   const tag = `v${pkg.version}`;
@@ -429,16 +429,22 @@ function backfillMissingReleases() {
 }
 
 const mode = process.argv[2] ?? "--check";
-if (mode === "--check") {
-  ensureClean();
-  fetchRemote();
-  assertCoreSync({ requireReleaseAsset: true });
-} else if (mode === "--publish") {
-  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|--publish-prerelease|--backfill]");
+try {
+  if (mode === "--check") {
+    ensureClean();
+    fetchRemote();
+    assertCoreSync({ requireReleaseAsset: true });
+  } else if (mode === "--publish" || mode === "--publish-prerelease" || mode === "--backfill") {
+    assertOwnerTerminalPublication();
+    await withGithubPublicationLock(root, async () => {
+      if (mode === "--publish") publishCurrent({ prereleaseMode: false });
+      else if (mode === "--publish-prerelease") publishCurrent({ prereleaseMode: true });
+      else backfillMissingReleases();
+    });
+  } else {
+    fail("usage: node scripts/github-release.mjs [--check|--publish|--publish-prerelease|--backfill] [--owner-terminal-confirm]");
+  }
+} catch (error) {
+  console.error(`release error: ${String(error?.message || error)}`);
+  process.exitCode = 1;
 }

package/scripts/install-published-prerelease.mjs

@@ -11,6 +11,7 @@ import { computePromotionContentDigest } from "./promotion-digest.mjs";
 import { readPublishedNpmPrerelease } from "./published-release.mjs";
 import { verifyCurrentReleaseAcceptance } from "./release-acceptance.mjs";
 import { assertSoakEligiblePrerelease } from "./release-channel.mjs";
+import { persistentActivationSpawnOptions } from "./persistent-activation-process.mjs";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const npmCli = process.env.npm_execpath;
@@ -103,13 +104,11 @@ function currentGlobalInstallation(packageName) {
 }
 
 function runActivation(entry, args) {
-  const result = spawnSync(process.execPath, [entry, ...args], {
-    cwd: root,
-    env: process.env,
-    encoding: "utf8",
-    timeout: 300_000,
-    windowsHide: true,
-  });
+  const result = spawnSync(
+    process.execPath,
+    [entry, ...args],
+    persistentActivationSpawnOptions({ cwd: root, env: process.env }),
+  );
   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"); }
@@ -121,6 +120,7 @@ function runNpm(args) {
     env: process.env,
     encoding: "utf8",
     timeout: 300_000,
+    killSignal: "SIGKILL",
     windowsHide: true,
   });
   if (result.error) throw result.error;

package/scripts/official-mcp-conformance.mjs

@@ -0,0 +1,243 @@
+import { createServer } from "node:http";
+import { existsSync, lstatSync, readFileSync, realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { runExecutable } from "../src/local/shell.mjs";
+
+const MAX_PROXY_REQUEST_BYTES = 16 * 1024 * 1024;
+const DEFAULT_TIMEOUT_MS = 60_000;
+
+export async function runOfficialMcpConformance(options) {
+  const checkout = validateConformanceCheckout(options.checkout);
+  const upstream = validatedUpstream(options.upstream);
+  const accessToken = boundedSecret(options.accessToken, "access token", 16 * 1024);
+  const scenario = requiredText(options.scenario, "conformance scenario");
+  const specVersion = String(options.specVersion || "2026-07-28");
+  const timeoutMs = positiveInteger(options.timeoutMs, DEFAULT_TIMEOUT_MS);
+  const proxy = await startBearerProxy({ upstream, accessToken });
+  try {
+    const npmCli = requiredText(process.env.npm_execpath, "npm_execpath");
+    const result = await runCommand({
+      command: process.execPath,
+      args: [
+        npmCli, "start", "--", "server", "--url", `${proxy.origin}/mcp`,
+        "--scenario", scenario, "--spec-version", specVersion,
+        ...(options.expectedFailures ? ["--expected-failures", String(options.expectedFailures)] : []),
+        ...(options.verbose === true ? ["--verbose"] : []),
+      ],
+      cwd: checkout,
+      timeoutMs,
+    });
+    return Object.freeze({ ...result, scenario, specVersion, proxyOrigin: proxy.origin });
+  } finally {
+    await proxy.close();
+  }
+}
+
+async function startBearerProxy({ upstream, accessToken }) {
+  const server = createServer((request, response) => {
+    void proxyRequest(request, response, upstream, accessToken);
+  });
+  await new Promise((resolve, reject) => {
+    server.once("error", reject);
+    server.listen(0, "127.0.0.1", resolve);
+  });
+  const address = server.address();
+  if (!address || typeof address === "string") throw new Error("conformance proxy did not bind a TCP port");
+  return {
+    origin: `http://127.0.0.1:${address.port}`,
+    close: () => new Promise((resolve, reject) => {
+      server.close((error) => { if (error) reject(error); else resolve(); });
+      server.closeAllConnections?.();
+    }),
+  };
+}
+
+async function proxyRequest(request, response, upstream, accessToken) {
+  const controller = new AbortController();
+  request.once("aborted", () => controller.abort());
+  response.once("close", () => { if (!response.writableEnded) controller.abort(); });
+  try {
+    const body = await readBoundedBody(request, MAX_PROXY_REQUEST_BYTES);
+    const headers = new Headers();
+    for (const [name, value] of Object.entries(request.headers)) {
+      if (value === undefined || ["host", "connection", "content-length", "transfer-encoding"].includes(name.toLowerCase())) continue;
+      if (Array.isArray(value)) for (const item of value) headers.append(name, item);
+      else headers.set(name, value);
+    }
+    headers.set("authorization", `Bearer ${accessToken}`);
+    const target = conformanceProxyTarget(request.url, upstream);
+    const upstreamResponse = await fetch(target, {
+      method: request.method,
+      headers,
+      body: body.length ? body : undefined,
+      signal: controller.signal,
+      redirect: "manual",
+    });
+    const responseHeaders = {};
+    upstreamResponse.headers.forEach((value, name) => {
+      if (!["connection", "content-encoding", "content-length", "transfer-encoding"].includes(name.toLowerCase())) responseHeaders[name] = value;
+    });
+    response.writeHead(upstreamResponse.status, responseHeaders);
+    if (!upstreamResponse.body) return response.end();
+    const reader = upstreamResponse.body.getReader();
+    try {
+      for (;;) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        if (value && !response.write(Buffer.from(value))) {
+          await new Promise((resolve) => { response.once("drain", resolve); });
+        }
+      }
+      response.end();
+    } finally {
+      reader.releaseLock();
+    }
+  } catch (error) {
+    if (controller.signal.aborted) return response.destroy();
+    if (!response.headersSent) response.writeHead(error?.code === "request_too_large" ? 413 : 502, { "content-type": "application/json" });
+    response.end(JSON.stringify({ error: "conformance_proxy_failure" }));
+  }
+}
+
+function readBoundedBody(request, maximumBytes) {
+  return new Promise((resolve, reject) => {
+    const chunks = [];
+    let bytes = 0;
+    let settled = false;
+    const finish = (callback, value) => {
+      if (settled) return;
+      settled = true;
+      request.removeListener("data", onData);
+      request.removeListener("end", onEnd);
+      request.removeListener("aborted", onAborted);
+      request.removeListener("error", onError);
+      callback(value);
+    };
+    const onData = (chunk) => {
+      bytes += chunk.length;
+      if (bytes > maximumBytes) {
+        const error = new Error("conformance proxy request is too large");
+        error.code = "request_too_large";
+        finish(reject, error);
+        request.destroy();
+        return;
+      }
+      chunks.push(chunk);
+    };
+    const onEnd = () => finish(resolve, Buffer.concat(chunks, bytes));
+    const onAborted = () => finish(reject, proxyInputError("conformance proxy request was aborted"));
+    const onError = (error) => finish(reject, error);
+    request.on("data", onData);
+    request.once("end", onEnd);
+    request.once("aborted", onAborted);
+    request.once("error", onError);
+  });
+}
+
+async function runCommand({ command, args, cwd, timeoutMs }) {
+  const result = await runExecutable(command, args, {
+    cwd,
+    env: { ...process.env, NO_COLOR: "1", CI: "1" },
+    capture: true,
+    allowFailure: true,
+    timeoutMs,
+    maxOutputBytes: 4 * 1024 * 1024,
+  });
+  return Object.freeze({ ...result, signal: null });
+}
+
+export function validateConformanceCheckout(value) {
+  const requested = resolve(requiredText(value, "conformance checkout"));
+  if (!existsSync(requested)) throw new Error("conformance checkout does not exist");
+  const requestedInfo = lstatSync(requested);
+  if (requestedInfo.isSymbolicLink() || !requestedInfo.isDirectory()) {
+    throw new Error("conformance checkout must be a real directory");
+  }
+  const checkout = realpathSync.native(requested);
+  for (const file of ["package.json", "package-lock.json"]) {
+    const path = join(checkout, file);
+    if (!existsSync(path)) throw new Error(`conformance checkout omits ${file}`);
+    const info = lstatSync(path);
+    if (info.isSymbolicLink() || !info.isFile()) throw new Error(`conformance checkout ${file} must be a regular file`);
+  }
+  let packageState;
+  try { packageState = JSON.parse(readFileSync(join(checkout, "package.json"), "utf8")); }
+  catch { throw new Error("conformance checkout package.json is invalid"); }
+  if (typeof packageState?.scripts?.start !== "string" || !packageState.scripts.start.trim()) {
+    throw new Error("conformance checkout omits its start command");
+  }
+  const nodeModules = join(checkout, "node_modules");
+  if (!existsSync(nodeModules) || !lstatSync(nodeModules).isDirectory()) {
+    throw new Error("conformance checkout dependencies are not installed; run npm ci --ignore-scripts in the checkout");
+  }
+  return checkout;
+}
+
+export function conformanceProxyTarget(requestTarget, upstream) {
+  const raw = String(requestTarget || "/mcp");
+  if (Buffer.byteLength(raw) > 8192) throw proxyInputError("conformance proxy request target is too large");
+  let parsed;
+  try { parsed = new URL(raw, "http://proxy.invalid"); }
+  catch { throw proxyInputError("conformance proxy request target is invalid"); }
+  if (parsed.origin !== "http://proxy.invalid" || parsed.hash) {
+    throw proxyInputError("conformance proxy requires a relative request target");
+  }
+  if (parsed.pathname !== "/mcp") throw proxyInputError("conformance proxy accepts only its MCP endpoint");
+  const target = new URL(upstream.href);
+  if (parsed.search) target.search = parsed.search;
+  return target;
+}
+
+function validatedUpstream(value) {
+  let upstream;
+  try { upstream = new URL(requiredText(value, "upstream MCP URL")); }
+  catch { throw new Error("upstream MCP URL is invalid"); }
+  if (upstream.username || upstream.password || upstream.hash) throw new Error("upstream MCP URL must not contain credentials or a fragment");
+  const loopback = upstream.hostname === "localhost" || upstream.hostname === "127.0.0.1" || upstream.hostname === "[::1]";
+  if (upstream.protocol !== "https:" && !(upstream.protocol === "http:" && loopback)) {
+    throw new Error("upstream MCP URL must use HTTPS or loopback HTTP");
+  }
+  return upstream;
+}
+
+function boundedSecret(value, label, maximumBytes) {
+  const text = requiredText(value, label);
+  if (Buffer.byteLength(text) > maximumBytes) throw new Error(`${label} is too large`);
+  return text;
+}
+
+function proxyInputError(message) {
+  const error = new Error(message);
+  error.code = "invalid_proxy_input";
+  return error;
+}
+
+function requiredText(value, label) {
+  const text = String(value || "").trim();
+  if (!text) throw new Error(`${label} is required`);
+  return text;
+}
+
+function positiveInteger(value, fallback) {
+  const number = Number(value);
+  return Number.isInteger(number) && number > 0 ? number : fallback;
+}
+
+async function main() {
+  const result = await runOfficialMcpConformance({
+    checkout: process.env.MBM_OFFICIAL_CONFORMANCE_CHECKOUT,
+    upstream: process.env.MBM_OFFICIAL_CONFORMANCE_UPSTREAM,
+    accessToken: process.env.MBM_OFFICIAL_CONFORMANCE_ACCESS_TOKEN,
+    scenario: process.env.MBM_OFFICIAL_CONFORMANCE_SCENARIO,
+    specVersion: process.env.MBM_OFFICIAL_CONFORMANCE_SPEC_VERSION || "2026-07-28",
+    timeoutMs: process.env.MBM_OFFICIAL_CONFORMANCE_TIMEOUT_MS,
+    verbose: process.env.MBM_OFFICIAL_CONFORMANCE_VERBOSE === "1",
+    expectedFailures: process.env.MBM_OFFICIAL_CONFORMANCE_BASELINE,
+  });
+  process.stdout.write(result.stdout);
+  process.stderr.write(result.stderr);
+  process.exitCode = result.code;
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] || "").href) await main();

package/scripts/persistent-activation-process.mjs

@@ -0,0 +1,36 @@
+export function persistentActivationSpawnOptions({ cwd, env = process.env } = {}) {
+  if (typeof cwd !== "string" || !cwd) {
+    throw new TypeError("persistent activation subprocess requires cwd");
+  }
+  if (!env || typeof env !== "object" || Array.isArray(env)) {
+    throw new TypeError("persistent activation subprocess requires an environment record");
+  }
+  // The activation child owns bounded deployment, network, relay, and service
+  // stages plus transactional cleanup. An outer timeout could SIGKILL the child
+  // while detached helpers remain alive and before compensation releases locks.
+  return { cwd, env, encoding: "utf8", windowsHide: true };
+}
+
+export function persistentCandidateFailureMessage(output, { cli, stateRoot, previousRuntime = null } = {}) {
+  const detail = String(output || "").trim() || "activation subprocess exited unsuccessfully";
+  if (!/foreground daemon is active/i.test(detail)) return `persistent candidate activation failed: ${detail}`;
+  const quotedCli = JSON.stringify(String(cli || "machine-mcp"));
+  const quotedStateRoot = JSON.stringify(String(stateRoot || ""));
+  const recovery = previousRuntime?.cli && previousRuntime?.pid
+    ? [
+      `Verified foreground runtime: ${previousRuntime.version || "unknown"} (pid ${previousRuntime.pid}).`,
+      "Stop that foreground daemon, then restore its existing login service with:",
+      `node ${JSON.stringify(previousRuntime.cli)} service start`,
+      `node ${quotedCli} service status --workspace ${JSON.stringify(previousRuntime.workspace)} --state-dir ${quotedStateRoot}`,
+      "Retry candidate activation only after status reports provider active and a verified service daemon for that workspace.",
+    ]
+    : [
+      "The foreground runtime could not be independently resolved to a trusted installed CLI.",
+      "Keep it running and inspect its daemon lock and command line before attempting a manual service recovery.",
+    ];
+  return [
+    `persistent candidate activation failed: ${detail}`,
+    "No Worker deployment or service replacement was started.",
+    ...recovery,
+  ].join("\n");
+}

package/scripts/release-candidate-manifest.mjs

@@ -38,3 +38,15 @@ export function validateCandidateManifest(value, expected = {}) {
     prepared_at: new Date(preparedAt).toISOString(),
   });
 }
+
+export function assertCandidateMatchesCurrentSource(manifest, current) {
+  const packageName = String(current?.packageName || "");
+  const packageVersion = String(current?.packageVersion || "");
+  const promotionDigest = String(current?.promotionDigest || "");
+  if (manifest.package_name !== packageName || manifest.package_version !== packageVersion) {
+    throw new Error("release candidate is stale: package identity no longer matches the current source");
+  }
+  if (!/^[0-9a-f]{64}$/.test(promotionDigest) || manifest.promotion_content_sha256 !== promotionDigest) {
+    throw new Error("release candidate is stale: promotion content digest no longer matches the current source");
+  }
+}

package/scripts/release-publication-guard.mjs

@@ -0,0 +1,65 @@
+import { spawnSync } from "node:child_process";
+import { realpathSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { withOwnerStateLock } from "../src/local/owner-state-lock.mjs";
+
+const CONFIRMATION_FLAG = "--owner-terminal-confirm";
+const LOCK_DIRECTORY = "machine-bridge-release-state";
+const LOCK_FILE = "github-publication.lock";
+const GIT_METADATA_TIMEOUT_MS = 30_000;
+
+export function assertOwnerTerminalPublication(options = {}) {
+  let argv = process.argv.slice(2);
+  if (Array.isArray(options.argv)) argv = options.argv.map(String);
+  const stdin = options.stdin === undefined ? process.stdin : options.stdin;
+  const stdout = options.stdout === undefined ? process.stdout : options.stdout;
+  const stderr = options.stderr === undefined ? process.stderr : options.stderr;
+  if (!argv.includes(CONFIRMATION_FLAG)) {
+    throw new Error(`GitHub publication requires an explicit owner terminal invocation with ${CONFIRMATION_FLAG}`);
+  }
+  if (stdin.isTTY !== true || stdout.isTTY !== true || stderr.isTTY !== true) {
+    throw new Error("GitHub publication requires an interactive owner terminal; background jobs, MCP calls, CI, and redirected sessions are not accepted");
+  }
+  return Object.freeze({ confirmation_flag: CONFIRMATION_FLAG, interactive_terminal: true });
+}
+
+export function withGithubPublicationLock(root, callback, options = {}) {
+  const stateRoot = options.stateRoot
+    ? resolve(String(options.stateRoot))
+    : resolveGithubPublicationStateRoot(root);
+  return withOwnerStateLock(stateRoot, callback, {
+    purpose: "github-publication",
+    fileName: LOCK_FILE,
+    label: "GitHub publication",
+    timeoutMs: options.timeoutMs ?? 1_000,
+    pollMs: options.pollMs ?? 25,
+    maxAgeMs: options.maxAgeMs ?? 6 * 60 * 60 * 1_000,
+  });
+}
+
+export function resolveGithubPublicationStateRoot(root) {
+  const repositoryRoot = resolve(String(root || ""));
+  const result = spawnSync("git", ["rev-parse", "--git-common-dir"], {
+    cwd: repositoryRoot,
+    encoding: "utf8",
+    timeout: GIT_METADATA_TIMEOUT_MS,
+    killSignal: "SIGKILL",
+    windowsHide: true,
+  });
+  return githubPublicationStateRootFromGitResult(repositoryRoot, result);
+}
+
+export function githubPublicationStateRootFromGitResult(repositoryRoot, result) {
+  if (result?.error || result?.status !== 0) throw new Error("could not resolve the common Git publication state directory");
+  const path = String(result?.stdout ?? "").trim();
+  if (!path || path.includes("\0")) throw new Error("Git returned an invalid common publication state directory");
+  const commonDirectory = resolve(repositoryRoot, path);
+  try {
+    return join(realpathSync.native(commonDirectory), LOCK_DIRECTORY);
+  } catch {
+    throw new Error("common Git publication state directory is unavailable");
+  }
+}
+
+export const githubPublicationConfirmationFlag = CONFIRMATION_FLAG;
+export const githubPublicationGitTimeoutMs = GIT_METADATA_TIMEOUT_MS;

package/scripts/release-state.mjs

@@ -1,7 +1,7 @@
 export function tagSyncError({ scope = "local", tag, head, commit }) {
   const label = scope === "remote" ? "remote tag" : "local tag";
   if (!commit) {
-    return `${label} ${tag} is missing; run npm run release before npm publish`;
+    return `${label} ${tag} is missing; run the applicable owner-terminal GitHub release command with --owner-terminal-confirm before npm publish`;
   }
   if (commit !== head) {
     return `${label} ${tag} points to ${commit}, not HEAD ${head}`;