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

package/src/local/daemon-http-relay-auth.mjs

@@ -0,0 +1,26 @@
+import { createHash, randomBytes } from "node:crypto";
+import { DAEMON_HTTP_RELAY_SCHEME, daemonHttpRelayTranscript } from "../shared/daemon-auth.mjs";
+import { encodeDeviceSessionCertificate, signWithDeviceSessionIdentity, validateDeviceSessionIdentity } from "./device-identity.mjs";
+
+const SESSION_CERTIFICATE_HEADER = "X-Bridge-Device-Certificate";
+
+export function createDaemonHttpRelayHeaders(identity, workerOrigin, server, version, body, now = Date.now()) {
+  validateDeviceSessionIdentity(identity, now);
+  const issuedAt = Math.floor(Number(now) / 1000);
+  if (!Number.isSafeInteger(issuedAt) || issuedAt <= 0) throw new Error("daemon HTTP relay timestamp is invalid");
+  const nonce = randomBytes(24).toString("base64url");
+  const bodySha256 = createHash("sha256").update(body).digest("base64url");
+  const signature = signWithDeviceSessionIdentity(identity, daemonHttpRelayTranscript({
+    workerOrigin, server, version, nonce, issuedAt, bodySha256,
+  }));
+  return {
+    "content-type": "application/json; charset=utf-8",
+    "X-Bridge-Device-Scheme": DAEMON_HTTP_RELAY_SCHEME,
+    "X-Bridge-Device-Key": identity.keyId,
+    "X-Bridge-Device-Nonce": nonce,
+    "X-Bridge-Device-Time": String(issuedAt),
+    "X-Bridge-Body-SHA256": bodySha256,
+    "X-Bridge-Device-Signature": signature,
+    [SESSION_CERTIFICATE_HEADER]: encodeDeviceSessionCertificate(identity),
+  };
+}

package/src/local/daemon-http-relay-connection.mjs

