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

package/src/local/runtime-activation.mjs

@@ -1,6 +1,8 @@
 export async function activatePersistentRuntime(options = {}) {
   const required = [
     "acquireStartupLock",
+    "acquireServiceLock",
+    "inspectActivationOwnership",
     "stopAutostart",
     "acquireDaemonLock",
     "prepareRemoteState",
@@ -13,20 +15,43 @@ export async function activatePersistentRuntime(options = {}) {
   for (const name of required) {
     if (typeof options[name] !== "function") throw new TypeError(`runtime activation requires ${name}`);
   }
+  const expectedVersion = requiredExpectedVersion(options.expectedVersion);
+  const maximumAttempts = boundedAttempts(options.maximumAttempts ?? 240);
+  const candidateStartAttempts = boundedCandidateStartAttempts(options.candidateStartAttempts ?? 3);
+  const candidateRetryWait = optionalFunction(options.candidateRetryWait, "candidateRetryWait", defaultCandidateRetryWait);
+  const convergenceWait = optionalFunction(options.wait, "wait", defaultWait);
+  const restorePreviousAutostart = optionalFunction(options.restorePreviousAutostart, "restorePreviousAutostart", options.startAutostart);
+  if (options.repairRemoteState !== undefined && typeof options.repairRemoteState !== "function") {
+    throw new TypeError("runtime activation repairRemoteState must be a function");
+  }
 
-  const startupLock = await options.acquireStartupLock();
+  let startupLock = null;
   let startupReleased = false;
+  let serviceLock = null;
   let daemonLock = null;
   let candidateRuntime = null;
   let candidateRelayVerified = false;
+  let remotePrepared = false;
+  let autostartInstalled = false;
   let providerStopped = false;
+  let previousServiceRuntime = null;
   let serviceStarted = false;
   try {
-    const providerStop = await options.stopAutostart();
-    if (providerStop?.ok === false && providerStop?.active === true) {
-      throw new Error("the existing autostart service could not be stopped before activation");
+    const acquiredServiceLock = await options.acquireServiceLock();
+    if (!acquiredServiceLock?.acquired) {
+      const owner = acquiredServiceLock?.owner || {};
+      throw new Error(`another machine-service operation is active (pid ${owner.pid || "unknown"})`);
     }
-    providerStopped = providerStop?.active_before === true && providerStop?.active === false;
+    requireReleasableLock(acquiredServiceLock, "machine-service");
+    serviceLock = acquiredServiceLock;
+    const acquiredStartupLock = await options.acquireStartupLock();
+    requireReleasableLock(acquiredStartupLock, "startup");
+    startupLock = acquiredStartupLock;
+    const ownership = validateActivationOwnership(await options.inspectActivationOwnership());
+    providerStopped = ownership.previousServiceRuntimeActive;
+    previousServiceRuntime = ownership.previousServiceRuntime;
+    const providerStop = await options.stopAutostart();
+    providerStopped = validateProviderStop(providerStop) || providerStopped;
 
     daemonLock = await options.acquireDaemonLock();
     if (!daemonLock?.acquired) {
@@ -36,21 +61,40 @@ export async function activatePersistentRuntime(options = {}) {
       }
       throw new Error(`the existing daemon could not be taken over (pid ${owner.pid || "unknown"})`);
     }
+    requireReleasableLock(daemonLock, "daemon");
 
-    const readiness = await options.prepareRemoteState();
-    candidateRuntime = options.createRuntime({ daemonLock, readiness });
-    if (!candidateRuntime || typeof candidateRuntime.start !== "function" || typeof candidateRuntime.stop !== "function") {
-      throw new TypeError("runtime activation candidate must expose start and stop");
+    let readiness;
+    try {
+      readiness = await options.prepareRemoteState({
+        onRemotePrepared() { remotePrepared = true; },
+      });
+      remotePrepared = true;
+    } catch (error) {
+      if (error?.deploymentSucceeded === true) remotePrepared = true;
+      throw error;
     }
-    await candidateRuntime.start();
+
+    const candidate = await startCandidateWithRecovery({
+      attempts: candidateStartAttempts,
+      daemonLock,
+      readiness,
+      createRuntime: options.createRuntime,
+      repairRemoteState: options.repairRemoteState,
+      wait: candidateRetryWait,
+      onRuntimeCreated(runtime) { candidateRuntime = runtime; },
+      onRuntimeStopped() { candidateRuntime = null; },
+      onRemoteRepaired() { remotePrepared = true; },
+    });
+    candidateRuntime = candidate.runtime;
     candidateRelayVerified = true;
 
     const installed = await options.installAutostart();
     const terminalError = candidateRuntime.terminalError?.();
     if (terminalError) throw terminalError;
-    if (installed?.ok === false) {
-      throw new Error(`autostart installation failed (${installed.provider || "unknown"})`);
+    if (installed?.ok !== true) {
+      throw new Error(`autostart installation failed (${installed?.provider || "unknown"})`);
     }
+    autostartInstalled = true;
 
     candidateRuntime.stop();
     candidateRuntime = null;
@@ -60,55 +104,295 @@ export async function activatePersistentRuntime(options = {}) {
     startupReleased = true;
 
     const serviceStart = await options.startAutostart();
-    if (serviceStart?.ok === false) {
-      throw new Error(`autostart start failed (${serviceStart.provider || "unknown"})`);
-    }
+    requireActiveServiceStart(serviceStart, "autostart start");
     serviceStarted = true;
 
     const convergence = await waitForActivatedRuntime({
-      expectedVersion: options.expectedVersion,
+      expectedVersion,
       inspectDaemon: options.inspectDaemon,
       checkWorker: options.checkWorker,
-      maximumAttempts: options.maximumAttempts,
-      wait: options.wait,
+      maximumAttempts,
+      wait: convergenceWait,
     });
     if (!convergence.ok) {
       throw new Error(`persistent runtime activation did not converge (${convergence.reason})`);
     }
+    serviceLock.release();
+    serviceLock = null;
     return {
       ok: true,
       serviceStart,
       convergence,
       candidateRelayVerified,
+      candidateRecoveryRedeployed: candidate.repaired,
     };
   } catch (error) {
-    const cleanupErrors = [];
-    try { candidateRuntime?.stop?.(); } catch (failure) { cleanupErrors.push(failure); }
-    try { daemonLock?.release?.(); } catch (failure) { cleanupErrors.push(failure); }
-    if (!startupReleased) {
-      try { startupLock.release(); }
-      catch (failure) { cleanupErrors.push(failure); }
-    }
+    throw await failedActivationError({
+      error,
+      candidateRuntime,
+      daemonLock,
+      startupLock,
+      startupReleased,
+      serviceLock,
+      providerStopped,
+      serviceStarted,
+      remotePrepared,
+      autostartInstalled,
+      installAutostart: options.installAutostart,
+      startAutostart: options.startAutostart,
+      restorePreviousAutostart,
+      inspectPreviousAutostart: options.inspectPreviousAutostart,
+      previousServiceRuntime,
+      restoreWait: convergenceWait,
+      restoreMaximumAttempts: options.maximumAttempts,
+    });
+  }
+}
+
+async function failedActivationError({
+  error,
+  candidateRuntime,
+  daemonLock,
+  startupLock,
+  startupReleased,
+  serviceLock,
+  providerStopped,
+  serviceStarted,
+  remotePrepared,
+  autostartInstalled,
+  installAutostart,
+  startAutostart,
+  restorePreviousAutostart,
+  inspectPreviousAutostart,
+  previousServiceRuntime,
+  restoreWait,
+  restoreMaximumAttempts,
+}) {
+  const cleanupErrors = [];
+  try { candidateRuntime?.stop?.(); } catch (failure) { cleanupErrors.push(failure); }
+  try { daemonLock?.release?.(); } catch (failure) { cleanupErrors.push(failure); }
+  if (!startupReleased && startupLock) {
+    try { startupLock.release(); }
+    catch (failure) { cleanupErrors.push(failure); }
+  }
+  let recovery = null;
+  const cleanupIncomplete = error?.cleanupIncomplete === true || cleanupErrors.length > 0;
+  if (!cleanupIncomplete) {
     try {
-      await restoreStoppedProvider(options.startAutostart, { providerStopped, serviceStarted });
+      recovery = await restoreCompatibleProvider({
+        installAutostart,
+        startAutostart,
+        restorePreviousAutostart,
+        inspectPreviousAutostart,
+        previousServiceRuntime,
+        restoreWait,
+        restoreMaximumAttempts,
+        providerStopped,
+        serviceStarted,
+        candidateServiceRequired: remotePrepared,
+        candidateDefinitionRequired: remotePrepared && !autostartInstalled,
+      });
     } catch (failure) { cleanupErrors.push(failure); }
-    if (cleanupErrors.length) {
-      throw new AggregateError(
-        [error, ...cleanupErrors],
-        "persistent runtime activation failed and local cleanup was incomplete; inspect the daemon and service state before retrying",
-      );
+  }
+  if (serviceLock) {
+    try { serviceLock.release(); } catch (failure) { cleanupErrors.push(failure); }
+  }
+  if (cleanupErrors.length) {
+    return new AggregateError(
+      [error, ...cleanupErrors],
+      "persistent runtime activation failed and local cleanup was incomplete; inspect the daemon and service state before retrying",
+    );
+  }
+  if (recovery?.candidateServiceStarted) return activationFailureWithRecovery(error);
+  return error;
+}
+
+async function startCandidateWithRecovery({
+  attempts = 3,
+  daemonLock,
+  readiness,
+  createRuntime,
+  repairRemoteState,
+  wait = defaultCandidateRetryWait,
+  onRuntimeCreated,
+  onRuntimeStopped,
+  onRemoteRepaired,
+} = {}) {
+  const maximumAttempts = boundedCandidateStartAttempts(attempts);
+  let currentReadiness = readiness;
+  let repaired = false;
+  let lastError = null;
+  for (let attempt = 1; attempt <= maximumAttempts; attempt += 1) {
+    const runtime = createRuntime({ daemonLock, readiness: currentReadiness });
+    if (!runtime || typeof runtime.start !== "function" || typeof runtime.stop !== "function") {
+      throw new TypeError("runtime activation candidate must expose start and stop");
+    }
+    onRuntimeCreated(runtime);
+    try {
+      await runtime.start();
+      return { runtime, repaired };
+    } catch (error) {
+      lastError = error;
+      let stopFailure = null;
+      try { runtime.stop(); } catch (failure) { stopFailure = failure; }
+      finally { onRuntimeStopped(); }
+      if (stopFailure) {
+        const cleanupError = new AggregateError(
+          [error, stopFailure],
+          "candidate relay start failed and runtime cleanup was incomplete",
+        );
+        cleanupError.cleanupIncomplete = true;
+        throw cleanupError;
+      }
+      if (!recoverableCandidateStartError(error) || attempt >= maximumAttempts) throw error;
+      if (!repaired && typeof repairRemoteState === "function") {
+        let repairPrepared = false;
+        const markRemoteRepaired = () => {
+          if (repairPrepared) return;
+          repairPrepared = true;
+          onRemoteRepaired();
+        };
+        currentReadiness = await repairRemoteState({
+          attempt,
+          error,
+          readiness: currentReadiness,
+          onRemotePrepared: markRemoteRepaired,
+        });
+        repaired = true;
+        markRemoteRepaired();
+      }
+      await wait(attempt);
     }
-    throw error;
   }
+  throw lastError || new Error("candidate relay did not start");
 }
 
+function recoverableCandidateStartError(error) {
+  return error?.code === "relay_authentication_failed";
+}
 
-async function restoreStoppedProvider(startAutostart, { providerStopped, serviceStarted }) {
-  if (!providerStopped || serviceStarted) return;
-  const restored = await startAutostart();
-  if (restored?.ok === false) {
-    throw new Error(`previous autostart service could not be restored (${restored.provider || "unknown"})`);
+async function restoreCompatibleProvider({
+  installAutostart,
+  startAutostart,
+  restorePreviousAutostart,
+  inspectPreviousAutostart,
+  previousServiceRuntime,
+  restoreWait,
+  restoreMaximumAttempts,
+  providerStopped,
+  serviceStarted,
+  candidateServiceRequired,
+  candidateDefinitionRequired,
+}) {
+  if (serviceStarted || (!candidateServiceRequired && !providerStopped)) {
+    return { candidateServiceStarted: false };
+  }
+  if (candidateDefinitionRequired) {
+    const installed = await installAutostart();
+    if (installed?.ok !== true) {
+      throw new Error(`compatible candidate autostart could not be installed (${installed?.provider || "unknown"})`);
+    }
   }
+  const restored = candidateServiceRequired
+    ? await startAutostart()
+    : await restorePreviousAutostart();
+  const qualifier = candidateServiceRequired ? "compatible candidate" : "previous";
+  requireActiveServiceStart(restored, `${qualifier} autostart service recovery`);
+  if (!candidateServiceRequired) {
+    if (!previousServiceRuntime || typeof inspectPreviousAutostart !== "function") {
+      throw new Error("previous autostart service recovery lacks verified runtime identity evidence");
+    }
+    const convergence = await waitForRestoredServiceRuntime({
+      inspectDaemon: () => inspectPreviousAutostart(previousServiceRuntime),
+      expectedVersion: previousServiceRuntime.version,
+      maximumAttempts: restoreMaximumAttempts,
+      wait: restoreWait,
+    });
+    if (!convergence.ok) {
+      throw new Error(`previous autostart service recovery did not converge (${convergence.reason})`);
+    }
+  }
+  return { candidateServiceStarted: candidateServiceRequired };
+}
+
+function validateActivationOwnership(value) {
+  const daemon = value?.daemon || {};
+  const provider = value?.provider || {};
+  if (typeof provider.active !== "boolean") {
+    throw new Error(`the machine autostart state could not be verified before activation (${provider.provider || "unknown"})`);
+  }
+  if (daemon.alive === true) {
+    if (daemon.mode === "foreground" || daemon.identity_reason === "foreground_daemon") {
+      throw new Error(`a foreground daemon is active (pid ${daemon.pid || "unknown"}); stop it explicitly before activation`);
+    }
+    if (daemon.verified_service_daemon !== true || daemon.mode !== "service") {
+      throw new Error(`the existing workspace daemon identity could not be verified before activation (${daemon.identity_reason || "unknown"})`);
+    }
+  }
+  const previousServiceRuntimeActive = daemon.alive === true
+    && daemon.verified_service_daemon === true
+    && daemon.mode === "service";
+  if (provider.active === true && !previousServiceRuntimeActive) {
+    throw new Error("refusing to stop the active machine service because the selected workspace does not own its verified daemon");
+  }
+  let previousServiceRuntime = null;
+  if (previousServiceRuntimeActive) {
+    const evidence = value?.previousRuntime || {};
+    if (typeof evidence.version !== "string" || !evidence.version
+        || typeof evidence.entryScript !== "string" || !evidence.entryScript) {
+      throw new Error("the previous service daemon identity evidence is incomplete before activation");
+    }
+    previousServiceRuntime = { version: evidence.version, entryScript: evidence.entryScript };
+  }
+  return { previousServiceRuntimeActive, previousServiceRuntime };
+}
+
+function validateProviderStop(result) {
+  if (result?.ok !== true) {
+    throw new Error(`the existing autostart service could not be stopped before activation (${result?.provider || "unknown"})`);
+  }
+  if (typeof result.active_before !== "boolean" || result.active !== false || typeof result.restore_required !== "boolean") {
+    throw new Error(`the existing autostart stop state could not be verified before activation (${result?.provider || "unknown"})`);
+  }
+  return result.restore_required;
+}
+
+function requireActiveServiceStart(result, operation) {
+  if (result?.ok !== true || result.active !== true) {
+    throw new Error(`${operation} did not reach an active persistent service (${result?.provider || "unknown"})`);
+  }
+}
+
+function activationFailureWithRecovery(error) {
+  const message = error instanceof Error && error.message ? error.message : String(error || "activation failed");
+  const recoveredMessage = `${message}; a compatible candidate service was installed and started for automatic recovery`;
+  const recovered = error instanceof AggregateError
+    ? new AggregateError(error.errors, recoveredMessage, { cause: error })
+    : new Error(recoveredMessage, { cause: error });
+  if (error?.code) recovered.code = error.code;
+  recovered.activationRecovery = "candidate_service_started";
+  return recovered;
+}
+
+export async function waitForRestoredServiceRuntime({
+  inspectDaemon, expectedVersion, maximumAttempts = 240, wait = defaultWait,
+} = {}) {
+  if (typeof inspectDaemon !== "function") throw new TypeError("previous runtime recovery requires a daemon inspector");
+  const attempts = boundedAttempts(maximumAttempts);
+  let daemon = null;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    daemon = await inspectDaemon();
+    if (daemon?.alive && daemon?.verified_service_daemon
+        && daemon?.mode === "service" && daemon?.version === expectedVersion) {
+      return { ok: true, attempts: attempt, daemon };
+    }
+    if (attempt < attempts) await wait(attempt);
+  }
+  const reason = !daemon?.alive ? "daemon_not_running"
+    : daemon?.verified_service_daemon !== true ? `daemon_identity_${daemon?.identity_reason || "unverified"}`
+      : daemon?.mode !== "service" ? `daemon_mode_${daemon?.mode || "unknown"}`
+        : `daemon_version_${daemon?.version || "unknown"}`;
+  return { ok: false, attempts, daemon, reason };
 }
 
 export async function waitForActivatedRuntime({
@@ -126,7 +410,9 @@ export async function waitForActivatedRuntime({
   let worker = null;
   for (let attempt = 1; attempt <= attempts; attempt += 1) {
     daemon = await inspectDaemon();
-    if (daemon?.alive && daemon?.verified_service_daemon && daemon?.version === expectedVersion) {
+    if (daemon?.alive && daemon?.verified_service_daemon
+        && daemon?.startup_readiness_verified === true
+        && daemon?.version === expectedVersion) {
       worker = await checkWorker();
       if (worker?.ok && worker?.version === expectedVersion) {
         return { ok: true, attempts: attempt, daemon, worker };
@@ -137,12 +423,32 @@ export async function waitForActivatedRuntime({
   const reasons = [];
   if (!daemon?.alive) reasons.push("daemon_not_running");
   else if (!daemon?.verified_service_daemon) reasons.push(`daemon_identity_${daemon?.identity_reason || "unverified"}`);
+  else if (daemon?.startup_readiness_verified !== true) reasons.push("daemon_startup_readiness_unverified");
   else if (daemon?.version !== expectedVersion) reasons.push(`daemon_version_${daemon?.version || "unknown"}`);
   if (!worker?.ok) reasons.push(`worker_${worker?.error || "not_ready"}`);
   else if (worker?.version !== expectedVersion) reasons.push(`worker_version_${worker?.version || "unknown"}`);
   return { ok: false, attempts, daemon, worker, reason: reasons.join(",") || "activation_not_converged" };
 }
 
+function requiredExpectedVersion(value) {
+  if (typeof value !== "string" || !/^[0-9A-Za-z.+-]{1,128}$/.test(value)) {
+    throw new TypeError("runtime activation expectedVersion must be a bounded package version string");
+  }
+  return value;
+}
+
+function optionalFunction(value, name, fallback) {
+  if (value === undefined) return fallback;
+  if (typeof value !== "function") throw new TypeError(`runtime activation ${name} must be a function`);
+  return value;
+}
+
+function requireReleasableLock(lock, name) {
+  if (!lock || typeof lock.release !== "function") {
+    throw new TypeError(`runtime activation ${name} lock must expose release`);
+  }
+}
+
 function boundedAttempts(value) {
   const parsed = Number(value);
   if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > 1200) {
@@ -151,7 +457,20 @@ function boundedAttempts(value) {
   return parsed;
 }
 
+function boundedCandidateStartAttempts(value) {
+  const parsed = Number(value);
+  if (!Number.isSafeInteger(parsed) || parsed < 1 || parsed > 10) {
+    throw new Error("candidate relay start attempts must be between 1 and 10");
+  }
+  return parsed;
+}
+
 function defaultWait(attempt) {
   const delay = Math.min(1_000, 100 + attempt * 25);
   return new Promise((resolvePromise) => { setTimeout(resolvePromise, delay); });
 }
+
+function defaultCandidateRetryWait(attempt) {
+  const delay = Math.min(2_000, 250 * (2 ** Math.max(0, attempt - 1)));
+  return new Promise((resolvePromise) => { setTimeout(resolvePromise, delay); });
+}

package/src/local/runtime-capabilities.mjs

@@ -1,4 +1,6 @@
 import { classifyOperationalError } from "./log.mjs";
+import { buildExecutionRouting } from "./execution-routing.mjs";
+import { policyAllowsTool } from "./policy.mjs";
 
 export async function sessionBootstrap({
   agentContextManager,
@@ -7,9 +9,11 @@ export async function sessionBootstrap({
   policy,
 }, args = {}, context = {}) {
   const bootstrap = await agentContextManager.sessionBootstrap(args, context);
+  const applicationAllowed = policyAllowsTool(policy, "list_local_applications");
+  const browserAllowed = policyAllowsTool(policy, "browser_status");
   bootstrap.local_automation = {
-    applications: appAutomationManager.capabilities(),
-    browser: policy.profile === "full" ? {
+    applications: applicationAllowed ? appAutomationManager.capabilities() : null,
+    browser: browserAllowed ? {
       existing_profile: true,
       extension_bridge: true,
       status_tool: "browser_status",
@@ -27,7 +31,9 @@ export async function resolveTaskCapabilities({
 }, args = {}, context = {}) {
   const result = await agentContextManager.resolveTaskCapabilities(args, context);
   const task = String(args.task || "");
-  if (policy.profile === "full") {
+  const applicationAllowed = policyAllowsTool(policy, "list_local_applications");
+  const browserAllowed = policyAllowsTool(policy, "browser_status");
+  if (applicationAllowed) {
     let applications;
     try {
       applications = await appAutomationManager.listApplications({ query: "", max_results: 500 }, context);
@@ -49,7 +55,7 @@ export async function resolveTaskCapabilities({
       .map(({ application, score }) => ({ ...application, score }));
   } else {
     result.application_matches = [];
-    result.application_discovery = { available: false, warning_count: 0, truncated: false, reason: "policy" };
+    result.application_discovery = { available: false, warning_count: 0, truncated: false, reason: "effective_policy" };
   }
   if (result.application_matches.length) {
     result.recommended_tools = [...new Set([
@@ -60,10 +66,20 @@ export async function resolveTaskCapabilities({
       "operate_local_application",
     ])];
   }
-  result.browser_backend = policy.profile === "full"
+  result.browser_backend = browserAllowed
     ? { tool: "browser_status", existing_profile: true, extension_bridge: true }
     : null;
-  result.routing_observability = "Call server_info or project_overview to verify that bootstrap and task capability resolution reached the local runtime.";
+  const routing = buildExecutionRouting(task, {
+    policy,
+    seedTools: result.recommended_tools,
+    commandRelevant: (result.command_matches?.[0]?.score || 0) >= 3,
+    skillRelevant: (result.skill_matches?.[0]?.score || 0) >= 3,
+    applicationMatches: result.application_matches,
+    browserAvailable: browserAllowed,
+  });
+  result.execution_routing = routing;
+  result.recommended_tools = routing.recommended_tools;
+  result.routing_observability = "Call server_info or project_overview to verify that bootstrap and task capability resolution reached the local runtime. Routing is advisory and does not restrict direct shell or any other tool allowed by the effective policy.";
   capabilityObserver.recordResolution(task, result);
   return result;
 }

package/src/local/runtime-diagnostics.mjs

@@ -3,12 +3,16 @@ import { rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { classifyOperationalError } from "./log.mjs";
 import { readBoundedFile } from "./workspace-file-service.mjs";
+import { systemNetworkRouteCheck } from "./system-network-route.mjs";
+
+export const RUNTIME_DIAGNOSTIC_PROCESS_TIMEOUT_MS = 30_000;
 
 export async function diagnoseRuntime({
   policy,
   runtimeDir,
   workspace,
   runProcess,
+  runFixedInternal,
   probeShell,
   managedJobManager,
   relayStatus = () => null,
@@ -44,6 +48,8 @@ export async function diagnoseRuntime({
     layer: "remote-relay", ok: false, skipped: true, transport: "stdio-or-local",
   });
 
+  checks.push(await systemNetworkRouteCheck({ runFixedInternal, classifyError: classifyOperationalError, context }));
+
   const probe = join(runtimeDir, `.diagnostic-${process.pid}-${randomBytes(6).toString("hex")}`);
   try {
     await writeFile(probe, "ok\n", { mode: 0o600, flag: "wx" });
@@ -59,7 +65,7 @@ export async function diagnoseRuntime({
     const direct = await runProcess(
       process.execPath,
       ["-e", "process.stdout.write('ok')"],
-      5000,
+      RUNTIME_DIAGNOSTIC_PROCESS_TIMEOUT_MS,
       true,
       1024,
       context,
@@ -75,7 +81,7 @@ export async function diagnoseRuntime({
   }
 
   if (policy.execMode === "shell") {
-    const result = await probeShell(context)
+    const result = await probeShell(context, RUNTIME_DIAGNOSTIC_PROCESS_TIMEOUT_MS)
       .catch((error) => ({ code: 127, error_class: classifyOperationalError(error) }));
     checks.push({
       layer: "local-shell",
@@ -103,6 +109,7 @@ export async function diagnoseRuntime({
       tool_call_blocked_before_response: "host/platform or connector gateway",
       diagnostic_reached_daemon_but_spawn_failed: "local OS, endpoint security, shell configuration, or Machine Bridge policy",
       system_network_stack_scope: "application proxy selection only; an operating-system VPN or TUN may still intercept the relay connection",
+      tunnel_default_route_detected: "the operating-system route is carried by a VPN/TUN; node selection and repair remain outside Machine Bridge",
       managed_job_accepted_then_later_tools_blocked: "job continues independently; inspect with local CLI or a later read_job call",
     },
     policy,

package/src/local/runtime.mjs

@@ -334,7 +334,20 @@ export class LocalRuntime {
       this.relayResumeSessionId = 0;
       return true;
     }
-    if (message.type === "pong") return true;
+    if (message.type === "pong") {
+      this.relayCallRecovery.pulse();
+      return true;
+    }
+    if (message.type === "tool_result_ack") {
+      if (!isRelayReadyContext(relayContext, this.relay)
+          || typeof message.id !== "string"
+          || !/^call_[A-Za-z0-9_-]{8,240}$/.test(message.id)) {
+        this.handleRelayProtocolViolation("invalid_tool_result_ack");
+        return true;
+      }
+      this.relayCallRecovery.acknowledge(message.id);
+      return true;
+    }
     if (message.type === "error") {
       this.relay?.handleServerError(message);
       return true;
@@ -516,7 +529,8 @@ export class LocalRuntime {
       runtimeDir: this.runtimeDir,
       workspace: this.workspace,
       runProcess: (...args) => this.runProcess(...args),
-      probeShell: (callContext) => this.processExecutionService.probeShell(callContext),
+      runFixedInternal: (...args) => this.processExecutionService.runFixedInternal(...args),
+      probeShell: (callContext, timeoutMs) => this.processExecutionService.probeShell(callContext, timeoutMs),
       managedJobManager: this.managedJobManager,
       relayStatus: () => this.relay?.status?.() || null,
       throwIfCancelled: (callContext) => this.throwIfCancelled(callContext),
@@ -533,7 +547,7 @@ export class LocalRuntime {
       agentContextManager: this.agentContextManager,
       appAutomationManager: this.appAutomationManager,
       capabilityObserver: this.capabilityObserver,
-      policy: this.policy,
+      policy: this.effectivePolicy(context),
     }, args, context);
   }
 
@@ -542,7 +556,7 @@ export class LocalRuntime {
       agentContextManager: this.agentContextManager,
       appAutomationManager: this.appAutomationManager,
       capabilityObserver: this.capabilityObserver,
-      policy: this.policy,
+      policy: this.effectivePolicy(context),
     }, args, context);
   }