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

package/native/macos/MachineBridgeTrustBroker.swift

@@ -0,0 +1,233 @@
+import Foundation
+import Security
+import LocalAuthentication
+
+private enum BrokerError: Error, CustomStringConvertible {
+    case usage(String)
+    case security(OSStatus, String)
+    case invalidKey(String)
+    case invalidInput(String)
+
+    var description: String {
+        switch self {
+        case .usage(let value), .invalidKey(let value), .invalidInput(let value): return value
+        case .security(let status, let operation):
+            let text = SecCopyErrorMessageString(status, nil) as String? ?? "OSStatus \(status)"
+            return "\(operation) failed: \(text)"
+        }
+    }
+}
+
+private struct Output: Encodable {
+    let ok: Bool
+    let provider: String
+    let keyTag: String
+    let publicJwk: PublicJwk?
+    let signature: String?
+    let secureEnclave: Bool
+}
+
+private struct PublicJwk: Codable {
+    let kty: String
+    let crv: String
+    let x: String
+    let y: String
+}
+
+private let providerName = "macos-secure-enclave-v1"
+
+@main
+private struct MachineBridgeTrustBroker {
+    static func main() {
+        do {
+            let arguments = CommandLine.arguments
+            guard arguments.count >= 4, arguments[2] == "--tag" else {
+                throw BrokerError.usage("usage: machine-bridge-trust-broker <ensure|public|sign|delete|status> --tag <tag> [--reason <text>]")
+            }
+            let action = arguments[1]
+            let tag = arguments[3]
+            guard tag.range(of: #"^[A-Za-z0-9._-]{8,180}$"#, options: .regularExpression) != nil else {
+                throw BrokerError.invalidInput("key tag is invalid")
+            }
+            let reason = option("--reason", in: arguments) ?? "Authorize Machine Bridge startup"
+            let result: Output
+            switch action {
+            case "ensure":
+                let key = try ensurePrivateKey(tag: tag)
+                result = try output(tag: tag, key: key, signature: nil)
+            case "public":
+                let key = try loadPrivateKey(tag: tag, prompt: nil, allowInteraction: false)
+                result = try output(tag: tag, key: key, signature: nil)
+            case "status":
+                let key = try? loadPrivateKey(tag: tag, prompt: nil, allowInteraction: false)
+                if let key {
+                    result = try output(tag: tag, key: key, signature: nil)
+                } else {
+                    result = Output(ok: false, provider: providerName, keyTag: tag, publicJwk: nil, signature: nil, secureEnclave: secureEnclaveAvailable())
+                }
+            case "sign":
+                let data = FileHandle.standardInput.readDataToEndOfFile()
+                guard !data.isEmpty, data.count <= 64 * 1024 else { throw BrokerError.invalidInput("signing input is empty or too large") }
+                guard String(data: data, encoding: .utf8) != nil else { throw BrokerError.invalidInput("signing input is not UTF-8") }
+                let key = try loadPrivateKey(tag: tag, prompt: reason, allowInteraction: true)
+                var error: Unmanaged<CFError>?
+                guard let der = SecKeyCreateSignature(key, .ecdsaSignatureMessageX962SHA256, data as CFData, &error) as Data? else {
+                    throw error?.takeRetainedValue() ?? BrokerError.invalidKey("Secure Enclave signing failed")
+                }
+                let raw = try derToP1363(der)
+                result = try output(tag: tag, key: key, signature: raw.base64URLEncodedString())
+            case "delete":
+                let status = SecItemDelete(keyQuery(tag: tag, returnRef: false, allowInteraction: false, prompt: nil) as CFDictionary)
+                guard status == errSecSuccess || status == errSecItemNotFound else { throw BrokerError.security(status, "delete key") }
+                result = Output(ok: true, provider: providerName, keyTag: tag, publicJwk: nil, signature: nil, secureEnclave: secureEnclaveAvailable())
+            default:
+                throw BrokerError.usage("unknown action: \(action)")
+            }
+            try emit(result)
+        } catch {
+            let message = String(describing: error)
+            FileHandle.standardError.write(Data("machine-bridge-trust-broker: \(message)\n".utf8))
+            exit(1)
+        }
+    }
+}
+
+private func ensurePrivateKey(tag: String) throws -> SecKey {
+    if let existing = try? loadPrivateKey(tag: tag, prompt: nil, allowInteraction: false) { return existing }
+    guard secureEnclaveAvailable() else { throw BrokerError.invalidKey("Secure Enclave is unavailable") }
+    var accessError: Unmanaged<CFError>?
+    guard let access = SecAccessControlCreateWithFlags(
+        nil,
+        kSecAttrAccessibleWhenUnlockedThisDeviceOnly,
+        [.privateKeyUsage, .userPresence],
+        &accessError
+    ) else {
+        throw accessError?.takeRetainedValue() ?? BrokerError.invalidKey("could not create Secure Enclave access control")
+    }
+    let privateAttributes: [String: Any] = [
+        kSecAttrIsPermanent as String: true,
+        kSecAttrApplicationTag as String: Data(tag.utf8),
+        kSecAttrAccessControl as String: access,
+    ]
+    let attributes: [String: Any] = [
+        kSecAttrKeyType as String: kSecAttrKeyTypeECSECPrimeRandom,
+        kSecAttrKeySizeInBits as String: 256,
+        kSecAttrTokenID as String: kSecAttrTokenIDSecureEnclave,
+        kSecPrivateKeyAttrs as String: privateAttributes,
+    ]
+    var keyError: Unmanaged<CFError>?
+    guard let key = SecKeyCreateRandomKey(attributes as CFDictionary, &keyError) else {
+        throw keyError?.takeRetainedValue() ?? BrokerError.invalidKey("could not create Secure Enclave key")
+    }
+    return key
+}
+
+private func loadPrivateKey(tag: String, prompt: String?, allowInteraction: Bool) throws -> SecKey {
+    let query = keyQuery(tag: tag, returnRef: true, allowInteraction: allowInteraction, prompt: prompt)
+    var result: CFTypeRef?
+    let status = SecItemCopyMatching(query as CFDictionary, &result)
+    guard status == errSecSuccess, let key = result as! SecKey? else { throw BrokerError.security(status, "load Secure Enclave key") }
+    return key
+}
+
+private func keyQuery(tag: String, returnRef: Bool, allowInteraction: Bool, prompt: String?) -> [String: Any] {
+    var query: [String: Any] = [
+        kSecClass as String: kSecClassKey,
+        kSecAttrKeyType as String: kSecAttrKeyTypeECSECPrimeRandom,
+        kSecAttrApplicationTag as String: Data(tag.utf8),
+        kSecReturnRef as String: returnRef,
+        kSecMatchLimit as String: kSecMatchLimitOne,
+    ]
+    let context = LAContext()
+    if allowInteraction {
+        context.localizedReason = prompt ?? "Authorize Machine Bridge startup"
+    } else {
+        context.interactionNotAllowed = true
+    }
+    query[kSecUseAuthenticationContext as String] = context
+    return query
+}
+
+private func output(tag: String, key: SecKey, signature: String?) throws -> Output {
+    guard let publicKey = SecKeyCopyPublicKey(key) else { throw BrokerError.invalidKey("public key is unavailable") }
+    var error: Unmanaged<CFError>?
+    guard let external = SecKeyCopyExternalRepresentation(publicKey, &error) as Data? else {
+        throw error?.takeRetainedValue() ?? BrokerError.invalidKey("public key export failed")
+    }
+    guard external.count == 65, external.first == 0x04 else { throw BrokerError.invalidKey("public key representation is invalid") }
+    let x = external.subdata(in: 1..<33).base64URLEncodedString()
+    let y = external.subdata(in: 33..<65).base64URLEncodedString()
+    return Output(
+        ok: true,
+        provider: providerName,
+        keyTag: tag,
+        publicJwk: PublicJwk(kty: "EC", crv: "P-256", x: x, y: y),
+        signature: signature,
+        secureEnclave: true
+    )
+}
+
+private func secureEnclaveAvailable() -> Bool {
+    let attributes: [String: Any] = [
+        kSecAttrKeyType as String: kSecAttrKeyTypeECSECPrimeRandom,
+        kSecAttrKeySizeInBits as String: 256,
+        kSecAttrTokenID as String: kSecAttrTokenIDSecureEnclave,
+        kSecPrivateKeyAttrs as String: [kSecAttrIsPermanent as String: false],
+    ]
+    var error: Unmanaged<CFError>?
+    return SecKeyCreateRandomKey(attributes as CFDictionary, &error) != nil
+}
+
+private func derToP1363(_ data: Data) throws -> Data {
+    var index = 0
+    func readByte() throws -> UInt8 {
+        guard index < data.count else { throw BrokerError.invalidInput("ECDSA signature is truncated") }
+        defer { index += 1 }
+        return data[index]
+    }
+    func readLength() throws -> Int {
+        let first = try readByte()
+        if first < 0x80 { return Int(first) }
+        let count = Int(first & 0x7f)
+        guard count > 0, count <= 2 else { throw BrokerError.invalidInput("ECDSA signature length is invalid") }
+        var length = 0
+        for _ in 0..<count { length = (length << 8) | Int(try readByte()) }
+        return length
+    }
+    guard try readByte() == 0x30 else { throw BrokerError.invalidInput("ECDSA signature sequence is invalid") }
+    let sequenceLength = try readLength()
+    guard sequenceLength == data.count - index else { throw BrokerError.invalidInput("ECDSA signature sequence length is invalid") }
+    func readInteger() throws -> Data {
+        guard try readByte() == 0x02 else { throw BrokerError.invalidInput("ECDSA signature integer is invalid") }
+        let length = try readLength()
+        guard length > 0, index + length <= data.count else { throw BrokerError.invalidInput("ECDSA signature integer is truncated") }
+        var value = data.subdata(in: index..<(index + length))
+        index += length
+        while value.count > 32, value.first == 0 { value.removeFirst() }
+        guard value.count <= 32 else { throw BrokerError.invalidInput("ECDSA signature integer is too large") }
+        if value.count < 32 { value = Data(repeating: 0, count: 32 - value.count) + value }
+        return value
+    }
+    let r = try readInteger()
+    let s = try readInteger()
+    guard index == data.count else { throw BrokerError.invalidInput("ECDSA signature has trailing bytes") }
+    return r + s
+}
+
+private func option(_ name: String, in arguments: [String]) -> String? {
+    guard let index = arguments.firstIndex(of: name), index + 1 < arguments.count else { return nil }
+    return arguments[index + 1]
+}
+
+private func emit<T: Encodable>(_ value: T) throws {
+    let encoder = JSONEncoder()
+    encoder.outputFormatting = [.sortedKeys]
+    FileHandle.standardOutput.write(try encoder.encode(value))
+    FileHandle.standardOutput.write(Data("\n".utf8))
+}
+
+private extension Data {
+    func base64URLEncodedString() -> String {
+        base64EncodedString().replacingOccurrences(of: "+", with: "-").replacingOccurrences(of: "/", with: "_").replacingOccurrences(of: "=", with: "")
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "machine-bridge-mcp",
-  "version": "2.0.0",
+  "version": "3.0.0-beta.9",
   "description": "Cross-client MCP bridge for local agent context, structured browser and application automation, files, Git, processes, resources, and durable jobs over stdio or OAuth relay.",
   "type": "module",
   "license": "MIT",
@@ -22,6 +22,7 @@
     "src/shared",
     "src/worker",
     "scripts",
+    "native",
     "wrangler.jsonc",
     "tsconfig.json",
     "tsconfig.local.json",
@@ -43,7 +44,7 @@
     "version:check": "node scripts/sync-worker-version.mjs --check",
     "version": "node scripts/sync-worker-version.mjs && git add package.json package-lock.json src/worker/index.ts browser-extension/manifest.json",
     "prepack": "npm run version:check && npm run privacy:check && npm run release-impact:check",
-    "prepublishOnly": "npm run check && npm run version:check && npm run release:check",
+    "prepublishOnly": "npm run publication:check && npm run check && npm run version:check && npm run release:check",
     "worker:types": "node scripts/generate-worker-types.mjs",
     "typecheck": "npm run worker:types && tsc -p tsconfig.json --noEmit && npm run typecheck:local",
     "syntax": "node scripts/syntax-check.mjs",
@@ -135,7 +136,34 @@
     "github-backlog:test": "node tests/github-backlog-test.mjs",
     "github:backlog": "node scripts/github-backlog.mjs",
     "operation-authorization:test": "node tests/operation-authorization-test.mjs",
-    "device-auth:test": "node tests/device-auth-test.mjs"
+    "device-auth:test": "node tests/device-auth-test.mjs",
+    "device-root-provider:test": "node tests/device-root-provider-test.mjs",
+    "security-audit:test": "node tests/security-audit-log-test.mjs",
+    "delegated-sandbox:test": "node tests/delegated-process-sandbox-test.mjs",
+    "dpop:test": "node tests/dpop-test.mjs",
+    "macos-trust:test": "node tests/macos-trust-broker-test.mjs",
+    "worker-security:test": "node tests/worker-security-boundaries-test.mjs",
+    "publication:check": "node scripts/npm-publication-policy.mjs",
+    "prerelease:release": "node scripts/github-release.mjs --publish-prerelease",
+    "release:candidate:activate": "node scripts/start-release-candidate.mjs --activate-service",
+    "prerelease:install": "node scripts/install-published-prerelease.mjs",
+    "prerelease:soak:accept": "node scripts/release-soak.mjs --record",
+    "release:soak:verify": "node scripts/release-soak.mjs --verify",
+    "release-channel:test": "node tests/release-channel-test.mjs",
+    "promotion-digest:test": "node tests/promotion-digest-test.mjs",
+    "prerelease-activation:test": "node tests/prerelease-activation-test.mjs",
+    "release-soak:test": "node tests/release-soak-test.mjs",
+    "published-release:test": "node tests/published-release-test.mjs",
+    "npm-publication-policy:test": "node tests/npm-publication-policy-test.mjs",
+    "runtime-activation:test": "node tests/runtime-activation-test.mjs",
+    "prerelease:publish": "node scripts/publish-npm.mjs prerelease",
+    "stable:publish": "node scripts/publish-npm.mjs stable",
+    "publish-npm:test": "node tests/publish-npm-test.mjs",
+    "release-candidate-manifest:test": "node tests/release-candidate-manifest-test.mjs",
+    "device-key-id-compatibility:test": "node tests/device-key-id-compatibility-test.mjs",
+    "candidate-runtime-store:test": "node tests/candidate-runtime-store-test.mjs",
+    "service-restart:test": "node tests/service-restart-handoff-test.mjs",
+    "browser-identity:test": "node tests/browser-extension-identity-test.mjs"
   },
   "dependencies": {
     "https-proxy-agent": "9.1.0",
@@ -178,9 +206,9 @@
   "homepage": "https://github.com/YuLeiFuYun/machine-bridge-mcp#readme",
   "allowScripts": {
     "esbuild@0.28.1": true,
-    "sharp@0.34.5": true,
     "fsevents": false,
-    "workerd@1.20260714.1": true
+    "workerd@1.20260714.1": true,
+    "sharp@0.35.3": true
   },
   "packageManager": "npm@12.0.1",
   "devEngines": {
@@ -194,5 +222,8 @@
       "version": ">=12.0.0",
       "onFail": "error"
     }
+  },
+  "overrides": {
+    "sharp": "0.35.3"
   }
 }