@@ -0,0 +1,298 @@
+import { performance } from "node:perf_hooks";
+import { randomBytes } from "node:crypto";
+import relayContract from "../shared/relay-contract.json" with { type: "json" };
+import { readinessMismatch } from "./relay-connection-classification.mjs";
+import { classifyOperationalError } from "./log.mjs";
+import { createDaemonHttpRelayHeaders } from "./daemon-http-relay-auth.mjs";
+import { postDaemonHttpRelay } from "./daemon-http-relay-request.mjs";
+import { RelayInboundSequence, RelayOutboundSequence } from "./daemon-http-relay-sequence.mjs";
+
+const HTTP_SESSION_ID = /^relay_http_[A-Za-z0-9_-]{43}$/;
+const ACTIVATION_TOKEN = /^activate_[A-Za-z0-9_-]{43}$/;
+
+export class DaemonHttpRelayConnection {
+  constructor(options = {}) {
+    this.workerUrl = String(options.workerUrl || "").replace(/\/$/, "");
+    this.endpoint = `${this.workerUrl}/daemon/http`;
+    this.deviceIdentity = options.deviceIdentity;
+    this.expectedServer = String(options.expectedServer || "");
+    this.expectedVersion = String(options.expectedVersion || "");
+    this.instanceId = String(options.instanceId || "");
+    this.descriptor = typeof options.descriptor === "function" ? options.descriptor : () => ({});
+    this.ownedCallIds = typeof options.ownedCallIds === "function" ? options.ownedCallIds : () => [];
+    this.onMessage = typeof options.onMessage === "function" ? options.onMessage : () => {};
+    this.onReady = typeof options.onReady === "function" ? options.onReady : () => {};
+    this.onDisconnect = typeof options.onDisconnect === "function" ? options.onDisconnect : () => {};
+    this.logger = options.logger || {};
+    this.now = typeof options.now === "function" ? options.now : () => performance.now();
+    this.wallNow = typeof options.wallNow === "function" ? options.wallNow : Date.now;
+    this.scheduler = options.scheduler || { setTimeout, clearTimeout };
+    this.postRequest = typeof options.postRequest === "function" ? options.postRequest : postDaemonHttpRelay;
+    this.pollIntervalMs = positiveInteger(options.pollIntervalMs, relayContract.httpFallbackPollIntervalMs);
+    this.minimumRequestIntervalMs = positiveInteger(options.minimumRequestIntervalMs, relayContract.httpFallbackMinimumRequestIntervalMs);
+    this.requestTimeoutMs = positiveInteger(options.requestTimeoutMs, relayContract.httpFallbackRequestTimeoutMs);
+    this.livenessTimeoutMs = positiveInteger(options.livenessTimeoutMs, relayContract.httpFallbackLivenessTimeoutMs);
+    this.sessionIdBase = positiveInteger(options.sessionIdBase, 1_000_000_000);
+    this.outbound = new RelayOutboundSequence();
+    this.inbound = new RelayInboundSequence();
+    this.closed = true;
+    this.ready = false;
+    this.localReady = false;
+    this.authenticated = false;
+    this.activeSessionId = 0;
+    this.sessionGeneration = 0;
+    this.transportSessionId = "";
+    this.activationToken = "";
+    this.pollTimer = null;
+    this.inFlight = null;
+    this.lastSuccessAt = 0;
+    this.lastSuccessWallAt = 0;
+    this.lastErrorClass = "";
+    this.networkRoute = "system-network-stack";
+    this.consecutiveFailures = 0;
+    this.lastRequestStartedAt = Number.NEGATIVE_INFINITY;
+    this.takeoverWebSocket = false;
+  }
+
+  start(options = {}) {
+    if (options.takeoverWebSocket === true) this.takeoverWebSocket = true;
+    if (!this.closed) { this.schedulePoll(0); return; }
+    this.closed = false;
+    this.resetSession(false);
+    this.schedulePoll(0);
+  }
+
+  stop() {
+    if (this.closed) return;
+    this.closed = true;
+    this.clearPollTimer();
+    this.inFlight?.abort?.("daemon HTTP relay stopped");
+    this.inFlight = null;
+    this.ready = false;
+    this.localReady = false;
+    this.authenticated = false;
+    this.activeSessionId = 0;
+    this.outbound.reset();
+    this.inbound.reset();
+    this.takeoverWebSocket = false;
+  }
+
+  status() {
+    return {
+      transport: "https",
+      authenticated: this.authenticated,
+      ready: this.ready,
+      closed: this.closed,
+      network_route: this.networkRoute,
+      application_heartbeat_interval_ms: this.pollIntervalMs,
+      application_heartbeat_timeout_ms: this.livenessTimeoutMs,
+      last_ready_at: this.lastSuccessWallAt ? new Date(this.lastSuccessWallAt).toISOString() : null,
+      last_transport_error_class: this.lastErrorClass || null,
+      http_poll_failures: this.consecutiveFailures,
+    };
+  }
+
+  currentSessionId() { return this.authenticated ? this.activeSessionId : 0; }
+
+  send(value) {
+    if (!this.ready || this.closed) return false;
+    try { this.outbound.enqueue(value); this.schedulePoll(0); return true; }
+    catch (error) {
+      this.lastErrorClass = classifyOperationalError(error);
+      return false;
+    }
+  }
+
+  sendForSession(value, expectedSessionId) {
+    const sessionId = Number(expectedSessionId) || 0;
+    if (!sessionId || sessionId !== this.activeSessionId) return { ok: false, reason: "session_ended" };
+    if (this.closed || !this.authenticated) return { ok: false, reason: "transport_unavailable" };
+    const preReadyControl = ["resume_calls_ack", "authority_revoke_ack"].includes(String(value?.type || ""));
+    if (!this.ready && !preReadyControl) return { ok: false, reason: "transport_unavailable" };
+    try { this.outbound.enqueue(value); this.schedulePoll(0); return { ok: true, reason: "sent" }; }
+    catch { return { ok: false, reason: "send_failed" }; }
+  }
+
+  confirmReady(message = {}) {
+    if (this.closed || !this.authenticated || this.localReady) return false;
+    const mismatch = readinessMismatch(message, this.expectedServer, this.expectedVersion);
+    if (mismatch) { this.resetSession(true); return false; }
+    this.outbound.enqueue({ type: "https_ready" });
+    this.localReady = true;
+    return true;
+  }
+
+  interrupt() {
+    if (this.closed) return false;
+    this.inFlight?.abort?.("daemon HTTP relay interrupted");
+    this.resetSession(true);
+    this.schedulePoll(0);
+    return true;
+  }
+
+  async poll() {
+    if (this.closed || this.inFlight) return;
+    this.clearPollTimer();
+    const now = this.now();
+    const earliest = this.lastRequestStartedAt + this.minimumRequestIntervalMs;
+    if (now < earliest) { this.schedulePoll(earliest - now); return; }
+    this.lastRequestStartedAt = now;
+    const descriptor = this.activationToken ? null : (this.descriptor() || {});
+    const body = JSON.stringify({
+      protocol: 1,
+      session_id: this.transportSessionId,
+      instance_id: this.instanceId,
+      ...(this.activationToken ? { activation_token: this.activationToken } : {}),
+      ack_worker_seq: this.inbound.acknowledged,
+      owned_call_ids: [...this.ownedCallIds()].slice(0, 32),
+      messages: this.outbound.snapshot(),
+      ...(this.takeoverWebSocket ? { takeover_websocket: true } : {}),
+      ...(descriptor ? {
+        tools: descriptor.tools ?? [], policy: descriptor.policy ?? {},
+        relay_diagnostics: descriptor.relayDiagnostics ?? {},
+      } : {}),
+    });
+    const controller = new AbortController();
+    this.inFlight = controller;
+    try {
+      const headers = createDaemonHttpRelayHeaders(
+        this.deviceIdentity, this.workerUrl, this.expectedServer, this.expectedVersion, body, this.wallNow(),
+      );
+      const response = await this.postRequest({
+        url: this.endpoint, headers, body, timeoutMs: this.requestTimeoutMs,
+        maximumResponseBytes: relayContract.httpFallbackMaximumEnvelopeBytes, signal: controller.signal,
+      });
+      if (this.inFlight !== controller || this.closed) return;
+      this.networkRoute = response.networkRoute || this.networkRoute;
+      await this.handleResponse(response.statusCode, response.body);
+    } catch (error) {
+      if (this.inFlight !== controller || this.closed) return;
+      this.handleFailure(error);
+    } finally {
+      if (this.inFlight === controller) this.inFlight = null;
+    }
+    if (!this.closed) this.schedulePoll(this.nextPollDelay());
+  }
+
+  async handleResponse(statusCode, text) {
+    if (statusCode === 404 || statusCode === 405 || statusCode === 426) {
+      this.handleFailure(Object.assign(new Error("daemon HTTP fallback is not supported by the Worker"), { code: "daemon_http_unsupported" }));
+      return;
+    }
+    if (statusCode === 401 || statusCode === 403) {
+      this.handleFailure(Object.assign(new Error("daemon HTTP fallback authentication failed"), { code: "authentication_failed" }));
+      return;
+    }
+    if (statusCode === 409) {
+      this.resetSession(true);
+      return;
+    }
+    if (statusCode < 200 || statusCode >= 300) {
+      this.handleFailure(Object.assign(new Error("daemon HTTP fallback request failed"), { code: "network_error" }));
+      return;
+    }
+    let body;
+    try { body = JSON.parse(String(text || "")); } catch {
+      this.resetSession(true); return;
+    }
+    if (!validResponse(body)) { this.resetSession(true); return; }
+    if (!this.outbound.acknowledge(body.ack_daemon_seq)) { this.resetSession(true); return; }
+    this.lastSuccessAt = this.now();
+    this.lastSuccessWallAt = this.wallNow();
+    this.lastErrorClass = "";
+    this.consecutiveFailures = 0;
+    if (body.phase === "standby") { this.resetSession(this.ready); return; }
+    if (!this.authenticated) {
+      this.authenticated = true;
+      this.sessionGeneration += 1;
+      this.activeSessionId = this.sessionIdBase + this.sessionGeneration;
+      this.activationToken = body.activation_token;
+    }
+    if (body.phase === "ready" && this.localReady && !this.ready) {
+      this.ready = true;
+      try { this.onReady({ reconnected: true, sessionId: this.activeSessionId, transport: "https" }); }
+      catch { /* Readiness notification is advisory; the authenticated transport state is already committed. */ }
+    }
+    for (const message of body.messages) {
+      const sequence = this.inbound.classify(message.seq);
+      if (sequence === "duplicate") continue;
+      if (sequence === "gap") { this.resetSession(true); return; }
+      const handlingSessionId = this.activeSessionId;
+      const context = { sessionId: this.activeSessionId, authenticated: true, ready: this.ready, transport: "https" };
+      let outcome;
+      try { outcome = this.onMessage(JSON.stringify(message.payload), context); }
+      catch (error) { this.logger.error?.("daemon HTTP relay message handler failed", { error_class: classifyOperationalError(error) }); return; }
+      if (message.payload?.type === "tool_call") {
+        if (this.closed || !this.authenticated || this.activeSessionId !== handlingSessionId) return;
+        this.inbound.commit(message.seq);
+        if (outcome && typeof outcome.catch === "function") {
+          outcome.catch((error) => this.logger.error?.("daemon HTTP relay message handler failed", { error_class: classifyOperationalError(error) }));
+        }
+        continue;
+      }
+      try { await outcome; }
+      catch (error) { this.logger.error?.("daemon HTTP relay control handler failed", { error_class: classifyOperationalError(error) }); return; }
+      if (this.closed || !this.authenticated || this.activeSessionId !== handlingSessionId) return;
+      this.inbound.commit(message.seq);
+    }
+  }
+
+  handleFailure(error) {
+    this.lastErrorClass = classifyOperationalError(error);
+    this.consecutiveFailures += 1;
+    if (!this.ready || !this.lastSuccessAt || this.now() - this.lastSuccessAt < this.livenessTimeoutMs) return;
+    this.resetSession(true);
+  }
+
+  resetSession(notify) {
+    const wasReady = this.ready;
+    this.ready = false;
+    this.localReady = false;
+    this.authenticated = false;
+    this.activeSessionId = 0;
+    this.activationToken = "";
+    this.transportSessionId = `relay_http_${randomBytes(32).toString("base64url")}`;
+    if (!HTTP_SESSION_ID.test(this.transportSessionId)) throw new Error("could not create daemon HTTP relay session id");
+    this.outbound.reset();
+    this.inbound.reset();
+    if (notify && wasReady) {
+      try { this.onDisconnect({ transport: "https" }); }
+      catch { /* Disconnect notification cannot restore the closed transport and must not block session reset. */ }
+    }
+  }
+
+  nextPollDelay() {
+    if (!this.authenticated || !this.ready || this.outbound.messages.length > 0) return 0;
+    return this.pollIntervalMs;
+  }
+
+  schedulePoll(delay) {
+    if (this.closed || this.inFlight) return;
+    const earliestDelay = Math.max(0, this.lastRequestStartedAt + this.minimumRequestIntervalMs - this.now());
+    const boundedDelay = Math.max(earliestDelay, Number(delay) || 0);
+    if (this.pollTimer && boundedDelay > 0) return;
+    this.clearPollTimer();
+    this.pollTimer = this.scheduler.setTimeout(() => { this.pollTimer = null; void this.poll(); }, boundedDelay);
+    this.pollTimer?.unref?.();
+  }
+
+  clearPollTimer() {
+    if (!this.pollTimer) return;
+    this.scheduler.clearTimeout(this.pollTimer);
+    this.pollTimer = null;
+  }
+}
+
+function validResponse(body) {
+  if (!body || typeof body !== "object" || Array.isArray(body) || body.protocol !== 1) return false;
+  if (!["probing", "ready", "standby"].includes(body.phase)) return false;
+  if (!Number.isSafeInteger(body.ack_daemon_seq) || body.ack_daemon_seq < 0 || !Array.isArray(body.messages) || body.messages.length > 64) return false;
+  if (body.phase !== "standby" && (typeof body.activation_token !== "string" || !ACTIVATION_TOKEN.test(body.activation_token))) return false;
+  return body.messages.every((message) => message && typeof message === "object" && !Array.isArray(message)
+    && Number.isSafeInteger(message.seq) && message.seq > 0 && message.payload && typeof message.payload === "object" && !Array.isArray(message.payload));
+}
+
+function positiveInteger(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.floor(number) : fallback;
+}

