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

package/src/local/cli.mjs

@@ -1,31 +1,38 @@
-import { readFileSync } from "node:fs";
 import { join, resolve } from "node:path";
 import process from "node:process";
 import readline from "node:readline/promises";
 import { LocalRuntime } from "./runtime.mjs";
-import { acquireDaemonLockWithTakeover, stopWorkspaceServiceDaemon } from "./daemon-process.mjs";
+import { acquireDaemonLockWithTakeover, inspectWorkspaceDaemon, stopWorkspaceServiceDaemon, workspaceDaemonOwnsPlatformAutostart } from "./daemon-process.mjs";
 import { inspectProcessInstance } from "./process-identity.mjs";
 import { runStdioServer } from "./stdio.mjs";
 import { assertCanonicalFullPolicy, POLICY_PROFILES, toolsForPolicy } from "./tools.mjs";
 import { resolvePolicy } from "./cli-policy.mjs";
 import { effectiveLogFormat, effectiveLogLevel, normalizeCommand, parseArgs, validateCommandOptions, validateLoggingOptions, validatePositionals } from "./cli-options.mjs";
 import { createLocalAdminCommands } from "./cli-local-admin.mjs";
-import { createApprovalCommand } from "./cli-approval.mjs";
 import { createServiceCommand } from "./cli-service.mjs";
+import { createActivateCommand } from "./cli-activate.mjs";
 import { generateAccountPassword } from "./account-admin.mjs";
 import { accountAdminClient, createAccountCommand } from "./cli-account-admin.mjs";
 export { resolvePolicy } from "./cli-policy.mjs";
 export { parseArgs, validateCommandOptions, validateLoggingOptions, validatePositionals } from "./cli-options.mjs";
 import { classifyOperationalError, createLogger, sanitizeLogText } from "./log.mjs";
+import { formatPolicySummary, printMcpConnection, printStartJson } from "./cli-ready-output.mjs";
 import { runExecutable, runWrangler } from "./shell.mjs";
 import { runFullAccessTest } from "./full-access-test.mjs";
 import { stopAndRemoveAutostart } from "./service-lifecycle.mjs";
+import { stopOwnedPlatformService } from "./service-ownership.mjs";
 import { loadServiceEnvironment } from "./service-environment.mjs";
-import { ensureWorkerDeployment } from "./worker-deployment.mjs";
+import { createDeviceSessionForRoot, deviceRootProviderStatus, ensurePreferredDeviceRoot } from "./device-root-provider.mjs";
+import { convergeRemoteConfiguration } from "./remote-configuration.mjs";
 import { workerHealth } from "./worker-health.mjs";
+import { DOCTOR_RUNTIME_SCOPE, doctorRuntimeCheckProjection } from "./doctor-reporting.mjs";
+import { supportStateProjection } from "./support-state-projection.mjs";
 export { workerHealthUserReason } from "./worker-health.mjs";
 import { activeStateJobs, activeStateLocks, knownProfileStates, knownWorkerNames } from "./state-inventory.mjs";