package/scripts/candidate-runtime-store.mjs

@@ -0,0 +1,38 @@
+import { randomBytes } from "node:crypto";
+import { existsSync, readdirSync, rmSync } from "node:fs";
+import { isAbsolute, join, relative, resolve, sep } from "node:path";
+import { parseReleaseVersion } from "./release-channel.mjs";
+
+const RUNTIME_DIRECTORY_PATTERN = /^v[0-9A-Za-z.-]+-[0-9a-f]{12}-[0-9a-f]{12}$/;
+
+export function candidateRuntimeContainer(stateRoot) {
+  return resolve(stateRoot, "release-channels", "runtimes");
+}
+
+export function createCandidateRuntimePrefix({ stateRoot, version, shasum, random = () => randomBytes(6).toString("hex") }) {
+  const parsed = parseReleaseVersion(version);
+  const digest = String(shasum || "");
+  if (!/^[0-9a-f]{40}$/.test(digest)) throw new Error("candidate runtime package SHA-1 is invalid");
+  const suffix = String(random());
+  if (!/^[0-9a-f]{12}$/.test(suffix)) throw new Error("candidate runtime random suffix is invalid");
+  return join(candidateRuntimeContainer(stateRoot), `v${parsed.raw}-${digest.slice(0, 12)}-${suffix}`);
+}
+
+export function pruneInactiveCandidateRuntimes({ stateRoot, activePrefix, remove = rmSync } = {}) {
+  const container = candidateRuntimeContainer(stateRoot);
+  const active = resolve(String(activePrefix || ""));
+  const activeRelative = relative(container, active);
+  if (!activeRelative || activeRelative === ".." || activeRelative.startsWith(`..${sep}`) || isAbsolute(activeRelative)) {
+    throw new Error("active candidate runtime is outside the runtime container");
+  }
+  if (!existsSync(container)) return [];
+  const removed = [];
+  for (const entry of readdirSync(container, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !RUNTIME_DIRECTORY_PATTERN.test(entry.name)) continue;
+    const candidate = resolve(container, entry.name);
+    if (candidate === active) continue;
+    remove(candidate, { recursive: true, force: true });
+    removed.push(candidate);
+  }
+  return removed;
+}