package/src/local/daemon-http-relay-request.mjs

@@ -0,0 +1,64 @@
+import http from "node:http";
+import https from "node:https";
+import { proxyAgentForHttp } from "./network-proxy.mjs";
+
+export function postDaemonHttpRelay({ url, headers, body, timeoutMs, maximumResponseBytes, signal }) {
+  return new Promise((resolve, reject) => {
+    const target = new URL(String(url));
+    const client = target.protocol === "https:" ? https : target.protocol === "http:" ? http : null;
+    if (!client) { reject(relayRequestError("daemon_http_invalid_url", "daemon HTTP relay URL must use HTTP or HTTPS")); return; }
+    let proxy;
+    try { proxy = proxyAgentForHttp(target.href); }
+    catch (error) { reject(error); return; }
+    let settled = false;
+    let timer = null;
+    const finish = (error, value) => {
+      if (settled) return;
+      settled = true;
+      if (timer) clearTimeout(timer);
+      error ? reject(error) : resolve(value);
+    };
+    const request = client.request(target, {
+      method: "POST", headers, ...(proxy.agent ? { agent: proxy.agent } : {}), ...(signal ? { signal } : {}),
+    }, (response) => {
+      const declared = Number(response.headers["content-length"] || 0);
+      if (Number.isFinite(declared) && declared > maximumResponseBytes) {
+        response.destroy();
+        finish(relayRequestError("daemon_http_response_too_large", "daemon HTTP relay response exceeded its byte limit"));
+        return;
+      }
+      const chunks = [];
+      let observed = 0;
+      response.on("data", (chunk) => {
+        if (settled) return;
+        observed += chunk.length;
+        if (observed > maximumResponseBytes) {
+          response.destroy();
+          finish(relayRequestError("daemon_http_response_too_large", "daemon HTTP relay response exceeded its byte limit"));
+          return;
+        }
+        chunks.push(chunk);
+      });
+      response.on("end", () => finish(null, {
+        statusCode: Number(response.statusCode) || 0,
+        body: Buffer.concat(chunks, observed).toString("utf8"),
+        networkRoute: proxy.agent ? "application-http-proxy" : "system-network-stack",
+      }));
+      response.on("error", (error) => finish(error));
+    });
+    request.on("error", (error) => finish(error));
+    timer = setTimeout(() => {
+      const error = relayRequestError("daemon_http_timeout", "daemon HTTP relay request timed out");
+      request.destroy(error);
+      finish(error);
+    }, Math.max(1, Number(timeoutMs) || 1));
+    timer.unref?.();
+    request.end(body);
+  });
+}
+
+function relayRequestError(code, message) {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}