+import { pruneRetiredManagedJobDirectories } from "./managed-job-directory-generation.mjs";
+import { withReleaseRuntimeLock } from "./release-runtime-lock.mjs";
 import {
+  acquireMachineServiceLockWithWait,
   acquireMaintenanceLock,
   acquireStartupLockWithWait,
   daemonLockPathForState,
@@ -36,7 +43,6 @@ import {
   expandHome,
   loadGlobalConfig,
   loadState,
-  packageRoot,
   readDaemonLockOwner,
   redactState,
   removeStateRoot,
@@ -47,14 +53,23 @@ import {
   selectedWorkspace,
   setSelectedWorkspace,
 } from "./state.mjs";
+import { packageName, packageVersion } from "./package-identity.mjs";
 
 const localAdminCommands = createLocalAdminCommands({ chooseWorkspace, confirm });
 const accountCommand = createAccountCommand({ chooseWorkspace, confirm });
-const approvalCommand = createApprovalCommand({ chooseWorkspace, confirm });
-const serviceCommand = createServiceCommand({ chooseWorkspace, stateRootFromArgs, structuredLogger });
+const serviceCommand = createServiceCommand({ chooseWorkspace, stateRootFromArgs, structuredLogger, acquireMachineServiceLockWithWait, currentPackageVersion });
+const activateCommand = createActivateCommand({
+  chooseWorkspace,
+  prepareRemoteState,
+  createRemoteRuntime,
+  currentPackageVersion,
+  assertNodeVersion,
+  structuredLogger,
+});
 
 const COMMAND_HANDLERS = new Map([
   ["start", startCommand],
+  ["activate", activateCommand],
   ["stdio", stdioCommand],
   ["client-config", clientConfigCommand],
   ["status", statusCommand],
@@ -66,7 +81,6 @@ const COMMAND_HANDLERS = new Map([
   ["rotate-secrets", rotateSecretsCommand],
   ["resource", localAdminCommands.resourceCommand],
   ["account", accountCommand],
-  ["approval", approvalCommand],
   ["browser", localAdminCommands.browserCommand],
   ["job", localAdminCommands.jobCommand],
   ["uninstall", uninstallCommand],
@@ -173,14 +187,18 @@ async function startCommand(args) {
   assertNodeVersion();
   const logger = createLogger({ level: args.json ? "error" : effectiveLogLevel(args), format: effectiveLogFormat(args), component: "cli" });
   const workspace = await chooseWorkspace(args, { promptOnFirstRun: true, save: true, allowPositional: true });
-  const state = loadState(workspace, { stateDir: args.stateDir });
-  if (args.daemonOnly) {
-    const serviceEnvironment = loadServiceEnvironment(state.paths.stateRoot);
-    logger.debug?.("Loaded persisted service network environment", { keys: serviceEnvironment.keys });
-  }
-  const startupLock = await acquireStartupLockWithWait(state, { operation: "start", logger });
+  let state = loadState(workspace, { stateDir: args.stateDir });
+  let startupLock = null;
+  let serviceLock = null;
 
   try {
+    serviceLock = await acquireRuntimeStartServiceLock(args, acquireMachineServiceLockWithWait, logger);
+    startupLock = await acquireStartupLockWithWait(state, { operation: "start", logger });
+    state = loadState(workspace, { stateDir: args.stateDir });
+    if (args.daemonOnly) {
+      const serviceEnvironment = loadServiceEnvironment(state.paths.stateRoot);
+      logger.debug?.("Loaded persisted service network environment", { keys: serviceEnvironment.keys });
+    }
     const startMode = await prepareStartMode(args, state, logger);
     const daemonLock = await acquireDaemonLockWithTakeover(state, {
       takeOverServiceOwner: startMode.takeOverServiceOwner,
@@ -194,9 +212,12 @@ async function startCommand(args) {
       reportExistingDaemon(args, state, daemonLock.owner, logger);
       return;
     }
+    serviceLock?.release?.();
+    serviceLock = null;
     await startRemoteRuntime({ args, workspace, state, daemonLock, logger });
   } finally {
-    startupLock.release();
+    serviceLock?.release?.();
+    startupLock?.release?.();
   }
 }
 
@@ -206,22 +227,38 @@ async function prepareStartMode(args, state, logger) {
     trimAutostartLogs(state.paths.stateRoot);
     return { takeOverServiceOwner: false };
   }
-  // A normal foreground start first asks the platform service manager to
-  // unload the job, then independently reclaims a verified daemon-only
-  // process. The second step handles orphaned service daemons that launchd or
-  // another service manager no longer tracks.
-  return stopAutostartBestEffort(logger);
+  // The platform service name is machine-global, while state/workspace locks
+  // are scoped. Stop the platform service only when the daemon lock proves
+  // that the loaded service belongs to this exact state/workspace. An
+  // unrelated foreground start (including install smoke tests with isolated
+  // HOME/state) must never unload another Machine Bridge deployment.
+  const ownership = await stopOwnedPlatformService({
+    state,
+    inspectWorkspaceDaemon,
+    ownsPlatformAutostart: workspaceDaemonOwnsPlatformAutostart,
+    stopPlatformService: () => stopAutostartBestEffort(logger),
+  });
+  if (!ownership.owned) {
+    logger.debug?.("foreground startup left unrelated machine autostart untouched", {
+      workspace_daemon_present: ownership.daemon.present === true,
+      workspace_daemon_alive: ownership.daemon.alive === true,
+      identity_reason: ownership.daemon.identity_reason || "not_running",
+    });
+    return { takeOverServiceOwner: true, provider: null };
+  }
+  // Once ownership is proven, unload the provider first so KeepAlive cannot
+  // respawn the service while the verified process lock is reclaimed.
+  return ownership.provider;
 }
 
 function reportExistingDaemon(args, state, owner, logger) {
-  const pid = owner?.pid ? `pid ${owner.pid}` : "unknown pid";
   if (isIdempotentDaemonOnlyStart(args)) {
     logger.debug?.("local daemon already running; daemon-only start completed as an idempotent no-op", { owner_pid_known: Boolean(owner?.pid) });
     return;
   }
   const mode = owner?.mode === "foreground" ? "foreground" : owner?.mode === "service" ? "background service" : "local";
   const version = owner?.version ? `, version ${owner.version}` : "";
-  const notice = `${mode} daemon already running for this workspace (${pid}${version}); it was not restarted and requested changes were not applied`;
+  const notice = `${mode} daemon already running for this workspace${version}; it was not restarted and requested changes were not applied`;
   logger.warn(notice);
   if (args.json) {
     printStartJson(state, { requestedChangesApplied: false, notice });
@@ -235,6 +272,20 @@ function reportExistingDaemon(args, state, owner, logger) {
   logger.plain(`  Workspace: ${state.workspace.path}`);
 }
 
+export function runtimeStartRequiresMachineServiceLock(args = {}) {
+  return args.daemonOnly !== true;
+}
+
+export async function acquireRuntimeStartServiceLock(args = {}, acquireLock = acquireMachineServiceLockWithWait, logger = console) {
+  if (!runtimeStartRequiresMachineServiceLock(args)) return null;
+  if (typeof acquireLock !== "function") throw new TypeError("runtime start requires a machine-service lock acquirer");
+  const lock = await acquireLock({ operation: "runtime-start", logger });
+  if (!lock?.acquired || typeof lock.release !== "function") {
+    throw new Error("machine-service operation lock could not be acquired for runtime start");
+  }
+  return lock;
+}
+
 export function isIdempotentDaemonOnlyStart(args) {
   if (!args.daemonOnly || args.json) return false;
   return !Boolean(
@@ -255,44 +306,67 @@ async function startRemoteRuntime({ args, workspace, state, daemonLock, logger }
   let runtime = null;
   try {
     const readiness = await prepareRemoteState({ args, workspace, state, logger });
-    runtime = createRemoteRuntime({ args, workspace, state, daemonLock });
+    runtime = createRemoteRuntime({ args, workspace, state, daemonLock, deviceSessionIdentity: readiness.deviceSessionIdentity });
     await runtime.start();
-    reportRemoteReady(args, state, readiness);
+    if (typeof daemonLock.update !== "function") throw new Error("daemon lock cannot publish startup readiness");
+    daemonLock.update({ startupReady: true, startupReadyAt: new Date().toISOString() });
+    reportRemoteReady(args, state, readiness, logger);
+    if (args.daemonOnly) {
+      const { startAutostartLogMaintenance } = await import("./autostart-log-maintenance.mjs");
+      startAutostartLogMaintenance(state.paths.stateRoot, {
+        onError(error) {
+          logger.event?.("warn", "service.log_maintenance.failed", {
+            error_class: classifyOperationalError(error),
+          }, "Background log maintenance failed");
+        },
+      });
+    }
     keepProcessAlive({ daemon: runtime, lock: daemonLock, logger });
   } catch (error) {
-    try { runtime?.stop?.(); } catch {}
-    daemonLock.release();
-    throw error;
+    throw cleanupRuntimeStartFailure(error, runtime, daemonLock);
   }
 }
 
-async function prepareRemoteState({ args, workspace, state, logger }) {
-  const workerName = validateWorkerName(args.workerName);
-  ensureWorkerSecrets(state, {
-    rotateSecrets: Boolean(args.rotateSecrets),
-    workerName,
-    allowWorkerRename: Boolean(args.forceWorker),
-  });
-  state.policy = resolvePolicy(args, state.policy);
-  state.policy.updatedAt = new Date().toISOString();
-  saveState(state);
+export function cleanupRuntimeStartFailure(error, runtime, daemonLock) {
+  const cleanupErrors = [];
+  try { runtime?.stop?.(); } catch (failure) { cleanupErrors.push(failure); }
+  try { daemonLock?.release?.(); } catch (failure) { cleanupErrors.push(failure); }
+  return cleanupErrors.length
+    ? new AggregateError([error, ...cleanupErrors],
+      "runtime startup failed and local cleanup was incomplete")
+    : error;
+}
 
-  let initialOwner = null;
+async function prepareRemoteState({ args, workspace, state, logger, onRemotePrepared, provisionInitialOwner = true }) {
   if (!args.daemonOnly) {
-    await ensureWorker(state, args);
-    initialOwner = await ensureInitialOwnerAccount(state);
+    await convergeRemoteConfiguration({ args, state });
+    onRemotePrepared?.();
   } else if (!state.worker.url) {
     throw new Error("--daemon-only requires an existing Worker URL; run start once without --daemon-only");
+  } else if (state.worker.pendingDeviceIdentity) {
+    throw new Error("--daemon-only cannot activate a pending device root; run a normal start once to deploy and promote it");
   }
 
+  const deviceSessionIdentity = await createDeviceSessionForRoot(
+    state.worker.deviceIdentity,
+    state.worker.url,
+    "machine-bridge-mcp",
+    currentPackageVersion(),
+    { profileDir: state.paths.profileDir, reason: "Authorize Machine Bridge startup" },
+  );
+  const initialOwner = args.daemonOnly || provisionInitialOwner === false
+    ? null
+    : await ensureInitialOwnerAccount(state, deviceSessionIdentity);
   if (!args.daemonOnly && !args.noAutostart) {
     await installAutostartBestEffort({ workspace, stateRoot: state.paths.stateRoot, entryScript: process.argv[1], logger });
   }
-  return { initialOwner };
+  return { initialOwner, deviceSessionIdentity };
 }
 
-async function ensureInitialOwnerAccount(state) {
-  const client = accountAdminClient(state);
+
+
+async function ensureInitialOwnerAccount(state, deviceSessionIdentity) {
+  const client = await accountAdminClient(state, deviceSessionIdentity);
   const existing = await client.list();
   if (existing.accounts.length > 0) return null;
   const password = generateAccountPassword();
@@ -300,31 +374,43 @@ async function ensureInitialOwnerAccount(state) {
   return { ...created.account, password };
 }
 
-function createRemoteRuntime({ args, workspace, state, daemonLock }) {
-  return new LocalRuntime({
+function createRemoteRuntime({ args, workspace, state, daemonLock, deviceSessionIdentity, exitOnTerminal = true }) {
+  const terminalState = { error: null };
+  const runtime = new LocalRuntime({
     workerUrl: state.worker.url,
-    deviceIdentity: state.worker.deviceIdentity,
+    deviceIdentity: deviceSessionIdentity,
     expectedRelayVersion: currentPackageVersion(),
     workspace,
     policy: state.policy,
     logger: createLogger({ level: args.json ? "error" : effectiveLogLevel(args), format: effectiveLogFormat(args), component: "daemon" }),
     jobRoot: join(state.paths.profileDir, "jobs"),
-    approvalRoot: state.paths.profileDir,
+    securityStateRoot: state.paths.profileDir,
     resources: state.resources,
     resourceStatePath: state.paths.statePath,
     browserStateRoot: state.paths.stateRoot,
+    deviceRootStatus: deviceRootProviderStatus(state.worker.deviceIdentity),
     onSuperseded: () => {
+      if (!exitOnTerminal) {
+        terminalState.error ??= new Error("candidate daemon was superseded before service handoff");
+        return;
+      }
       daemonLock.release();
       process.exit(0);
     },
-    onFatal: () => {
+    onFatal: (error) => {
+      if (!exitOnTerminal) {
+        terminalState.error ??= error instanceof Error ? error : new Error("candidate relay failed before service handoff");
+        return;
+      }
       daemonLock.release();
       process.exit(1);
     },
   });
+  if (!exitOnTerminal) runtime.terminalError = () => terminalState.error;
+  return runtime;
 }
 
-function reportRemoteReady(args, state, readiness) {
+function reportRemoteReady(args, state, readiness, logger) {
   if (args.json) {
     printStartJson(state, { initialOwner: readiness.initialOwner });
     return;
@@ -333,6 +419,7 @@ function reportRemoteReady(args, state, readiness) {
     quiet: Boolean(args.quiet),
     verbose: Boolean(args.verbose),
     initialOwner: readiness.initialOwner,
+    logger,
   });
 }
 
@@ -350,6 +437,7 @@ async function stdioCommand(args) {
     resources: state.resources,
     resourceStatePath: state.paths.statePath,
     browserStateRoot: state.paths.stateRoot,
+    deviceRootStatus: state.worker?.deviceIdentity ? deviceRootProviderStatus(state.worker.deviceIdentity) : null,
   });
 }
 
@@ -378,65 +466,31 @@ async function clientConfigCommand(args) {
     console.log(codex.trimEnd());
   }
 }
-
-async function ensureWorker(state, args) {
-  const logger = createLogger({ level: args.json ? "error" : effectiveLogLevel(args), format: effectiveLogFormat(args), component: "worker" });
-  return ensureWorkerDeployment(state, args, { logger });
-}
-
-
-function printStartJson(state, { requestedChangesApplied = true, notice = "", initialOwner = null } = {}) {
-  createLogger({ component: "ready" }).json({
-    mcp: {
-      server_url: state.worker.mcpServerUrl,
-      worker_url: state.worker.url,
-      worker_name: state.worker.name,
-    },
-    ...(initialOwner ? { initial_owner: initialOwner } : {}),
-    workspace: state.workspace.path,
-    state_path: state.paths.statePath,
-    policy: state.policy,
-    requested_changes_applied: requestedChangesApplied,
-    ...(notice ? { notice } : {}),
-  });
-}
-
-function printMcpConnection(state, { quiet = false, verbose = false, initialOwner = null } = {}) {
-  const logger = createLogger({ component: "ready", quiet, level: quiet ? "error" : verbose ? "debug" : "info" });
-  logger.success("Remote MCP bridge is ready");
-  logger.plain(`  MCP Server URL: ${state.worker.mcpServerUrl}`);
-  if (initialOwner) {
-    logger.warn("Initial owner account created; save the password now because it is not stored locally or shown again. Do not share this terminal output; rotate the password immediately if it has been exposed.");
-    logger.plain(`  Account: ${initialOwner.name}`);
-    logger.plain(`  Password: ${initialOwner.password}`);
-  } else {
-    logger.safePlain("  Use `machine-mcp account` to manage account access.");
-  }
-  logger.plain(`  Workspace: ${state.workspace.path}`);
-  logger.safePlain(`  Policy: ${formatPolicySummary(state.policy)}`);
-  if (verbose) logger.plain(`  State: ${state.paths.statePath}`);
-}
-
-function formatPolicySummary(policy = {}) {
-  const scope = policy.unrestrictedPaths ? "all local paths" : "workspace only";
-  const environment = policy.minimalEnv ? "isolated env" : "full parent env";
-  return `${policy.profile || "custom"} [${policy.origin || "unknown"}; write=${policy.allowWrite ? "on" : "off"}; exec=${policy.execMode || "off"}; ${scope}; ${environment}; absolute_paths=${policy.exposeAbsolutePaths ? "on" : "off"}]`;
-}
-
-
 function keepProcessAlive({ daemon = null, lock = null, logger = createLogger({ component: "cli" }) } = {}) {
   let stopping = false;
   const stop = async () => {
     if (stopping) return;
     stopping = true;
     logger.info("stopping local services");
-    try { daemon?.stop?.(); } catch {}
-    try { lock?.release?.(); } catch {}
+    try {
+      await daemon?.stop?.();
+    } catch (error) {
+      stopping = false;
+      logger.error("local service shutdown is incomplete; retaining daemon ownership for a later retry", {
+        error_class: classifyOperationalError(error),
+      });
+      return;
+    }
+    try { lock?.release?.(); }
+    catch (error) { logger.warn("daemon lock release failed during final shutdown", { error_class: classifyOperationalError(error) }); }
     process.exit(0);
   };
-  process.once("SIGINT", () => void stop());
-  process.once("SIGTERM", () => void stop());
-  process.once("exit", () => lock?.release?.());
+  process.on("SIGINT", () => void stop());
+  process.on("SIGTERM", () => void stop());
+  process.once("exit", () => {
+    try { lock?.release?.(); }
+    catch { /* Process exit is the final ownership fallback; no in-process recovery remains possible. */ }
+  });
   setInterval(() => {}, 2 ** 31 - 1);
 }
 
@@ -454,19 +508,26 @@ async function statusCommand(args) {
 
 async function doctorCommand(args) {
   const workspace = await chooseWorkspace(args, { promptOnFirstRun: false, save: false, allowPositional: true });
+  const state = loadState(workspace, { stateDir: args.stateDir });
+  state.policy = resolvePolicy({}, state.policy);
   const checks = [];
   checks.push({ name: "node", ok: isSupportedNodeVersion(), detail: process.version });
   const npmCommand = npmVersionCommand();
   const npm = await runExecutable(npmCommand.file, npmCommand.args, { capture: true, allowFailure: true, timeoutMs: 10_000 });
   const npmDetail = sanitizeLines(npm.stdout || npm.stderr);
   checks.push({ name: "npm", ok: npm.code === 0 && isSupportedNpmVersion(npmDetail), detail: npmDetail || "unavailable" });
-  const wrangler = await runWrangler(["--version"], { capture: true, allowFailure: true });
+  const wrangler = await runWrangler(["--version"], { capture: true, allowFailure: true, stateRoot: state.paths.stateRoot });
   checks.push({ name: "wrangler", ok: wrangler.code === 0, detail: (wrangler.stdout || wrangler.stderr).trim() });
-  const whoami = await runWrangler(["whoami"], { capture: true, allowFailure: true });
+  const whoami = await runWrangler(["whoami"], { capture: true, allowFailure: true, stateRoot: state.paths.stateRoot });
   checks.push({ name: "cloudflare-login", ok: whoami.code === 0, detail: whoami.code === 0 ? "authenticated" : sanitizeLines(whoami.stderr || whoami.stdout) });
-  const state = loadState(workspace, { stateDir: args.stateDir });
-  state.policy = resolvePolicy({}, state.policy);
   checks.push({ name: "policy", ok: true, detail: formatPolicySummary(state.policy) });
+  checks.push({
+    name: "authorization-model",
+    ok: true,
+    detail: state.policy.profile === "full"
+      ? "local owner operations execute automatically without per-operation prompts; shell, browser, and application automation use the daemon OS user's ambient authority"
+      : "operations allowed by the selected local policy execute automatically without per-operation prompts",
+  });
   if (state.policy.profile === "full") {
     try {
       assertCanonicalFullPolicy(state.policy);
@@ -476,7 +537,7 @@ async function doctorCommand(args) {
     }
   }
   const health = state.worker?.url ? await workerHealth(state.worker.url, currentPackageVersion(), { expectedWorkerName: state.worker.name }) : { ok: false, error: "no worker url" };
-  checks.push({ name: "worker-health", ok: health.ok, detail: health.ok ? state.worker.url : health.error });
+  checks.push({ name: "worker-health", ok: health.ok, detail: health.ok ? "reachable" : health.error });
   const diagnosticRuntime = new LocalRuntime({
     workspace,
     policy: state.policy,
@@ -492,18 +553,12 @@ async function doctorCommand(args) {
   } finally {
     diagnosticRuntime.stop();
   }
-  for (const check of runtimeDiagnostics.checks) {
-    checks.push({
-      name: `runtime:${check.layer}`,
-      ok: check.skipped === true || check.ok === true,
-      detail: check.skipped ? `skipped (${check.error_class || "not applicable"})` : check.ok ? "ok" : check.error_class || "failed",
-    });
-  }
+  for (const check of runtimeDiagnostics.checks) checks.push(doctorRuntimeCheckProjection(check));
   console.log(JSON.stringify({
     ok: checks.every(check => check.ok),
     checks,
-    runtimeDiagnostics,
-    state: redactState(state),
+    diagnosticScope: DOCTOR_RUNTIME_SCOPE,
+    state: supportStateProjection(state),
   }, null, 2));
 }
 
@@ -518,11 +573,20 @@ async function fullTestCommand(args) {
 
 async function rotateSecretsCommand(args) {
   const workspace = await chooseWorkspace(args, { promptOnFirstRun: false, save: false, allowPositional: true });
-  const state = loadState(workspace, { stateDir: args.stateDir });
+  let state = loadState(workspace, { stateDir: args.stateDir });
   const operationLogger = createLogger({ level: args.quiet ? "error" : "warn", component: "service" });
-  const startupLock = await acquireStartupLockWithWait(state, { operation: "rotate-secrets", logger: operationLogger });
+  let startupLock = null;
+  let serviceLock = null;
   try {
-    await stopAutostartBestEffort(operationLogger);
+    serviceLock = await acquireMachineServiceLockWithWait({ operation: "rotate-secrets", logger: operationLogger });
+    startupLock = await acquireStartupLockWithWait(state, { operation: "rotate-secrets", logger: operationLogger });
+    state = loadState(workspace, { stateDir: args.stateDir });
+    await stopOwnedPlatformService({
+      state,
+      inspectWorkspaceDaemon,
+      ownsPlatformAutostart: workspaceDaemonOwnsPlatformAutostart,
+      stopPlatformService: () => stopAutostartBestEffort(operationLogger),
+    });
     const stopped = await stopWorkspaceServiceDaemon(state, { logger: operationLogger, reason: "secret rotation" });
     if (stopped.found && !stopped.ok) {
       const pid = stopped.pid ? `pid ${stopped.pid}` : "unknown pid";
@@ -534,19 +598,35 @@ async function rotateSecretsCommand(args) {
     if (daemonIdentity?.current) {
       throw new Error(`refusing to rotate secrets while the daemon is active (pid ${daemonOwner.pid}); stop the foreground daemon and retry`);
     }
-    ensureWorkerSecrets(state, { rotateSecrets: true });
+    if (state.worker.pendingDeviceIdentity) throw new Error("a device-root rotation is already pending; run machine-mcp to deploy it before rotating again");
+    ensureWorkerSecrets(state, { rotateSecrets: true, deferDeviceRotation: true });
+    state.worker.pendingDeviceIdentity = await ensurePreferredDeviceRoot({
+      profileDir: state.paths.profileDir,
+      workspaceHash: state.workspace.hash,
+      existing: null,
+      rotate: true,
+    });
     saveState(state);
-    console.log("Rotated account administration, daemon, and global token-version secrets.");
-    console.log("All account access tokens are invalid. Run machine-mcp to redeploy, then reconnect clients.");
+    console.log("Prepared a two-phase rotation for account administration, device root, and token-version secrets.");
+    console.log("All account access tokens are invalid. Run machine-mcp to deploy, verify, and atomically promote the pending device root.");
   } finally {
-    startupLock.release();
+    startupLock?.release?.();
+    serviceLock?.release?.();
   }
 }
 
-async function installAutostartBestEffort({ workspace, stateRoot, entryScript, logger }) {
+export async function installAutostartBestEffort({ workspace, stateRoot, entryScript, logger }, options = {}) {
+  let serviceLock = null;
   try {
-    const { installAutostart } = await import("./service.mjs");
-    const result = await installAutostart({ workspace, stateRoot, entryScript, logger: structuredLogger(true) });
+    const acquireLock = options.acquireServiceLock || acquireMachineServiceLockWithWait;
+    const acquired = await acquireLock({ operation: "runtime-start-autostart", logger });
+    if (!acquired?.acquired || typeof acquired.release !== "function") {
+      throw new Error("machine-service operation lock could not be acquired for automatic autostart installation");
+    }
+    serviceLock = acquired;
+    const install = options.installAutostart || (await import("./service.mjs")).installAutostart;
+    const makeLogger = options.structuredLogger || structuredLogger;
+    const result = await install({ workspace, stateRoot, entryScript, version: currentPackageVersion(), logger: makeLogger(true) });
     if (result?.ok) logger.info("Autostart installed for future logins", { provider: result.provider });
     else logger.warn("Autostart installation reported a problem; run `machine-mcp service status` for details", {
       provider: result?.provider || "unknown",
@@ -554,6 +634,8 @@ async function installAutostartBestEffort({ workspace, stateRoot, entryScript, l
     });
   } catch (error) {
     logger.warn("Autostart installation skipped", { error_class: classifyOperationalError(error) });
+  } finally {
+    serviceLock?.release?.();
   }
 }
 
@@ -585,13 +667,19 @@ async function uninstallCommand(args) {
     console.log("Uninstall cancelled. Re-run with `machine-mcp uninstall --yes` to skip confirmation.");
     return;
   }
+  await withReleaseRuntimeLock(stateRoot, () => uninstallStateRoot({ stateRoot, deleteRemote }));
+}
+
+async function uninstallStateRoot({ stateRoot, deleteRemote }) {
   const currentValidation = validateStateRootForRemoval(stateRoot);
   const maintenance = currentValidation.exists ? acquireMaintenanceLock(stateRoot, { operation: "uninstall" }) : null;
   if (maintenance && !maintenance.acquired) {
     const pid = maintenance.owner?.pid ? `pid ${maintenance.owner.pid}` : "another process";
     throw new Error(`another state maintenance operation is active (${pid})`);
   }
+  let serviceLock = null;
   try {
+    serviceLock = await acquireMachineServiceLockWithWait({ operation: "uninstall" });
     if (currentValidation.exists) validateStateRootForRemoval(stateRoot);
     assertNoActiveJobsForUninstall(stateRoot);
     const autostartRemoved = await removeAutostartBestEffort(stateRoot);
@@ -608,16 +696,24 @@ async function uninstallCommand(args) {
     console.log("If installed globally, remove the npm package with:");
     console.log("  npm uninstall -g machine-bridge-mcp");
   } finally {
+    serviceLock?.release?.();
     maintenance?.release?.();
   }
 }
 
 function assertNoActiveJobsForUninstall(stateRoot) {
+  for (const state of knownProfileStates(stateRoot)) {
+    pruneRetiredManagedJobDirectories(join(state.paths.profileDir, "jobs"), { warn() {} });
+  }
   const activeJobs = activeStateJobs(stateRoot);
   if (!activeJobs.length) return;
-  const detail = activeJobs.slice(0, 5).map((item) => `${item.job_id}:${item.status}`).join(", ");
+  const retiredBlocked = activeJobs.some((item) => item.state_kind === "retired_managed_job");
+  const detail = activeJobs.slice(0, 5).map((item) => item.state_kind === "retired_managed_job" ? `retired-managed-job:${item.status}` : `${item.job_id}:${item.status}`).join(", ");
   const suffix = activeJobs.length > 5 ? `, and ${activeJobs.length - 5} more` : "";
-  throw new Error(`refusing to uninstall while managed jobs are active (${detail}${suffix}); inspect or cancel them with machine-mcp job list/cancel`);
+  const guidance = retiredBlocked
+    ? "run machine-mcp job list to retry safe retired cleanup; if retired state remains unreadable, inspect the owner-only state root instead of deleting it blindly; cancel any active jobs before retrying"
+    : "inspect with machine-mcp job list/read and cancel active jobs before retrying";
+  throw new Error(`refusing to uninstall while managed-job state is active or requires inspection (${detail}${suffix}); ${guidance}`);
 }
 
 function assertNoActiveLocksForUninstall(stateRoot) {
@@ -635,9 +731,9 @@ async function deleteKnownWorkers(stateRoot) {
   }
   const failures = [];
   for (const name of names) {
-    const result = await runWrangler(["delete", name, "--force"], { capture: true, allowFailure: true });
+    const result = await runWrangler(["delete", name, "--force"], { capture: true, allowFailure: true, stateRoot });
     const detail = (result.stderr || result.stdout || "unknown error").trim();
-    if (result.code === 0 || /not found|does not exist|could not find/i.test(detail)) {
+    if (result.code === 0) {
       console.log(`Deleted Worker: ${name}`);
     } else {
       failures.push({ name, detail: sanitizeLines(detail) || "unknown error" });
@@ -694,14 +790,7 @@ function escapeRegExp(value) {
   return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
 
-function validateWorkerName(value) {
-  if (value === undefined || value === null || value === false) return undefined;
-  const name = String(value).trim();
-  if (!/^[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?$/.test(name)) {
-    throw new Error("--worker-name must be 1-63 lowercase letters, digits, or hyphens, and cannot start or end with a hyphen");
-  }
-  return name;
-}
+
 
 export function isSupportedNodeVersion(version = process.versions.node) {
   const major = Number(String(version || "").replace(/^v/, "").split(".")[0]);
@@ -737,28 +826,23 @@ Usage:
 
 Commands:
   start             Deploy/update Worker, take over autostart, run foreground daemon
+  activate          Deploy/update Worker, replace autostart, start and verify background daemon
   stdio             Run a local MCP stdio server for Claude, Cursor, Codex, and compatible clients
   client-config     Print stdio client configuration snippets
   workspace show    Show remembered workspace
   workspace set     Re-select workspace; prompts with current/default path
   service status    Show autostart status
   service install   Install login autostart for remembered/current workspace
-  service start     Start the installed autostart service now
+  service start     Ensure the installed autostart service is running (idempotent)
+  service restart   Schedule an explicit service-manager restart and return before handoff
   service stop      Stop the installed autostart service
   service uninstall Remove only the autostart entry
   status            Print redacted local profile state and Worker health
   doctor            Check Node, Wrangler, Cloudflare login, Worker health
   full-test         Run real local full-profile capability tests in a temporary sandbox
   rotate-secrets    Rotate account-admin, device identity, and global token-version secrets
-  account list|add|role|enable|disable|rotate-password|remove
-                    Manage isolated remote accounts and targeted revocation
-  approval list     Show pending high-impact operations and active capability leases
-  approval approve APPROVAL_ID [--duration 1h] [--full]
-                    Approve its scope, or open an explicit full window (maximum 8h)
-  approval grant SCOPE --account ACCOUNT_ID --client CLIENT_ID [--duration 1h]
-                    Pre-authorize a bounded scope; use * values only intentionally
-  approval revoke LEASE_ID | approval clear
-                    Revoke one or all local capability leases
+  account list|clients|revoke-client|add|role|enable|disable|rotate-password|remove
+                    Manage remote accounts, trusted clients, and targeted revocation
   resource generate-ssh-key NAME [PATH]
                     Generate/reuse an Ed25519 key locally and register its private file by alias
   browser status    Show browser-extension bridge and connection status
@@ -797,13 +881,11 @@ Uninstall options:
 }
 
 function currentPackageVersion() {
-  const pkg = JSON.parse(readFileSync(resolve(packageRoot, "package.json"), "utf8"));
-  return String(pkg.version);
+  return packageVersion;
 }
 
 function version() {
-  const pkg = JSON.parse(readFileSync(resolve(packageRoot, "package.json"), "utf8"));
-  console.log(`${pkg.name} ${pkg.version}`);
+  console.log(`${packageName} ${packageVersion}`);
 }
 
 function sleep(ms) {