package/scripts/check-plan.mjs

@@ -2,6 +2,16 @@ export const FAST_CHECK_TASKS = Object.freeze([
   "privacy:check",
   "release-impact:check",
   "release:acceptance:test",
+  "release-channel:test",
+  "release-candidate-manifest:test",
+  "promotion-digest:test",
+  "prerelease-activation:test",
+  "release-soak:test",
+  "published-release:test",
+  "npm-publication-policy:test",
+  "publish-npm:test",
+  "runtime-activation:test",
+  "candidate-runtime-store:test",
   "release-state:test",
   "release-ci:test",
   "network-retry:test",
@@ -11,6 +21,10 @@ export const FAST_CHECK_TASKS = Object.freeze([
   "secure-file:test",
   "worker-secret-file:test",
   "device-auth:test",
+  "device-root-provider:test",
+  "device-key-id-compatibility:test",
+  "dpop:test",
+  "security-audit:test",
   "sarif-security:test",
   "shell:test",
   "architecture:test",
@@ -24,6 +38,7 @@ export const FAST_CHECK_TASKS = Object.freeze([
   "account:test",
   "operation-authorization:test",
   "worker-oauth-controller:test",
+  "worker-security:test",
   "policy-docs:check",
   "tool-docs:check",
   "runtime-infrastructure:test",
@@ -31,6 +46,7 @@ export const FAST_CHECK_TASKS = Object.freeze([
   "runtime-handlers:test",
   "cli-entrypoint:test",
   "cli-service:test",
+  "service-restart:test",
   "lifecycle:test",
   "logging-structure:test",
   "worker-runtime-infrastructure:test",
@@ -42,6 +58,7 @@ export const FAST_CHECK_TASKS = Object.freeze([
   "catalog:test",
   "capability-ranking:test",
   "agent-boundaries:test",
+  "browser-identity:test",
   "browser-command:test",
   "check-plan:test",
 ]);
@@ -56,6 +73,8 @@ export const PLATFORM_ONLY_CHECK_TASKS = Object.freeze([
   "service-lifecycle:test",
   "service-environment:test",
   "service-platform:test",
+  "delegated-sandbox:test",
+  "macos-trust:test",
   "agent-context:test",
   "browser-devtools-input:test",
   "browser-service-worker:test",

package/scripts/check-runner.mjs

@@ -46,7 +46,10 @@ function runTask({ task, npmCli, cwd, env, verbose, spawnProcess }) {
     try {
       child = spawnProcess(process.execPath, [npmCli, "run", "--silent", task], {
         cwd,
-        env: { ...env, NO_COLOR: env.NO_COLOR || "1" },
+        env: {
+          ...env,
+          NO_COLOR: env.NO_COLOR || "1",
+        },
         stdio: verbose ? "inherit" : ["ignore", "pipe", "pipe"],
         windowsHide: true,
         shell: false,

package/scripts/commit-message-check.mjs

@@ -1,5 +1,8 @@
 import { execFileSync } from "node:child_process";
 import process from "node:process";
+import { createTrustedGitResolver } from "../src/local/trusted-git-executable.mjs";
+
+const gitExecutable = createTrustedGitResolver({ workspace: process.cwd() });
 
 const allowedTypes = Object.freeze([
   "feat",
@@ -54,10 +57,10 @@ function readTitles(args) {
   if (rangeIndex !== -1) {
     const range = args[rangeIndex + 1];
     if (!range) throw new Error("--range requires a Git revision range");
-    return execFileSync("git", ["log", "--format=%s", range], { encoding: "utf8" })
+    return execFileSync(gitExecutable(), ["log", "--format=%s", range], { encoding: "utf8" })
       .split(/\r?\n/)
       .filter(Boolean);
   }
 
-  return [execFileSync("git", ["log", "-1", "--format=%s"], { encoding: "utf8" }).trim()];
+  return [execFileSync(gitExecutable(), ["log", "-1", "--format=%s"], { encoding: "utf8" }).trim()];
 }

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]");
 }