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

package/src/local/policy.mjs

@@ -111,6 +111,25 @@ export function normalizePolicy(policy = {}) {
   return Object.freeze(normalized);
 }
 
+/** @param {PolicyInput} left @param {PolicyInput} right @param {{profile?: string, origin?: string}} [options] */
+export function intersectPolicies(left, right, options = {}) {
+  const a = normalizePolicy(left);
+  const b = normalizePolicy(right);
+  const rank = { off: 0, direct: 1, shell: 2 };
+  const execMode = rank[a.execMode] <= rank[b.execMode] ? a.execMode : b.execMode;
+  return Object.freeze({
+    profile: typeof options.profile === "string" && options.profile ? options.profile : "custom",
+    origin: typeof options.origin === "string" && options.origin ? options.origin : "custom",
+    revision: Math.max(a.revision, b.revision),
+    allowWrite: a.allowWrite && b.allowWrite,
+    allowExec: execMode !== "off",
+    execMode,
+    unrestrictedPaths: a.unrestrictedPaths && b.unrestrictedPaths,
+    minimalEnv: a.minimalEnv || b.minimalEnv,
+    exposeAbsolutePaths: a.exposeAbsolutePaths && b.exposeAbsolutePaths,
+  });
+}
+
 /** @param {PolicyCapabilities} left @param {PolicyCapabilities} right */
 export function policyCapabilitiesEqual(left, right) {
   return left.allowWrite === right.allowWrite

package/src/local/process-execution.mjs

@@ -6,6 +6,7 @@ import { executionEnv, workspaceShellCommand } from "./shell.mjs";
 import { MAX_COMMAND_BYTES, validateArgv } from "./process-contract.mjs";
 import { terminateProcessTreeWithEscalation } from "./process-tree.mjs";
 import { BridgeError } from "./errors.mjs";
+import { delegatedProcessCommand } from "./delegated-process-sandbox.mjs";
 import { clampInteger } from "./numbers.mjs";
 import { ProcessOutputStream } from "./process-output-stream.mjs";
 import { processFailureMessage, publicProcessToolResult } from "./process-result-projection.mjs";
@@ -19,8 +20,7 @@ import {
   PUBLIC_PROCESS_INLINE_OUTPUT_BYTES,
 } from "./execution-limits.mjs";
 
-const PROCESS_OUTPUT_CAPTURE = Symbol("process-output-capture");
-const CONTINUATION_READ_BYTES = 64 * 1024;
+const PROCESS_OUTPUT_CAPTURE = Symbol("process-output-capture"); const CONTINUATION_READ_BYTES = 64 * 1024;
 
 function spawnDirectProcess(command, args, options) {
   // Keep the production child_process API call structurally separate from the
@@ -35,10 +35,11 @@ function spawnDirectProcess(command, args, options) {
 }
 
 export class ProcessExecutionService {
-  constructor({ workspace, policy, policyGate, runtimeDir, processTracker, resolveExistingPath, resolveLocalCommand, displayPath, throwIfCancelled, retainCompletedOutput = null, spawnProcess = spawnDirectProcess, terminateProcess = terminateProcessTreeWithEscalation }) {
+  constructor({ workspace, policy, policyGate, policyForContext = null, runtimeDir, processTracker, resolveExistingPath, resolveLocalCommand, displayPath, throwIfCancelled, retainCompletedOutput = null, spawnProcess = spawnDirectProcess, terminateProcess = terminateProcessTreeWithEscalation }) {
     this.workspace = workspace;
     this.policy = policy;
     this.policyGate = policyGate;
+    this.policyForContext = typeof policyForContext === "function" ? policyForContext : () => this.policy;
     this.runtimeDir = runtimeDir;
     this.processTracker = processTracker;
     this.resolveExistingPath = resolveExistingPath;
@@ -53,7 +54,7 @@ export class ProcessExecutionService {
   async runDirect(args, context = {}) {
     this.policyGate.assert("run_process");
     const argv = validateArgv(args.argv);
-    const cwd = await this.resolveExistingPath(args.cwd || ".");
+    const cwd = await this.resolveExistingPath(args.cwd || ".", context);
     if (!(await stat(cwd)).isDirectory()) throw new BridgeError("invalid_request", "cwd is not a directory");
     const result = await this.runPublic(
       argv[0], argv.slice(1),
@@ -67,14 +68,14 @@ export class ProcessExecutionService {
     this.policyGate.assert("run_local_command");
     const command = await this.resolveLocalCommand(args, context);
     const argv = validateArgv(command.argv);
-    const cwd = await this.resolveExistingPath(command.cwd);
+    const cwd = await this.resolveExistingPath(command.cwd, context);
     if (!(await stat(cwd)).isDirectory()) throw new BridgeError("invalid_request", "registered command cwd is not a directory");
     const requested = args.timeout_seconds === undefined
       ? command.timeoutSeconds
       : clampInteger(args.timeout_seconds, command.timeoutSeconds, MIN_PROCESS_TIMEOUT_SECONDS, MAX_PROCESS_TIMEOUT_SECONDS);
     const timeoutSeconds = Math.min(requested, command.timeoutSeconds);
     const result = await this.runPublic(argv[0], argv.slice(1), timeoutSeconds * 1000, context, cwd);
-    return publicProcessToolResult({ name: command.name, cwd: this.displayPath(cwd), timeout_seconds: timeoutSeconds, ...result });
+    return publicProcessToolResult({ name: command.name, cwd: this.displayPath(cwd, context), timeout_seconds: timeoutSeconds, ...result });
   }
 
   async probeShell(context = {}) {
@@ -82,6 +83,10 @@ export class ProcessExecutionService {
     return this.run(shell.cmd, shell.args, 5000, true, 64 * 1024, context);
   }
 
+  async runFixedInternal(cmd, args, timeoutMs, allowFailure = false, maxOutputBytes = DEFAULT_PROCESS_OUTPUT_BYTES, context = {}, cwd = this.workspace) {
+    const argv = validateArgv([cmd, ...args]);
+    return this.run(argv[0], argv.slice(1), timeoutMs, allowFailure, maxOutputBytes, context, cwd, null, { internalFixed: true });
+  }
   async runShell(command, timeoutSeconds, context = {}) {
     this.policyGate.assert("exec_command");
     if (!command || typeof command !== "string") throw new BridgeError("invalid_request", "command is required");
@@ -114,7 +119,7 @@ export class ProcessExecutionService {
         command: basename(cmd), cwd,
         stdout: capture.stdout, stderr: capture.stderr,
         exitCode: result.code, startedAt, closedAt: Date.now(),
-      });
+      }, context);
       if (session) {
         continuation = {
           output_session_id: session.session_id,
@@ -155,9 +160,16 @@ export class ProcessExecutionService {
       const retainedStderr = options.retainOutput ? new ProcessOutputStream(MAX_PROCESS_SESSION_OUTPUT_BYTES) : null;
       let child;
       try {
-        child = this.spawnProcess(cmd, args, {
+        const internalFixed = options.internalFixed === true;
+        const launch = internalFixed
+          ? { command: cmd, args }
+          : delegatedProcessCommand({ command: cmd, args, workspace: this.workspace, runtimeDir: this.runtimeDir, context });
+        child = this.spawnProcess(launch.command, launch.args, {
           cwd,
-          env: executionEnv(this.workspace, { fullEnv: this.policy.minimalEnv === false, runtimeDir: this.runtimeDir }),
+          env: executionEnv(this.workspace, {
+            fullEnv: internalFixed ? false : this.policyForContext(context).minimalEnv === false,
+            runtimeDir: this.runtimeDir,
+          }),
           detached: process.platform !== "win32",
           windowsHide: true,
           shell: false,

package/src/local/process-sessions.mjs

@@ -2,6 +2,8 @@ import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { basename } from "node:path";
 import { executionEnv } from "./shell.mjs";
+import { assertOwnedByContext, principalBinding } from "./authority-context.mjs";
+import { delegatedProcessCommand } from "./delegated-process-sandbox.mjs";
 import { validateArgv } from "./process-contract.mjs";
 import { terminateProcessTree, terminateProcessTreeWithEscalation } from "./process-tree.mjs";
 import { createToolAuthorizer } from "./policy.mjs";
@@ -13,10 +15,11 @@ import {
 } from "./execution-limits.mjs";
 
 export class ProcessSessionManager {
-  constructor({ workspace, policy, authorizeTool = null, runtimeDir, processTracker, resolveCwd, displayPath, throwIfCancelled }) {
+  constructor({ workspace, policy, authorizeTool = null, policyForContext = null, runtimeDir, processTracker, resolveCwd, displayPath, throwIfCancelled }) {
     this.workspace = workspace;
     this.policy = policy;
     this.authorizeTool = createToolAuthorizer(this.policy, authorizeTool);
+    this.policyForContext = typeof policyForContext === "function" ? policyForContext : () => this.policy;
     this.runtimeDir = runtimeDir;
     this.processTracker = processTracker;
     this.resolveCwd = resolveCwd;
@@ -34,6 +37,7 @@ export class ProcessSessionManager {
   }
 
   clear() {
+    for (const session of this.sessions.values()) notifySessionWaiters(session);
     this.sessions.clear();
   }
 
@@ -41,7 +45,7 @@ export class ProcessSessionManager {
     for (const session of this.sessions.values()) notifySessionWaiters(session);
   }
 
-  retainCompletedOutput({ command, cwd, stdout, stderr, exitCode, startedAt, closedAt = Date.now() }) {
+  retainCompletedOutput({ command, cwd, stdout, stderr, exitCode, startedAt, closedAt = Date.now() }, context = {}) {
     this.prune();
     this.evictExitedForCapacity();
     if (this.sessions.size >= MAX_PROCESS_SESSIONS) return null;
@@ -61,23 +65,25 @@ export class ProcessSessionManager {
       stdinClosed: true,
       waiters: new Set(),
       terminationTimer: null,
+      ...principalBinding(context),
     };
     this.sessions.set(session.id, session);
-    return this.summary(session);
+    return this.summary(session, context);
   }
 
   async start(args, context = {}) {
     this.authorizeTool("start_process");
     const argv = validateArgv(args.argv);
-    const cwd = await this.resolveCwd(args.cwd || ".");
+    const cwd = await this.resolveCwd(args.cwd || ".", context);
     this.prune();
     this.evictExitedForCapacity();
     if (this.sessions.size >= MAX_PROCESS_SESSIONS) throw new Error(`process session limit reached (${MAX_PROCESS_SESSIONS})`);
     this.throwIfCancelled(context);
 
-    const child = spawn(argv[0], argv.slice(1), {
+    const launch = delegatedProcessCommand({ command: argv[0], args: argv.slice(1), workspace: this.workspace, runtimeDir: this.runtimeDir, context });
+    const child = spawn(launch.command, launch.args, {
       cwd,
-      env: executionEnv(this.workspace, { fullEnv: this.policy.minimalEnv === false, runtimeDir: this.runtimeDir }),
+      env: executionEnv(this.workspace, { fullEnv: this.policyForContext(context).minimalEnv === false, runtimeDir: this.runtimeDir }),
       detached: process.platform !== "win32",
       windowsHide: true,
     });
@@ -96,6 +102,7 @@ export class ProcessSessionManager {
       stdinClosed: false,
       waiters: new Set(),
       terminationTimer: null,
+      ...principalBinding(context),
     };
     this.sessions.set(session.id, session);
     this.trackChild(child, context.callId);
@@ -133,12 +140,12 @@ export class ProcessSessionManager {
       throw error;
     }
     this.throwIfCancelled(context);
-    return this.summary(session);
+    return this.summary(session, context);
   }
 
   async read(args, context = {}) {
     this.authorizeTool("read_process");
-    const session = this.get(args.session_id);
+    const session = this.get(args.session_id, context);
     const stdoutOffset = clampInteger(args.stdout_offset, 0, 0, Number.MAX_SAFE_INTEGER);
     const stderrOffset = clampInteger(args.stderr_offset, 0, 0, Number.MAX_SAFE_INTEGER);
     const maxBytes = clampInteger(args.max_bytes, 64 * 1024, 1, 256 * 1024);
@@ -158,7 +165,7 @@ export class ProcessSessionManager {
     this.throwIfCancelled(context);
     session.lastActivity = Date.now();
     return {
-      ...this.summary(session),
+      ...this.summary(session, context),
       stdout: session.stdout.read(stdoutOffset, maxBytes),
       stderr: session.stderr.read(stderrOffset, maxBytes),
     };
@@ -166,7 +173,7 @@ export class ProcessSessionManager {
 
   async write(args, context = {}) {
     this.authorizeTool("write_process");
-    const session = this.get(args.session_id);
+    const session = this.get(args.session_id, context);
     if (session.closedAt !== null) throw new Error("process session has already exited");
     const data = String(args.data ?? "");
     if (Buffer.byteLength(data) > MAX_PROCESS_SESSION_STDIN_BYTES) throw new Error(`stdin data exceeds maximum size (${MAX_PROCESS_SESSION_STDIN_BYTES} bytes)`);
@@ -182,42 +189,45 @@ export class ProcessSessionManager {
       session.stdinClosed = true;
     }
     session.lastActivity = Date.now();
-    return { ...this.summary(session), bytes_written: Buffer.byteLength(data) };
+    return { ...this.summary(session, context), bytes_written: Buffer.byteLength(data) };
   }
 
   async kill(args, context = {}) {
     this.authorizeTool("kill_process");
-    const session = this.get(args.session_id);
+    const session = this.get(args.session_id, context);
     this.throwIfCancelled(context);
     const wasRunning = session.closedAt === null;
     const force = args.force === true;
     if (wasRunning && force) terminateProcessTree(session.child, "SIGKILL");
     else if (wasRunning && !session.terminationTimer) {
-      session.terminationTimer = terminateProcessTreeWithEscalation(session.child);
+      session.terminationTimer = terminateProcessTreeWithEscalation(session.child, {
+        onTerminationSettled: () => { session.terminationTimer = null; },
+      });
     }
     session.lastActivity = Date.now();
     return {
-      ...this.summary(session),
+      ...this.summary(session, context),
       termination_requested: wasRunning,
       force,
       force_after_ms: wasRunning && !force ? 2000 : null,
     };
   }
 
-  get(sessionId) {
+  get(sessionId, context = {}) {
     this.prune();
     const id = String(sessionId || "");
     if (!/^proc_[A-Za-z0-9_-]{20,}$/.test(id)) throw new Error("invalid process session id");
     const session = this.sessions.get(id);
     if (!session) throw new Error("process session not found or expired");
+    assertOwnedByContext(session, context, "process session");
     return session;
   }
 
-  summary(session) {
+  summary(session, context = {}) {
     return {
       session_id: session.id,
       command: session.argv0,
-      cwd: this.displayPath(session.cwd),
+      cwd: this.displayPath(session.cwd, context),
       running: session.closedAt === null,
       exit_code: session.exitCode,
       signal: session.signal,

package/src/local/process-tracker.mjs

@@ -6,8 +6,12 @@ export class ProcessTracker {
     this.terminateWithEscalation = typeof options.terminateWithEscalation === "function"
       ? options.terminateWithEscalation
       : terminateProcessTreeWithEscalation;
+    this.clearScheduledTermination = typeof options.clearScheduledTermination === "function"
+      ? options.clearScheduledTermination
+      : clearTimeout;
     this.active = new Set();
     this.byCall = new Map();
+    this.terminationTimers = new Map();
   }
 
   track(child, callId = "") {
@@ -35,21 +39,41 @@ export class ProcessTracker {
 
   terminateCall(callId, { force = false } = {}) {
     const children = [...(this.byCall.get(String(callId || "")) || [])];
-    for (const child of children) {
-      if (force) this.terminate(child, "SIGKILL");
-      else this.terminateWithEscalation(child);
-    }
+    for (const child of children) this.requestTermination(child, force);
     return children.length;
   }
 
   terminateAll(signal = "SIGTERM", escalate = false) {
     for (const child of [...this.active]) {
-      if (escalate && signal !== "SIGKILL") this.terminateWithEscalation(child);
-      else this.terminate(child, signal);
+      if (escalate && signal !== "SIGKILL") this.requestTermination(child, false);
+      else {
+        this.clearTermination(child);
+        this.terminate(child, signal);
+      }
     }
   }
 
   snapshot() {
     return { active_processes: this.active.size, calls_with_processes: this.byCall.size };
   }
+
+  requestTermination(child, force) {
+    if (force) {
+      this.clearTermination(child);
+      this.terminate(child, "SIGKILL");
+      return;
+    }
+    if (this.terminationTimers.has(child)) return;
+    const timer = this.terminateWithEscalation(child, {
+      onTerminationSettled: () => { this.terminationTimers.delete(child); },
+    });
+    if (timer) this.terminationTimers.set(child, timer);
+  }
+
+  clearTermination(child) {
+    const timer = this.terminationTimers.get(child);
+    if (!timer) return;
+    this.clearScheduledTermination(timer);
+    this.terminationTimers.delete(child);
+  }
 }

package/src/local/process-tree-ownership.mjs

@@ -0,0 +1,59 @@
+import { spawnSync } from "node:child_process";
+
+const PROCESS_SNAPSHOT_TIMEOUT_MS = 3000;
+const PROCESS_SNAPSHOT_BYTES = 512 * 1024;
+const START_TIME_TOLERANCE_MS = 1500;
+
+export function captureProcessTreeOwnership(child, options = {}) {
+  const pid = positivePid(child?.pid);
+  const platform = String(options.platform || process.platform);
+  if (!pid) return { platform, pid: 0, members: [] };
+  if (platform === "win32") return { platform, pid, members: [{ pid, startedAt: null }] };
+  return { platform, pid, members: processGroupMembers(pid, options) };
+}
+
+export function processTreeOwnershipStillCurrent(snapshot, child, options = {}) {
+  if (!snapshot?.pid) return false;
+  if (snapshot.platform === "win32") return !childHasExited(child);
+  if (!Array.isArray(snapshot.members) || snapshot.members.length === 0) return !childHasExited(child);
+  const current = processGroupMembers(snapshot.pid, options);
+  return snapshot.members.some((expected) => current.some((observed) => sameProcessIdentity(expected, observed)));
+}
+
+function processGroupMembers(groupId, options = {}) {
+  const list = typeof options.listProcessGroups === "function" ? options.listProcessGroups : listProcessGroups;
+  return list(options).filter((entry) => entry.pgid === groupId).map(({ pid, startedAt }) => ({ pid, startedAt }));
+}
+
+function listProcessGroups(options = {}) {
+  const run = typeof options.spawnSyncProcess === "function" ? options.spawnSyncProcess : spawnSync;
+  const result = run("ps", ["-axo", "pid=,pgid=,lstart="], {
+    encoding: "utf8",
+    timeout: PROCESS_SNAPSHOT_TIMEOUT_MS,
+    maxBuffer: PROCESS_SNAPSHOT_BYTES,
+    windowsHide: true,
+    env: { ...process.env, LC_ALL: "C", LANG: "C" },
+    stdio: ["ignore", "pipe", "ignore"],
+  });
+  if (result?.error || result?.status !== 0) return [];
+  return String(result.stdout || "").split(/\r?\n/).map(parseProcessRow).filter(Boolean);
+}
+
+function parseProcessRow(line) {
+  const match = /^\s*(\d+)\s+(\d+)\s+(.+?)\s*$/.exec(String(line || ""));
+  if (!match) return null;
+  const pid = positivePid(match[1]);
+  const pgid = positivePid(match[2]);
+  const startedAt = Date.parse(match[3]);
+  return pid && pgid && Number.isFinite(startedAt) ? { pid, pgid, startedAt } : null;
+}
+
+function sameProcessIdentity(left, right) {
+  return left.pid === right.pid && Number.isFinite(left.startedAt) && Number.isFinite(right.startedAt)
+    && Math.abs(left.startedAt - right.startedAt) <= START_TIME_TOLERANCE_MS;
+}
+function positivePid(value) { const parsed = Number(value); return Number.isInteger(parsed) && parsed > 0 ? parsed : 0; }
+function childHasExited(child) {
+  return child?.exitCode !== null && child?.exitCode !== undefined
+    || child?.signalCode !== null && child?.signalCode !== undefined;
+}

package/src/local/process-tree.mjs

@@ -1,4 +1,9 @@
 import { spawn } from "node:child_process";
+import {
+  captureProcessTreeOwnership,
+  processTreeOwnershipStillCurrent,
+} from "./process-tree-ownership.mjs";
+export { captureProcessTreeOwnership, processTreeOwnershipStillCurrent } from "./process-tree-ownership.mjs";
 
 export const DEFAULT_PROCESS_TERMINATION_GRACE_MS = 2000;
 
@@ -10,13 +15,9 @@ export function terminateProcessTree(child, signal = "SIGTERM", options = {}) {
       const spawnProcess = typeof options.spawnProcess === "function" ? options.spawnProcess : spawn;
       const force = signal === "SIGKILL";
       const killer = spawnProcess("taskkill.exe", ["/PID", String(child.pid), "/T", ...(force ? ["/F"] : [])], {
-        stdio: "ignore",
-        windowsHide: true,
-        shell: false,
+        stdio: "ignore", windowsHide: true, shell: false,
       });
-      const fallback = () => {
-        try { child.kill(signal); } catch {}
-      };
+      const fallback = () => { try { child.kill(signal); } catch {} };
       killer?.once?.("error", fallback);
       killer?.once?.("exit", (code) => { if (code !== 0) fallback(); });
       killer?.unref?.();
@@ -25,17 +26,11 @@ export function terminateProcessTree(child, signal = "SIGTERM", options = {}) {
       // Fall through to ChildProcess.kill for environments without taskkill.
     }
   }
-
   const killProcess = typeof options.killProcess === "function" ? options.killProcess : process.kill.bind(process);
-  try {
-    killProcess(-child.pid, signal);
-    return true;
-  } catch {
-    try {
-      return child.kill(signal) !== false;
-    } catch {
-      return false;
-    }
+  try { killProcess(-child.pid, signal); return true; }
+  catch {
+    try { return child.kill(signal) !== false; }
+    catch { return false; }
   }
 }
 
@@ -45,9 +40,18 @@ export function terminateProcessTreeWithEscalation(child, options = {}) {
     : DEFAULT_PROCESS_TERMINATION_GRACE_MS;
   const schedule = typeof options.setTimeout === "function" ? options.setTimeout : setTimeout;
   const terminate = typeof options.terminate === "function" ? options.terminate : terminateProcessTree;
+  const ownership = typeof options.captureOwnership === "function"
+    ? options.captureOwnership(child)
+    : captureProcessTreeOwnership(child, options);
   terminate(child, "SIGTERM", options);
   return schedule(() => {
-    terminate(child, "SIGKILL", options);
-    options.onEscalated?.();
+    try {
+      const owned = typeof options.isTerminationTargetOwned === "function"
+        ? options.isTerminationTargetOwned(ownership, child)
+        : processTreeOwnershipStillCurrent(ownership, child, options);
+      if (!owned) return;
+      terminate(child, "SIGKILL", options);
+      options.onEscalated?.();
+    } finally { options.onTerminationSettled?.(); }
   }, graceMs);
 }

package/src/local/relay-connection.mjs

@@ -1,6 +1,9 @@
 import WebSocket from "ws";
 import { classifyOperationalError } from "./log.mjs";
 import { proxyAgentForWebSocket } from "./network-proxy.mjs";
+import {
+  APPLICATION_PROXY_ROUTE_SCOPE, relayOutageFields, relayRecoveryFields, relayStatusSnapshot,
+} from "./relay-diagnostics.mjs";
 
 const DEFAULT_HEARTBEAT_INTERVAL_MS = 25_000;
 const DEFAULT_HEARTBEAT_TIMEOUT_MS = 75_000;
@@ -39,6 +42,7 @@ export class RelayConnection {
     this.reconnectDelay = typeof options.reconnectDelay === "function" ? options.reconnectDelay : reconnectDelay;
     this.proxyAgentForUrl = typeof options.proxyAgentForUrl === "function" ? options.proxyAgentForUrl : proxyAgentForWebSocket;
     this.networkRoute = "unresolved";
+    this.networkRouteScope = APPLICATION_PROXY_ROUTE_SCOPE;
     this.maxPayload = boundedPositiveInteger(options.maxPayload, 8 * 1024 * 1024);
     this.heartbeatIntervalMs = boundedPositiveInteger(options.heartbeatIntervalMs, DEFAULT_HEARTBEAT_INTERVAL_MS);
     this.heartbeatTimeoutMs = boundedPositiveInteger(options.heartbeatTimeoutMs, DEFAULT_HEARTBEAT_TIMEOUT_MS);
@@ -72,8 +76,15 @@ export class RelayConnection {
     this.outageNoticeEmitted = false;
     this.outageWarningCount = 0;
     this.lastOutageWarnAt = 0;
+    this.outageCount = 0;
     this.lastCloseCategory = "connection_interrupted";
+    this.lastCloseCode = 0;
     this.lastTransportErrorClass = "";
+    this.lastDisconnectedAt = 0;
+    this.lastReadyAt = 0;
+    this.lastReadyDurationMs = 0;
+    this.lastReconnectDelayMs = 0;
+    this.nextReconnectAt = 0;
     this.pendingCloseCategory = "";
     this.connectedOnce = null;
     this.connectedOnceResolve = null;
@@ -83,16 +94,7 @@ export class RelayConnection {
   }
 
   status() {
-    return {
-      authenticated: this.authenticated,
-      ready: this.ready,
-      readiness_probe_delivered: this.readinessProbeDelivered,
-      closed: this.closed,
-      network_route: this.networkRoute,
-      reconnect_attempt: this.reconnectAttempt,
-      outage_active: this.outageStartedAt > 0,
-      session_generation: this.sessionGeneration,
-    };
+    return relayStatusSnapshot(this, this.now());
   }
 
   currentSessionId() {
@@ -218,17 +220,18 @@ export class RelayConnection {
     this.ready = true;
     this.clearTimer("readinessTimer", "clearTimeout");
     this.reconnectAttempt = 0;
+    this.lastReadyAt = this.now();
+    this.nextReconnectAt = 0;
+    this.lastReconnectDelayMs = 0;
 
     if (!this.hasConnected) {
       this.logger.info?.("remote relay connected and end-to-end result delivery verified");
     } else if (this.outageStartedAt > 0) {
       const outageMs = Math.max(0, this.now() - this.outageStartedAt);
       if (this.outageNoticeEmitted) {
-        this.logger.info?.(`remote relay connection restored after ${formatDuration(outageMs)} (${formatAttempts(this.outageAttempts)})`);
-        this.logger.debug?.("remote relay outage recovery details", {
-          outage_seconds: roundSeconds(outageMs),
-          attempts: this.outageAttempts,
-        });
+        const recoveryFields = relayRecoveryFields(this, outageMs);
+        this.logger.info?.(`remote relay connection restored after ${formatDuration(outageMs)} (${formatAttempts(this.outageAttempts)})`, recoveryFields);
+        this.logger.debug?.("remote relay outage recovery details", recoveryFields);
       } else {
         this.logger.debug?.("remote relay connection recovered after a brief interruption", {
           outage_ms: outageMs,
@@ -281,7 +284,7 @@ export class RelayConnection {
       const proxy = this.proxyAgentForUrl(wsUrl);
       const headers = this.connectionHeaders();
       if (!headers || typeof headers !== "object" || Array.isArray(headers)) throw new Error("relay connection headers are invalid");
-      this.networkRoute = proxy?.agent ? "proxy" : "direct";
+      this.networkRoute = proxy?.agent ? "application-http-proxy" : "system-network-stack";
       socket = new this.WebSocketClass(wsUrl, {
         headers,
         maxPayload: this.maxPayload,
@@ -290,11 +293,13 @@ export class RelayConnection {
       this.logger.debug?.("remote relay network route selected", { route: this.networkRoute });
     } catch (error) {
       if (error?.code === "relay_proxy_configuration") {
-        this.networkRoute = "invalid-proxy-configuration";
+        this.networkRoute = "invalid-application-proxy-configuration";
         this.failPermanently("relay_proxy_configuration");
         return;
       }
       this.lastTransportErrorClass = classifyRelayTransportError(error);
+      this.lastCloseCode = 0;
+      this.lastDisconnectedAt = this.now();
       this.logger.debug?.("remote relay connection could not be created", { error_class: this.lastTransportErrorClass });
       this.scheduleReconnect("connection_interrupted");
       return;
@@ -362,9 +367,14 @@ export class RelayConnection {
       const reasonText = sanitizeCloseReason(reason);
       const category = this.pendingCloseCategory || relayCloseCategory(code, reasonText);
       this.pendingCloseCategory = "";
-      const connectedForMs = wasAuthenticated && this.connectedAt > 0 ? Math.max(0, this.now() - this.connectedAt) : 0;
+      if (category !== "relay_transport_error") this.lastTransportErrorClass = "";
+      const disconnectedAt = this.now();
+      const connectedForMs = wasAuthenticated && this.connectedAt > 0 ? Math.max(0, disconnectedAt - this.connectedAt) : 0;
+      this.lastDisconnectedAt = disconnectedAt;
+      this.lastReadyDurationMs = wasReady && this.lastReadyAt > 0 ? Math.max(0, disconnectedAt - this.lastReadyAt) : 0;
+      this.lastCloseCode = Number(code) || 0;
       this.logger.debug?.("remote relay transport closed", {
-        close_code: Number(code) || 0,
+        close_code: this.lastCloseCode,
         close_reason: reasonText || "<none>",
         category,
         ready: wasReady,
@@ -457,10 +467,20 @@ export class RelayConnection {
     if (this.closed || this.reconnectTimer) return;
     this.recordOutage(category);
     const delay = this.reconnectDelay(this.reconnectAttempt++);
+    this.lastReconnectDelayMs = delay;
+    this.nextReconnectAt = this.now() + delay;
     this.scheduleOutageWarning();
-    this.logger.debug?.("scheduling daemon reconnect", { delay_ms: delay, attempt: this.outageAttempts });
+    this.logger.debug?.("scheduling daemon reconnect", {
+      delay_ms: delay,
+      next_reconnect_at: new Date(this.nextReconnectAt).toISOString(),
+      attempt: this.outageAttempts,
+      close_category: this.lastCloseCategory,
+      network_route: this.networkRoute,
+      network_route_scope: this.networkRouteScope,
+    });
     this.reconnectTimer = this.scheduler.setTimeout(() => {
       this.reconnectTimer = null;
+      this.nextReconnectAt = 0;
       this.connect();
     }, delay);
     this.reconnectTimer?.unref?.();
@@ -501,6 +521,7 @@ export class RelayConnection {
     const now = this.now();
     if (this.outageStartedAt === 0) {
       this.outageStartedAt = now;
+      this.outageCount += 1;
       this.outageAttempts = 0;
       this.outageNoticeEmitted = false;
       this.lastOutageWarnAt = 0;
@@ -538,13 +559,9 @@ export class RelayConnection {
     const action = outageMs >= 5 * 60_000
       ? " If this persists, check internet access and the deployed Worker."
       : "";
-    this.logger.warn?.(`remote relay unavailable for ${formatDuration(outageMs)}; reconnecting automatically (${formatAttempts(this.outageAttempts)}; ${cause}).${action}`);
-    this.logger.debug?.("remote relay outage details", {
-      outage_seconds: roundSeconds(outageMs),
-      attempts: this.outageAttempts,
-      cause,
-      ...(this.lastTransportErrorClass ? { error_class: this.lastTransportErrorClass } : {}),
-    });
+    const outageFields = relayOutageFields(this, this.now(), cause);
+    this.logger.warn?.(`remote relay unavailable for ${formatDuration(outageMs)}; reconnecting automatically (${formatAttempts(this.outageAttempts)}; ${cause}).${action}`, outageFields);
+    this.logger.debug?.("remote relay outage details", outageFields);
   }
 
   resetOutage() {
@@ -554,8 +571,7 @@ export class RelayConnection {
     this.outageNoticeEmitted = false;
     this.outageWarningCount = 0;
     this.lastOutageWarnAt = 0;
-    this.lastCloseCategory = "connection_interrupted";
-    this.lastTransportErrorClass = "";
+    this.nextReconnectAt = 0;
     this.pendingCloseCategory = "";
   }
 
@@ -666,8 +682,8 @@ export function isSupersededClose(code, reason) {
 
 export function reconnectDelay(attempt, random = Math.random) {
   const safeAttempt = Math.max(0, Number.isFinite(Number(attempt)) ? Number(attempt) : 0);
-  const base = Math.min(3000 * (2 ** Math.min(safeAttempt, 5)), 60_000);
-  return base + Math.floor(random() * 1000);
+  const base = Math.min(1000 * (2 ** Math.min(safeAttempt, 4)), 15_000);
+  return base + Math.floor(random() * 500);
 }
 
 function normalizeWorkerUrl(value) {
@@ -744,7 +760,3 @@ function formatDuration(milliseconds) {
   }
   return parts.join(" ") || "1 second";
 }
-
-function roundSeconds(milliseconds) {
-  return Math.max(1, Math.round(milliseconds / 1000));
-}