package/src/local/daemon-http-relay-sequence.mjs

@@ -0,0 +1,49 @@
+import relayContract from "../shared/relay-contract.json" with { type: "json" };
+
+export class RelayOutboundSequence {
+  constructor() { this.next = 1; this.acknowledged = 0; this.bytes = 0; this.messages = []; }
+  enqueue(payload) {
+    const serialized = JSON.stringify(payload);
+    const bytes = Buffer.byteLength(serialized);
+    if (bytes > relayContract.httpFallbackMaximumMessageBytes
+        || this.messages.length >= relayContract.httpFallbackMaximumQueuedMessages
+        || this.bytes + bytes > relayContract.httpFallbackMaximumQueuedBytes) {
+      throw new Error("daemon HTTP relay outbound queue capacity exceeded");
+    }
+    this.messages.push({ seq: this.next++, payload, bytes });
+    this.bytes += bytes;
+  }
+  acknowledge(sequence) {
+    if (!Number.isSafeInteger(sequence) || sequence < 0 || sequence >= this.next) return false;
+    if (sequence <= this.acknowledged) return true;
+    this.acknowledged = sequence;
+    while (this.messages[0]?.seq <= sequence) {
+      const removed = this.messages.shift();
+      if (removed) this.bytes = Math.max(0, this.bytes - removed.bytes);
+    }
+    return true;
+  }
+  snapshot() {
+    const selected = []; let bytes = 0;
+    for (const message of this.messages) {
+      if (selected.length > 0 && bytes + message.bytes > relayContract.httpFallbackMaximumEnvelopeBytes) break;
+      selected.push({ seq: message.seq, payload: message.payload }); bytes += message.bytes;
+    }
+    return selected;
+  }
+  reset() { this.next = 1; this.acknowledged = 0; this.bytes = 0; this.messages.length = 0; }
+}
+
+export class RelayInboundSequence {
+  constructor() { this.acknowledged = 0; }
+  classify(sequence) {
+    if (!Number.isSafeInteger(sequence) || sequence <= 0) return "gap";
+    if (sequence <= this.acknowledged) return "duplicate";
+    return sequence === this.acknowledged + 1 ? "new" : "gap";
+  }
+  commit(sequence) {
+    if (sequence !== this.acknowledged + 1) throw new Error("daemon HTTP relay inbound sequence is not contiguous");
+    this.acknowledged = sequence;
+  }
+  reset() { this.acknowledged = 0; }
+}

