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

package/scripts/sbom-check.mjs

@@ -0,0 +1,99 @@
+import { spawnSync } from "node:child_process";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import packageJson from "../package.json" with { type: "json" };
+
+const MAX_SBOM_BYTES = 4 * 1024 * 1024;
+const SBOM_TIMEOUT_MS = 30_000;
+const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
+
+export function generateAndValidateSbom(options = {}) {
+  const npmCli = String(options.npmCli || process.env.npm_execpath || "").trim();
+  if (!npmCli) throw new Error("sbom check must run through an npm lifecycle so npm_execpath is available");
+  const cwd = resolve(options.cwd || root);
+  const result = spawnSync(process.execPath, [npmCli, "sbom", "--sbom-format", "cyclonedx"], {
+    cwd,
+    env: options.env || process.env,
+    encoding: "utf8",
+    maxBuffer: MAX_SBOM_BYTES,
+    timeout: SBOM_TIMEOUT_MS,
+    killSignal: "SIGKILL",
+    windowsHide: true,
+  });
+  if (result.error) throw result.error;
+  if (result.status !== 0) throw new Error(`npm sbom failed: ${boundedText(result.stderr || result.stdout)}`);
+  if (Buffer.byteLength(result.stdout) > MAX_SBOM_BYTES) throw new Error("npm sbom output exceeds the fixed byte budget");
+  let document;
+  try { document = JSON.parse(result.stdout); }
+  catch { throw new Error("npm sbom did not return valid JSON"); }
+  return validateCycloneDxSbom(document, {
+    packageName: options.packageName || packageJson.name,
+    packageVersion: options.packageVersion || packageJson.version,
+    forbiddenPaths: options.forbiddenPaths || [cwd, homedir()],
+  });
+}
+
+export function validateCycloneDxSbom(document, options = {}) {
+  if (!isRecord(document)) throw new Error("SBOM root must be an object");
+  if (document.bomFormat !== "CycloneDX" || document.specVersion !== "1.5") {
+    throw new Error("SBOM must be CycloneDX 1.5");
+  }
+  const component = isRecord(document.metadata) && isRecord(document.metadata.component)
+    ? document.metadata.component
+    : null;
+  const packageName = String(options.packageName || "");
+  const packageVersion = String(options.packageVersion || "");
+  if (!component || component.name !== packageName || component.version !== packageVersion) {
+    throw new Error("SBOM metadata component does not match the current package identity");
+  }
+  if (!Array.isArray(document.components) || document.components.length < 1 || document.components.length > 10_000) {
+    throw new Error("SBOM components must be a non-empty bounded array");
+  }
+  if (!Array.isArray(document.dependencies) || document.dependencies.length < 1 || document.dependencies.length > 20_000) {
+    throw new Error("SBOM dependencies must be a non-empty bounded array");
+  }
+  const references = new Set();
+  for (const item of document.components) {
+    if (!isRecord(item) || typeof item["bom-ref"] !== "string" || !item["bom-ref"]
+        || typeof item.name !== "string" || !item.name || typeof item.version !== "string" || !item.version) {
+      throw new Error("SBOM contains an invalid component record");
+    }
+    if (references.has(item["bom-ref"])) throw new Error("SBOM contains duplicate component references");
+    references.add(item["bom-ref"]);
+  }
+  const rootReference = String(component["bom-ref"] || "");
+  if (!rootReference || !document.dependencies.some((entry) => isRecord(entry)
+      && entry.ref === rootReference && Array.isArray(entry.dependsOn))) {
+    throw new Error("SBOM dependency graph omits the root package");
+  }
+  const serialized = JSON.stringify(document);
+  for (const path of options.forbiddenPaths || []) {
+    const candidate = String(path || "");
+    if (candidate && candidate.length >= 2 && serialized.includes(candidate)) {
+      throw new Error("SBOM contains a local filesystem path");
+    }
+  }
+  return Object.freeze({
+    bom_format: document.bomFormat,
+    spec_version: document.specVersion,
+    package: `${packageName}@${packageVersion}`,
+    components: document.components.length,
+    dependencies: document.dependencies.length,
+  });
+}
+
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+
+function boundedText(value) {
+  return String(value || "").replace(/[\r\n]+/g, " ").slice(0, 1000);
+}
+
+async function main() {
+  const summary = generateAndValidateSbom();
+  process.stdout.write(`CycloneDX SBOM validated (${summary.components} components, ${summary.dependencies} dependencies)\n`);
+}
+
+if (import.meta.url === pathToFileURL(process.argv[1] || "").href) await main();