package/src/local/daemon-process.mjs

@@ -1,3 +1,4 @@
+import { realpathSync } from "node:fs";
 import path from "node:path";
 import process from "node:process";
 import {
@@ -76,7 +77,7 @@ export async function stopWorkspaceServiceDaemon(state, options = {}) {
       verified = true;
       if (!signalled.has(Number(owner.pid))) {
         const purpose = options.reason || "service stop";
-        logger.info?.(`stopping detached background daemon (pid ${owner.pid}) for ${purpose}`);
+        logger.info?.(`stopping detached background daemon for ${purpose}`);
         try {
           process.kill(Number(owner.pid), "SIGTERM");
         } catch (error) {
@@ -105,7 +106,7 @@ export async function stopWorkspaceServiceDaemon(state, options = {}) {
       if (!current.current) continue;
       const identity = inspectWorkspaceDaemonOwner(state, signalState.owner);
       if (!identity.verified_service_daemon) continue;
-      logger.warn?.(`detached background daemon ignored graceful termination; forcing process ${pid} to stop`);
+      logger.warn?.("detached background daemon ignored graceful termination; forcing it to stop");
       try {
         process.kill(pid, "SIGKILL");
         signalState.forced = true;
@@ -165,23 +166,38 @@ export async function stopWorkspaceServiceDaemon(state, options = {}) {
   };
 }
 
-export function inspectWorkspaceDaemon(state) {
+export function workspaceDaemonOwnsPlatformAutostart(status = {}) {
+  return status.alive === true
+    && status.verified_service_daemon === true
+    && status.mode === "service";
+}
+
+export function inspectWorkspaceDaemon(state, options = {}) {
   const owner = readDaemonLockOwner(daemonLockPathForState(state));
-  if (!owner) return { present: false, alive: false, verified_service_daemon: false };
+  if (!owner) return { present: false, alive: false, verified_service_daemon: false, startup_readiness_verified: false };
   const alive = Boolean(owner.pid && isPidAlive(owner.pid));
-  const identity = alive
-    ? inspectWorkspaceDaemonOwner(state, owner)
+  let identity = alive
+    ? inspectWorkspaceDaemonOwner(state, owner, options)
     : { verified_service_daemon: false, reason: "stale_lock" };
+  if (identity.verified_service_daemon && options.expectedVersion
+      && owner.version !== options.expectedVersion) {
+    identity = { verified_service_daemon: false, reason: "version_mismatch" };
+  }
+  if (identity.verified_service_daemon && options.expectedEntryScript
+      && !sameCanonicalFile(owner.entryScript, options.expectedEntryScript)) {
+    identity = { verified_service_daemon: false, reason: "entrypoint_mismatch" };
+  }
   return {
     present: true,
     alive,
     verified_service_daemon: identity.verified_service_daemon,
     identity_reason: identity.reason,
+    startup_readiness_verified: identity.verified_service_daemon && owner.startupReady === true,
     ...publicDaemonOwner(owner),
   };
 }
 
-function inspectWorkspaceDaemonOwner(state, owner) {
+function inspectWorkspaceDaemonOwner(state, owner, options = {}) {
   if (!owner || owner.purpose !== "daemon") return { verified_service_daemon: false, reason: "invalid_lock_owner" };
   const pid = Number(owner.pid);
   if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid) return { verified_service_daemon: false, reason: "invalid_pid" };
@@ -190,12 +206,18 @@ function inspectWorkspaceDaemonOwner(state, owner) {
   if (!sameCanonicalPath(owner.workspace, state.workspace.path)) return { verified_service_daemon: false, reason: "workspace_mismatch" };
   if (owner.mode === "foreground") return { verified_service_daemon: false, reason: "foreground_daemon" };
   if (owner.mode !== "service") return { verified_service_daemon: false, reason: "invalid_daemon_mode" };
+  if (options.expectedNodeVersion && owner.nodeVersion !== String(options.expectedNodeVersion)) {
+    return { verified_service_daemon: false, reason: "node_version_mismatch" };
+  }
 
   const command = processCommandLine(pid);
   if (!command) {
     return { verified_service_daemon: false, reason: "service_identity_unavailable" };
   }
   const argv = splitProcessCommandLine(command);
+  if (options.expectedNodeExecutable && !sameCanonicalFile(argv[0], options.expectedNodeExecutable)) {
+    return { verified_service_daemon: false, reason: "node_executable_mismatch" };
+  }
   const entryName = path.basename(String(owner.entryScript || "machine-mcp"));
   const workspaceArg = commandFlagValue(argv, "--workspace");
   const stateRootArg = commandFlagValue(argv, "--state-dir");
@@ -233,6 +255,17 @@ function sameCanonicalPath(left, right) {
   }
 }
 
+function sameCanonicalFile(left, right) {
+  if (typeof left !== "string" || typeof right !== "string") return false;
+  try {
+    const a = realpathSync(left);
+    const b = realpathSync(right);
+    return process.platform === "win32" ? a.toLowerCase() === b.toLowerCase() : a === b;
+  } catch {
+    return false;
+  }
+}
+
 function publicDaemonOwner(owner) {
   return {
     pid: Number(owner?.pid) || null,