package/scripts/start-release-candidate.mjs

@@ -5,13 +5,16 @@ import { createHash } from "node:crypto";
 import { existsSync, readFileSync, rmSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
-import { defaultStateRoot, expandHome } from "../src/local/state.mjs";
+import { defaultStateRoot, expandHome, selectedWorkspace } from "../src/local/state.mjs";
 import { ensureOwnerOnlyDirectorySync } from "../src/local/secure-file.mjs";
 import { createCandidateRuntimePrefix, pruneInactiveCandidateRuntimes } from "./candidate-runtime-store.mjs";
 import { writePrereleaseActivation } from "./prerelease-activation.mjs";
 import { verifyTarball } from "./release-acceptance.mjs";
 import { parseReleaseVersion } from "./release-channel.mjs";
-import { validateCandidateManifest } from "./release-candidate-manifest.mjs";
+import { discoverForegroundDaemonRecovery } from "./foreground-daemon-recovery.mjs";
+import { persistentActivationSpawnOptions, persistentCandidateFailureMessage } from "./persistent-activation-process.mjs";
+import { assertCandidateMatchesCurrentSource, validateCandidateManifest } from "./release-candidate-manifest.mjs";
+import { computePromotionContentDigest } from "./promotion-digest.mjs";
 
 const root = resolve(dirname(fileURLToPath(import.meta.url)), "..");
 const candidateDirectory = join(root, ".release-candidate");
@@ -22,9 +25,17 @@ const npmCli = process.env.npm_execpath;
 if (!npmCli) fail("candidate startup must run through npm so npm_execpath is available");
 
 try {
-  const manifest = readJson(manifestPath, "release candidate manifest");
-  validateCandidateManifest(manifest);
-  const tarball = join(candidateDirectory, String(manifest.filename || ""));
+  const currentPackage = readJson(join(root, "package.json"), "current package");
+  const manifest = validateCandidateManifest(
+    readJson(manifestPath, "release candidate manifest"),
+    { packageName: currentPackage.name, packageVersion: currentPackage.version },
+  );
+  assertCandidateMatchesCurrentSource(manifest, {
+    packageName: currentPackage.name,
+    packageVersion: currentPackage.version,
+    promotionDigest: computePromotionContentDigest(root, { npmCli }),
+  });
+  const tarball = join(candidateDirectory, manifest.filename);
   verifyTarball(tarball, manifest);
 
   const npmVersion = runNpm(["--version"], root).stdout.trim();
@@ -111,15 +122,21 @@ function activatePersistentCandidate({ manifest, installedPackage, installPrefix
   const args = ["activate", ...withoutManagedFlags(forwardedArgs), "--state-dir", stateRoot, "--json"];
   const previous = currentGlobalInstallation(manifest.package_name);
   console.log("Activating the exact prerelease as the persistent login daemon. Portable-root startup does not prompt; a separately provisioned Secure Enclave broker may request one user-presence operation.");
-  const result = spawnSync(process.execPath, [cli, ...args], {
-    cwd: root,
-    env: process.env,
-    encoding: "utf8",
-    timeout: 300_000,
-    windowsHide: true,
-  });
+  const result = spawnSync(
+    process.execPath,
+    [cli, ...args],
+    persistentActivationSpawnOptions({ cwd: root, env: process.env }),
+  );
   if (result.error) throw result.error;
-  if (result.status !== 0) throw new Error(`persistent candidate activation failed: ${result.stderr || result.stdout}`);
+  if (result.status !== 0) {
+    const output = result.stderr || result.stdout;
+    const requestedWorkspace = argumentListValue("--workspace", withoutManagedFlags(forwardedArgs))
+      || selectedWorkspace(stateRoot);
+    const previousRuntime = discoverForegroundDaemonRecovery({
+      output, stateRoot, workspace: requestedWorkspace,
+    });
+    throw new Error(persistentCandidateFailureMessage(output, { cli, stateRoot, previousRuntime }));
+  }
   let activation;
   try { activation = JSON.parse(result.stdout); } catch { throw new Error("persistent candidate activation did not return valid JSON"); }
   if (
@@ -155,6 +172,7 @@ function activatePersistentCandidate({ manifest, installedPackage, installPrefix
   if (previous?.version) console.log(`Rollback baseline retained: globally installed ${previous.version}.`);
 }
 
+
 function currentGlobalInstallation(packageName) {
   try {
     const globalRoot = runNpm(["root", "--global"], root).stdout.trim();
@@ -180,6 +198,13 @@ function withoutManagedFlags(args) {
   return out;
 }
 
+function argumentListValue(name, args) {
+  const exact = args.find(value => value.startsWith(`${name}=`));
+  if (exact) return exact.slice(name.length + 1);
+  const index = args.indexOf(name);
+  return index >= 0 ? args[index + 1] || "" : "";
+}
+
 function argumentValue(name) {
   const exact = process.argv.find((value) => value.startsWith(`${name}=`));
   if (exact) return exact.slice(name.length + 1);
@@ -198,6 +223,7 @@ function runNpm(args, cwd) {
     encoding: "utf8",
     env: process.env,
     timeout: 300_000,
+    killSignal: "SIGKILL",
     windowsHide: true,
   });
   if (result.error) throw result.error;

package/src/local/agent-context-projection.mjs

@@ -36,6 +36,9 @@ import { createHash } from "node:crypto";
  */
 /**
  * @typedef {object} ProjectionState
+ * @property {string} target
+ * @property {string} targetDir
+ * @property {string} scopeRoot
  * @property {string[]} configFiles
  * @property {InstructionItem | null} builtinInstructions
  * @property {InstructionItem | null} automaticProjectContext
@@ -47,18 +50,34 @@ import { createHash } from "node:crypto";
 /** @param {ProjectionState} state @param {SkillSummary[]} skills */
 export function capabilityFingerprint(state, skills) {
   return sha256(JSON.stringify({
-    configs: state.configFiles,
+    target: state.target,
+    target_dir: state.targetDir,
+    scope_root: state.scopeRoot,
+    configs: [...state.configFiles],
     instructions: [
-      state.builtinInstructions?.sha256 || "",
-      state.automaticProjectContext?.sha256 || "",
-      state.modelInstructions?.sha256 || "",
-      ...state.instructions.map((item) => item.sha256),
+      instructionFingerprintItem(state.builtinInstructions),
+      instructionFingerprintItem(state.automaticProjectContext),
+      instructionFingerprintItem(state.modelInstructions),
+      ...state.instructions.map(instructionFingerprintItem),
     ],
-    skills: skills.map((skill) => [skill.id, skill.sha256]),
-    commands: [...state.commands.values()].map((command) => [command.name, command.argv]),
+    skills: skills
+      .map((skill) => [skill.id, skill.name, skill.entrypoint, skill.sourceRoot, skill.sha256])
+      .sort((left, right) => String(left[0]).localeCompare(String(right[0]))),
+    commands: [...state.commands.values()]
+      .map((command) => [
+        command.name, command.description, command.argv, command.cwd, command.timeoutSeconds,
+        command.allowExtraArgs, command.source, command.sourceType || "", command.script || "",
+      ])
+      .sort((left, right) => String(left[0]).localeCompare(String(right[0]))),
   }));
 }
 
+/** @param {InstructionItem | null | undefined} item */
+function instructionFingerprintItem(item) {
+  if (!item) return null;
+  return [item.source || "", item.path || "", item.scope, item.sha256, item.precedence, item.bytes];
+}
+
 /** @param {SkillSummary} skill @param {DisplayPath} displayPath */
 export function publicSkill(skill, displayPath) {
   return {

package/src/local/agent-context.mjs

@@ -134,16 +134,37 @@ export class AgentContextManager {
       skillRelevant: Boolean(selected),
     });
     const refresh = capabilityFingerprint(state, discovered.skills);
-    return {
-      task,
-      target: this.displayPath(state.target, context),
+    const knownRefreshFingerprint = args.known_refresh_fingerprint === undefined
+      ? ""
+      : String(args.known_refresh_fingerprint || "");
+    if (knownRefreshFingerprint && !/^[a-f0-9]{64}$/.test(knownRefreshFingerprint)) {
+      throw new Error("known_refresh_fingerprint must be a lowercase SHA-256 hex digest");
+    }
+    const contextUnchanged = Boolean(knownRefreshFingerprint && knownRefreshFingerprint === refresh);
+    const staticContext = contextUnchanged ? {} : {
       effective_instructions: renderEffectiveInstructions(effectiveInstructionItems(state), (value) => this.displayPath(value, context)),
       builtin_instructions: publicVirtualInstruction(state.builtinInstructions, false),
       automatic_project_context: publicVirtualInstruction(state.automaticProjectContext, false),
       model_instructions_file: state.modelInstructions ? this.displayPath(state.modelInstructions.path, context) : null,
       instruction_files: state.instructions.map((item) => ({ path: this.displayPath(item.path, context), scope: item.scope, bytes: item.bytes, sha256: item.sha256, precedence: item.precedence })),
+    };
+    return {
+      task,
+      target: this.displayPath(state.target, context),
+      ...staticContext,
       instructions_truncated: state.instructionsTruncated,
-      refresh: { strategy: "rescan-on-every-call", fingerprint: refresh, generated_at: new Date().toISOString() },
+      refresh: {
+        strategy: "rescan-on-every-call",
+        fingerprint: refresh,
+        context_unchanged: contextUnchanged,
+        generated_at: new Date().toISOString(),
+      },
+      context_reuse: {
+        static_context_omitted: contextUnchanged,
+        omitted_fields: contextUnchanged
+          ? ["effective_instructions", "builtin_instructions", "automatic_project_context", "model_instructions_file", "instruction_files"]
+          : [],
+      },
       selected_skill: selectedSkill,
       skill_matches: skillMatches.map(({ skill, score }) => ({ ...publicSkill(skill, (value) => this.displayPath(value, context)), score })),
       command_matches: commandMatches.map(({ command, score }) => ({ ...publicCommands(new Map([[command.name, command]]), (value) => this.displayPath(value, context))[0], score })),

package/src/local/autostart-log-maintenance.mjs

@@ -0,0 +1,36 @@
+// @ts-check
+
+import { trimAutostartLogs } from "./service.mjs";
+
+const DEFAULT_MAINTENANCE_INTERVAL_MS = 15 * 60 * 1000;
+
+/**
+ * Keep long-lived background-service logs within the same bounds enforced at
+ * startup. The injected scheduler/trim hooks keep the lifecycle deterministic
+ * in tests without weakening the production file-safety checks.
+ *
+ * @param {string} stateRoot
+ * @param {{
+ *   intervalMs?: number,
+ *   trim?: (stateRoot: string) => void,
+ *   onError?: (error: unknown) => void,
+ *   scheduler?: {setInterval: (callback: () => void, delay: number) => any},
+ * }} [options]
+ */
+export function startAutostartLogMaintenance(stateRoot, options = {}) {
+  const intervalMs = positiveInteger(options.intervalMs, DEFAULT_MAINTENANCE_INTERVAL_MS);
+  const trim = typeof options.trim === "function" ? options.trim : trimAutostartLogs;
+  const onError = typeof options.onError === "function" ? options.onError : () => {};
+  const scheduler = options.scheduler || { setInterval };
+  const maintain = () => {
+    try { trim(stateRoot); } catch (error) { onError(error); }
+  };
+  const timer = scheduler.setInterval(maintain, intervalMs);
+  timer?.unref?.();
+  return { intervalMs, maintain };
+}
+
+function positiveInteger(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;
+}

package/src/local/capability-observer.mjs

@@ -34,6 +34,11 @@ export class CapabilityObserver {
       matched_commands: Array.isArray(result?.command_matches) ? result.command_matches.length : 0,
       matched_applications: Array.isArray(result?.application_matches) ? result.application_matches.length : 0,
       recommended_tools: Array.isArray(result?.recommended_tools) ? [...result.recommended_tools] : [],
+      primary_route: result?.execution_routing?.primary_route?.id || null,
+      routing_ambiguity: result?.execution_routing?.ambiguity?.level || "none",
+      routing_score_gap: Number.isFinite(Number(result?.execution_routing?.ambiguity?.score_gap))
+        ? Number(result.execution_routing.ambiguity.score_gap)
+        : 0,
       refresh_fingerprint: String(result?.refresh?.fingerprint || ""),
     };
   }

package/src/local/child-process-settlement.mjs

@@ -0,0 +1,103 @@
+// @ts-check
+
+/**
+ * @typedef {{
+ *   onSettle?: (code: number | null, signal: string | null, source: "close" | "exit_fallback") => void,
+ *   onFallback?: () => void,
+ *   schedule?: (callback: () => void, delay: number) => unknown,
+ *   clearSchedule?: (timer: unknown) => void,
+ *   fallbackMs?: unknown,
+ *   readExitState?: () => { code?: number | null, signal?: string | null },
+ * }} ChildProcessSettlementOptions
+ */
+
+/** @param {ChildProcessSettlementOptions} [options] */
+export function createChildProcessSettlement(options = {}) {
+  if (typeof options.onSettle !== "function") throw new TypeError("child settlement requires onSettle");
+  const onSettle = options.onSettle;
+  /** @type {(callback: () => void, delay: number) => unknown} */
+  const defaultSchedule = (callback, delay) => setTimeout(callback, delay);
+  /** @type {(timer: unknown) => void} */
+  const defaultClearSchedule = timer => clearTimeout(/** @type {ReturnType<typeof setTimeout>} */ (timer));
+  const schedule = typeof options.schedule === "function" ? options.schedule : defaultSchedule;
+  const clearSchedule = typeof options.clearSchedule === "function" ? options.clearSchedule : defaultClearSchedule;
+  const delay = boundedDelay(options.fallbackMs);
+  let settled = false;
+  /** @type {unknown} */
+  let timer = null;
+  let timerSet = false;
+
+  /**
+   * @param {number | null} code
+   * @param {string | null} signal
+   * @param {"close" | "exit_fallback"} source
+   */
+  function settle(code, signal, source) {
+    if (settled) return false;
+    settled = true;
+    if (timerSet) clearSchedule(timer);
+    timer = null;
+    timerSet = false;
+    onSettle(code, signal, source);
+    return true;
+  }
+
+  /** @param {number | null} code @param {string | null} signal */
+  function onClose(code, signal) { return settle(code, signal, "close"); }
+
+  /** @param {number | null} code @param {string | null} signal */
+  function onExit(code, signal) {
+    if (settled || timerSet) return false;
+    timerSet = true;
+    timer = schedule(() => {
+      timer = null;
+      timerSet = false;
+      options.onFallback?.();
+      const observed = safeExitState(options.readExitState);
+      const settledCode = typeof observed.code === "number" && Number.isInteger(observed.code) ? observed.code : code;
+      const settledSignal = observed.signal || signal;
+      settle(settledCode, settledSignal, "exit_fallback");
+    }, delay);
+    return true;
+  }
+
+  function cancel() {
+    if (settled) return false;
+    settled = true;
+    if (timerSet) clearSchedule(timer);
+    timer = null;
+    timerSet = false;
+    return true;
+  }
+
+  return Object.freeze({ onClose, onExit, cancel });
+}
+
+/** @param {unknown} value */
+function boundedDelay(value) {
+  if (value === undefined) return 1000;
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed) || parsed < 0 || parsed > 10_000) {
+    throw new TypeError("child settlement fallback must be between 0 and 10000 milliseconds");
+  }
+  return Math.floor(parsed);
+}
+export function childExitedBeforeTimeout({ exitCode = null, signalCode = null, processState = "unknown" } = {}) {
+  return Number.isInteger(exitCode) || Boolean(signalCode) || processState === "zombie";
+}
+
+/** @param {ChildProcessSettlementOptions["readExitState"]} reader @returns {{ code: number | null, signal: string | null }} */
+function safeExitState(reader) {
+  if (typeof reader !== "function") return { code: null, signal: null };
+  try {
+    const value = reader();
+    const code = value?.code;
+    const signal = value?.signal;
+    return {
+      code: typeof code === "number" && Number.isInteger(code) ? code : null,
+      signal: typeof signal === "string" && signal ? signal : null,
+    };
+  } catch {
+    return { code: null, signal: null };
+  }
+}

package/src/local/cli-activate.mjs

@@ -2,8 +2,9 @@ import { acquireDaemonLockWithTakeover, inspectWorkspaceDaemon } from "./daemon-
 import { effectiveLogFormat, effectiveLogLevel } from "./cli-options.mjs";
 import { createLogger } from "./log.mjs";
 import { activatePersistentRuntime } from "./runtime-activation.mjs";
-import { installAutostart, startAutostart, stopAutostart } from "./service.mjs";
-import { acquireStartupLockWithWait, loadState } from "./state.mjs";
+import { autostartStatus, installAutostart, startAutostart, stopAutostart } from "./service.mjs";
+import { startOwnedServiceRuntime } from "./service-runtime.mjs";
+import { acquireMachineServiceLockWithWait, acquireStartupLockWithWait, daemonLockPathForState, loadState, readDaemonLockOwner } from "./state.mjs";
 import { workerHealth } from "./worker-health.mjs";
 
 export function createActivateCommand({
@@ -42,13 +43,41 @@ export function createActivateCommand({
     const result = await activatePersistentRuntime({
       expectedVersion,
       acquireStartupLock: () => acquireStartupLockWithWait(state, { operation: "activate", logger }),
+      acquireServiceLock: () => acquireMachineServiceLockWithWait({ operation: "activate", logger }),
+      inspectActivationOwnership: async () => {
+        const daemon = inspectWorkspaceDaemon(state);
+        const owner = daemon.alive && daemon.verified_service_daemon
+          ? readDaemonLockOwner(daemonLockPathForState(state))
+          : null;
+        return {
+          daemon,
+          provider: await autostartStatus(),
+          previousRuntime: owner ? { version: owner.version, entryScript: owner.entryScript } : null,
+        };
+      },
       stopAutostart: () => stopAutostart({ logger: structuredLogger(true) }),
       acquireDaemonLock: () => acquireDaemonLockWithTakeover(state, {
         takeOverServiceOwner: true,
         ownerMetadata: { mode: "foreground", version: expectedVersion },
         logger,
       }),
-      prepareRemoteState: () => prepareRemoteState({ args: activationArgs, workspace, state, logger }),
+      prepareRemoteState: ({ onRemotePrepared } = {}) => prepareRemoteState({
+        args: activationArgs,
+        workspace,
+        state,
+        logger,
+        onRemotePrepared,
+      }),
+      repairRemoteState: async ({ onRemotePrepared } = {}) => {
+        logger.warn("candidate device authentication was rejected; redeploying the same Worker once with the current device identity");
+        return prepareRemoteState({
+          args: { ...activationArgs, forceWorker: true, rotateSecrets: false },
+          workspace,
+          state,
+          logger,
+          onRemotePrepared,
+        });
+      },
       createRuntime: ({ daemonLock, readiness }) => createRemoteRuntime({
         args: activationArgs,
         workspace,
@@ -61,10 +90,17 @@ export function createActivateCommand({
         workspace,
         stateRoot: state.paths.stateRoot,
         entryScript: process.argv[1],
+        version: expectedVersion,
         logger: structuredLogger(true),
       }),
-      startAutostart: () => startAutostart({ logger: structuredLogger(true) }),
-      inspectDaemon: async () => inspectWorkspaceDaemon(state),
+      startAutostart: () => startOwnedServiceRuntime({ logger: structuredLogger(true) }),
+      restorePreviousAutostart: () => startAutostart({ logger: structuredLogger(true) }),
+      inspectPreviousAutostart: (identity) => inspectWorkspaceDaemon(state, {
+        expectedVersion: identity.version, expectedEntryScript: identity.entryScript,
+      }),
+      inspectDaemon: async () => inspectWorkspaceDaemon(state, {
+        expectedVersion, expectedEntryScript: process.argv[1],
+      }),
       checkWorker: async () => workerHealth(state.worker.url, expectedVersion, { expectedWorkerName: state.worker.name }),
     });
     const convergence = result.convergence;
@@ -76,6 +112,7 @@ export function createActivateCommand({
       daemon: convergence.daemon,
       service: result.serviceStart,
       candidate_relay_verified_before_handoff: result.candidateRelayVerified,
+      candidate_auth_recovery_redeployed: result.candidateRecoveryRedeployed,
     };
     if (args.json) console.log(JSON.stringify(payload, null, 2));
     else {

package/src/local/cli-service.mjs

@@ -4,6 +4,8 @@ import { inspectWorkspaceDaemon, stopWorkspaceServiceDaemon } from "./daemon-pro
 import { stopAndRemoveAutostart } from "./service-lifecycle.mjs";
 import { serviceEnvironmentSummary } from "./service-environment.mjs";
 import { scheduleServiceRestart } from "./service-restart-scheduler.mjs";
+import { startOwnedServiceRuntime } from "./service-runtime.mjs";
+import { loadServiceOwner } from "./service-owner.mjs";
 import { loadState, resolveWorkspace, selectedWorkspace } from "./state.mjs";
 
 const SERVICE_ACTION_HANDLERS = new Map([
@@ -21,12 +23,18 @@ export function createServiceCommand(dependencies) {
     chooseWorkspace: requiredFunction(dependencies.chooseWorkspace, "chooseWorkspace"),
     stateRootFromArgs: requiredFunction(dependencies.stateRootFromArgs, "stateRootFromArgs"),
     structuredLogger: requiredFunction(dependencies.structuredLogger, "structuredLogger"),
+    currentPackageVersion: requiredFunction(dependencies.currentPackageVersion, "currentPackageVersion"),
     service: dependencies.service || defaultService,
     inspectWorkspaceDaemon: dependencies.inspectWorkspaceDaemon || inspectWorkspaceDaemon,
     stopWorkspaceServiceDaemon: dependencies.stopWorkspaceServiceDaemon || stopWorkspaceServiceDaemon,
     stopAndRemoveAutostart: dependencies.stopAndRemoveAutostart || stopAndRemoveAutostart,
     serviceEnvironmentSummary: dependencies.serviceEnvironmentSummary || serviceEnvironmentSummary,
+    loadServiceOwner: dependencies.loadServiceOwner || loadServiceOwner,
     scheduleServiceRestart: dependencies.scheduleServiceRestart || scheduleServiceRestart,
+    startOwnedServiceRuntime: dependencies.startOwnedServiceRuntime || startOwnedServiceRuntime,
+    acquireMachineServiceLockWithWait: requiredFunction(
+      dependencies.acquireMachineServiceLockWithWait, "acquireMachineServiceLockWithWait",
+    ),
     loadState: dependencies.loadState || loadState,
     resolveWorkspace: dependencies.resolveWorkspace || resolveWorkspace,
     selectedWorkspace: dependencies.selectedWorkspace || selectedWorkspace,
@@ -42,18 +50,45 @@ async function serviceCommand(args, context) {
   const handler = SERVICE_ACTION_HANDLERS.get(action);
   if (!handler) throw new Error(`Unknown service action: ${action}`);
   const stateRoot = context.stateRootFromArgs(args);
-  return handler({ args, stateRoot, service: context.service, context });
+  if (!new Set(["install", "start", "stop", "uninstall", "remove"]).has(action)) {
+    return handler({ args, stateRoot, service: context.service, context });
+  }
+  const lock = await context.acquireMachineServiceLockWithWait({ operation: `service-${action}` });
+  if (!lock?.acquired || typeof lock.release !== "function") {
+    throw new Error("machine-service operation lock could not be acquired");
+  }
+  try {
+    return await handler({ args, stateRoot, service: context.service, context });
+  } finally {
+    lock.release();
+  }
 }
 
 async function serviceStatusAction({ args, stateRoot, service, context }) {
   const status = await service.autostartStatus();
-  const state = optionalServiceState(args, stateRoot, context);
-  const workspaceDaemon = state ? context.inspectWorkspaceDaemon(state) : null;
+  let owner = null;
+  let ownerProjection = { status: "missing", version: null };
+  try {
+    owner = context.loadServiceOwner();
+    if (owner) ownerProjection = { status: owner.status, version: owner.version };
+  } catch {
+    ownerProjection = { status: "invalid", version: null, error_class: "invalid_state" };
+  }
+  const explicitState = hasExplicitServiceTarget(args) ? optionalServiceState(args, stateRoot, context) : null;
+  const ownerState = !explicitState && owner?.status === "committed"
+    ? context.loadState(owner.workspace, { stateDir: owner.stateRoot })
+    : null;
+  const state = explicitState || ownerState || optionalServiceState(args, stateRoot, context);
+  const effectiveStateRoot = ownerState ? owner.stateRoot : stateRoot;
+  const workspaceDaemon = state ? context.inspectWorkspaceDaemon(state, ownerState ? {
+    expectedVersion: owner.version, expectedEntryScript: owner.entryScript,
+  } : {}) : null;
   printServiceResult({
     ...status,
     workspace: state?.workspace?.path || null,
     workspace_daemon: workspaceDaemon,
-    service_environment: context.serviceEnvironmentSummary(stateRoot),
+    service_owner: ownerProjection,
+    service_environment: context.serviceEnvironmentSummary(effectiveStateRoot),
     effective_active: Boolean(status.active || workspaceDaemon?.alive),
     orphaned_workspace_daemon: Boolean(status.active === false && workspaceDaemon?.alive && workspaceDaemon?.verified_service_daemon),
   }, context, false);
@@ -66,10 +101,19 @@ async function serviceInstallAction({ args, stateRoot, service, context }) {
   if (!state.worker?.url) {
     throw new Error("No deployed Worker is recorded for this workspace. Run `machine-mcp` once before `machine-mcp service install`.");
   }
+  const provider = await service.autostartStatus();
+  const daemon = context.inspectWorkspaceDaemon(state);
+  if (typeof provider?.active !== "boolean") {
+    throw new Error("machine service activity could not be verified before installation");
+  }
+  if (provider.active || daemon?.alive) {
+    throw new Error("refusing to replace the machine service definition while a provider or workspace daemon is active");
+  }
   const result = await service.installAutostart({
     workspace,
     stateRoot,
     entryScript: context.entryScript,
+    version: context.currentPackageVersion(),
     logger: context.structuredLogger(Boolean(args.quiet)),
   });
   printServiceResult(result, context);
@@ -77,7 +121,13 @@ async function serviceInstallAction({ args, stateRoot, service, context }) {
 
 async function serviceStartAction({ args, service, context }) {
   assertGlobalServiceAction(args, "start");
-  const result = await service.startAutostart({ logger: context.structuredLogger(Boolean(args.quiet)) });
+  const logger = context.structuredLogger(Boolean(args.quiet));
+  const result = await context.startOwnedServiceRuntime({
+    logger,
+    readProvider: service.autostartStatus,
+    mutateProvider: service.startAutostart,
+    stopProvider: service.stopAutostart,
+  });
   printServiceResult(result, context);
 }