machine-bridge-mcp 1.2.5 → 1.2.7

package/src/local/daemon-process.mjs

@@ -11,6 +11,7 @@ import { inspectProcessInstance, isPidAlive, processCommandLine, splitProcessCom
 
 const DEFAULT_TAKEOVER_TIMEOUT_MS = 15_000;
 const DEFAULT_TAKEOVER_POLL_MS = 100;
+const DEFAULT_FORCE_AFTER_MS = 2_000;
 
 export async function acquireDaemonLockWithTakeover(state, options = {}) {
   const ownerMetadata = options.ownerMetadata || {};
@@ -50,9 +51,10 @@ export async function acquireDaemonLockWithTakeover(state, options = {}) {
 export async function stopWorkspaceServiceDaemon(state, options = {}) {
   const timeoutMs = boundedPositiveInt(options.timeoutMs, DEFAULT_TAKEOVER_TIMEOUT_MS);
   const pollMs = boundedPositiveInt(options.pollMs, DEFAULT_TAKEOVER_POLL_MS);
+  const forceAfterMs = Math.min(timeoutMs, boundedPositiveInt(options.forceAfterMs, DEFAULT_FORCE_AFTER_MS));
   const logger = options.logger || { info() {}, warn() {} };
   const deadline = createMonotonicDeadline(timeoutMs);
-  const signalled = new Set();
+  const signalled = new Map();
   let owner = options.owner || readDaemonLockOwner(daemonLockPathForState(state));
   let verified = false;
   let lastOwner = owner;
@@ -89,12 +91,42 @@ export async function stopWorkspaceServiceDaemon(state, options = {}) {
             };
           }
         }
-        signalled.add(Number(owner.pid));
+        signalled.set(Number(owner.pid), {
+          owner: { ...owner },
+          forceDeadline: createMonotonicDeadline(forceAfterMs),
+          forced: false,
+        });
       }
     }
 
-    const liveSignalled = [...signalled].filter((pid) => isPidAlive(pid));
-    const currentOwnerAlive = Boolean(owner?.pid && isPidAlive(owner.pid));
+    for (const [pid, signalState] of signalled) {
+      if (signalState.forced || !signalState.forceDeadline.expired()) continue;
+      const current = inspectProcessInstance(signalState.owner);
+      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`);
+      try {
+        process.kill(pid, "SIGKILL");
+        signalState.forced = true;
+      } catch (error) {
+        if (error?.code !== "ESRCH") {
+          return {
+            ok: false,
+            found: true,
+            verified_service_daemon: true,
+            reason: "force_signal_failed",
+            timeout_ms: timeoutMs,
+            ...publicDaemonOwner(signalState.owner),
+          };
+        }
+      }
+    }
+
+    const liveSignalled = [...signalled.entries()]
+      .filter(([, signalState]) => inspectProcessInstance(signalState.owner).current)
+      .map(([pid]) => pid);
+    const currentOwnerAlive = Boolean(owner?.pid && inspectProcessInstance(owner).current);
     if (!currentOwnerAlive && liveSignalled.length === 0) break;
 
     if (deadline.expired()) {
@@ -107,6 +139,7 @@ export async function stopWorkspaceServiceDaemon(state, options = {}) {
         verified_service_daemon: verified,
         reason: "timeout",
         timeout_ms: timeoutMs,
+        force_after_ms: forceAfterMs,
         pid: remainingPid,
         mode: publicDaemonMode(lastOwner),
         version: typeof lastOwner?.version === "string" ? lastOwner.version : "unknown",
@@ -126,6 +159,8 @@ export async function stopWorkspaceServiceDaemon(state, options = {}) {
     verified_service_daemon: verified,
     reason: verified ? "stopped" : "not_running",
     timeout_ms: timeoutMs,
+    force_after_ms: forceAfterMs,
+    forced: [...signalled.values()].some((item) => item.forced),
     ...(lastOwner ? publicDaemonOwner(lastOwner) : {}),
   };
 }
@@ -168,11 +203,18 @@ function inspectWorkspaceDaemonOwner(state, owner) {
     const name = path.basename(value);
     return name === entryName || name === "machine-mcp" || name === "machine-mcp.mjs";
   });
-  const matches = argv.includes("--daemon-only")
+  const explicitIdentity = Boolean(workspaceArg && stateRootArg)
     && sameCanonicalPath(workspaceArg, state.workspace.path)
-    && sameCanonicalPath(stateRootArg, state.paths.stateRoot)
-    && entryMatches;
-  return { verified_service_daemon: matches, reason: matches ? "service_command" : "command_mismatch" };
+    && sameCanonicalPath(stateRootArg, state.paths.stateRoot);
+  const implicitIdentity = !workspaceArg && !stateRootArg;
+  const commonIdentity = argv.includes("--daemon-only") && entryMatches;
+  if (commonIdentity && explicitIdentity) {
+    return { verified_service_daemon: true, reason: "service_command" };
+  }
+  if (commonIdentity && implicitIdentity) {
+    return { verified_service_daemon: true, reason: "implicit_service_command" };
+  }
+  return { verified_service_daemon: false, reason: "command_mismatch" };
 }
 
 function commandFlagValue(argv, name) {

package/src/local/execution-limits.mjs

@@ -0,0 +1,36 @@
+export const MAX_CONCURRENT_TOOL_CALLS = 16;
+export const MAX_PROCESS_SESSIONS = 8;
+export const MIN_PROCESS_TIMEOUT_SECONDS = 1;
+export const MAX_PROCESS_TIMEOUT_SECONDS = 600;
+export const DEFAULT_PROCESS_OUTPUT_BYTES = 512 * 1024;
+export const MAX_PROCESS_STDIN_BYTES = 1024 * 1024;
+export const MAX_PROCESS_SESSION_OUTPUT_BYTES = 1024 * 1024;
+export const MAX_PROCESS_SESSION_STDIN_BYTES = 64 * 1024;
+export const PROCESS_SESSION_RETENTION_MS = 30 * 60 * 1000;
+
+export function executionGuardrailsSnapshot() {
+  return {
+    tool_calls: {
+      maximum_concurrent: MAX_CONCURRENT_TOOL_CALLS,
+    },
+    one_shot_processes: {
+      timeout_seconds: { minimum: MIN_PROCESS_TIMEOUT_SECONDS, maximum: MAX_PROCESS_TIMEOUT_SECONDS },
+      stdin_max_bytes: MAX_PROCESS_STDIN_BYTES,
+      output_max_bytes_per_stream: DEFAULT_PROCESS_OUTPUT_BYTES,
+      process_tree_termination: "sigterm-then-sigkill",
+    },
+    process_sessions: {
+      maximum_concurrent: MAX_PROCESS_SESSIONS,
+      retained_output_max_bytes_per_stream: MAX_PROCESS_SESSION_OUTPUT_BYTES,
+      write_stdin_max_bytes: MAX_PROCESS_SESSION_STDIN_BYTES,
+      exited_retention_ms: PROCESS_SESSION_RETENTION_MS,
+      process_tree_termination: "sigterm-then-sigkill",
+    },
+    operating_system_enforcement: {
+      cpu_quota: "not-enforced",
+      memory_quota: "not-enforced",
+      network_isolation: "not-enforced",
+      required_boundary: "dedicated-low-privilege-account-or-vm-container",
+    },
+  };
+}

package/src/local/job-runner.mjs

@@ -4,7 +4,7 @@ import { chmodSync, existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs
 import { basename, join, resolve } from "node:path";
 import { performance } from "node:perf_hooks";
 import { executionEnv } from "./shell.mjs";
-import { terminateProcessTree } from "./process-sessions.mjs";
+import { terminateProcessTreeWithEscalation } from "./process-tree.mjs";
 import { createExclusiveFileSync, removeOwnedJsonFileSync, replaceFileAtomicallySync } from "./exclusive-file.mjs";
 import { createMonotonicDeadline } from "./monotonic-deadline.mjs";
 import { currentProcessStartTimeMs } from "./process-identity.mjs";
@@ -279,8 +279,7 @@ function spawnStep(argv, { cwd, env, input, timeoutMs, cancellationAware, captur
     let killTimer = null;
     const timer = setTimeout(() => {
       timedOut = true;
-      terminateProcessTree(child, "SIGTERM");
-      killTimer = setTimeout(() => terminateProcessTree(child, "SIGKILL"), 2000);
+      killTimer = terminateProcessTreeWithEscalation(child);
     }, timeoutMs);
     timer.unref?.();
     const cancellationPoll = setInterval(() => {
@@ -474,12 +473,10 @@ function requestCancellation() {
   cancelRequested = true;
   const child = activeChild;
   if (!child || !activeChildCancellationAware) return;
-  terminateProcessTree(child, "SIGTERM");
   if (cancellationEscalation) return;
-  cancellationEscalation = setTimeout(() => {
-    terminateProcessTree(child, "SIGKILL");
-    cancellationEscalation = null;
-  }, 2000);
+  cancellationEscalation = terminateProcessTreeWithEscalation(child, {
+    onEscalated: () => { cancellationEscalation = null; },
+  });
 }
 
 function isCancellationRequested() {

package/src/local/loopback-health.mjs

@@ -0,0 +1,67 @@
+import { request as requestHttp } from "node:http";
+
+export function readLoopbackJson(input, options = {}) {
+  let target;
+  try { target = new URL(String(input)); } catch { return Promise.resolve(null); }
+  const pathname = typeof options.pathname === "string" && options.pathname.startsWith("/") ? options.pathname : "/healthz";
+  const port = Number(target.port);
+  if (target.protocol !== "http:"
+      || target.hostname !== "127.0.0.1"
+      || target.pathname !== pathname
+      || target.username || target.password || target.search || target.hash
+      || !Number.isInteger(port) || port < 1024 || port > 65535) {
+    return Promise.resolve(null);
+  }
+  const request = typeof options.request === "function" ? options.request : requestHttp;
+  const timeoutMs = Number.isFinite(Number(options.timeoutMs)) ? Math.max(1, Number(options.timeoutMs)) : 2000;
+  const maximumBytes = Number.isFinite(Number(options.maximumBytes)) ? Math.max(1, Number(options.maximumBytes)) : 64 * 1024;
+  return new Promise((resolvePromise) => {
+    let settled = false;
+    let client;
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      resolvePromise(value);
+    };
+    try {
+      client = request({
+        protocol: "http:", hostname: "127.0.0.1", port, path: pathname, method: "GET", agent: false,
+        headers: { accept: "application/json", connection: "close" },
+      }, (response) => {
+        if (response.statusCode !== 200) {
+          response.resume();
+          finish(null);
+          return;
+        }
+        const chunks = [];
+        let total = 0;
+        response.on("data", (chunk) => {
+          if (settled) return;
+          total += chunk.length;
+          if (total > maximumBytes) {
+            client.destroy();
+            finish(null);
+            return;
+          }
+          chunks.push(chunk);
+        });
+        response.on("end", () => {
+          if (settled) return;
+          try {
+            const value = JSON.parse(Buffer.concat(chunks, total).toString("utf8"));
+            finish(value && typeof value === "object" && !Array.isArray(value) ? value : null);
+          } catch {
+            finish(null);
+          }
+        });
+        response.on("error", () => finish(null));
+      });
+    } catch {
+      finish(null);
+      return;
+    }
+    client.setTimeout(timeoutMs, () => client.destroy(new Error("loopback health request timed out")));
+    client.on("error", () => finish(null));
+    client.end();
+  });
+}

package/src/local/managed-jobs.mjs

@@ -1,7 +1,7 @@
 import { spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { closeSync, constants as fsConstants, existsSync, ftruncateSync, lstatSync, readSync, readdirSync, realpathSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
-import { dirname, join, resolve } from "node:path";
+import { basename, dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
 import { assertStateMaintenanceAvailable, ensureOwnerOnlyDir, ownerOnlyFile } from "./state.mjs";
 import { createExclusiveFileSync, replaceFileAtomicallySync } from "./exclusive-file.mjs";
@@ -12,6 +12,7 @@ import { BridgeError } from "./errors.mjs";
 import { inspectResourceFile, normalizeResourceRegistry, validatePlan } from "./managed-job-plan.mjs";
 export { inspectResourceFile, publicResourceRegistry, validateResourceName } from "./managed-job-plan.mjs";
 import { clampInteger } from "./numbers.mjs";
+import { classifyOperationalError } from "./log.mjs";
 
 const JOB_ID = /^job_[A-Za-z0-9_-]{24,}$/;
 const MAX_JOBS = 50;
@@ -124,7 +125,7 @@ export class ManagedJobManager {
       status.cleanup_guarantee = "best-effort-finally-and-recovery";
       atomicWriteJson(statusFile, status, 256 * 1024);
       try {
-        launchRunner(dir);
+        launchRunner(dir, false, "", { logger: this.logger });
       } catch (error) {
         failRunnerLaunch(dir, status, error);
         throw error;
@@ -181,7 +182,7 @@ export class ManagedJobManager {
     atomicWriteJson(join(dir, "status.json"), status, 256 * 1024);
     if (launch) {
       try {
-        launchRunner(dir);
+        launchRunner(dir, false, "", { logger: this.logger });
       } catch (error) {
         failRunnerLaunch(dir, status, error);
         throw error;
@@ -356,7 +357,7 @@ export class ManagedJobManager {
         markRecoveryExhausted(dir, file, status, recoveryAttempts);
         return;
       }
-      const runnerPid = relaunchInterruptedJob(dir, file, status, recoveryAttempts, recoveryLock.token);
+      const runnerPid = relaunchInterruptedJob(dir, file, status, recoveryAttempts, recoveryLock.token, this.logger);
       recoveryLock.handoff(runnerPid);
       handedOff = true;
     } finally {
@@ -513,7 +514,7 @@ function markRecoveryExhausted(dir, statusFile, status, recoveryAttempts) {
   scrubFinishedPlan(dir, status);
 }
 
-function relaunchInterruptedJob(dir, statusFile, status, recoveryAttempts, recoveryToken) {
+function relaunchInterruptedJob(dir, statusFile, status, recoveryAttempts, recoveryToken, logger) {
   status.status = "interrupted";
   status.updated_at = new Date().toISOString();
   status.finished_at = status.updated_at;
@@ -522,7 +523,7 @@ function relaunchInterruptedJob(dir, statusFile, status, recoveryAttempts, recov
   atomicWriteJson(statusFile, status, 256 * 1024);
   rmSync(join(dir, "runtime"), { recursive: true, force: true });
   rmSync(join(dir, "runner.pid"), { force: true });
-  return launchRunner(dir, true, recoveryToken);
+  return launchRunner(dir, true, recoveryToken, { logger });
 }
 
 function acquireRecoveryLock(dir) {
@@ -634,7 +635,7 @@ function replacePrivateTextFile(file, content) {
   ownerOnlyFile(file);
 }
 
-function launchRunner(dir, recover = false, recoveryToken = "") {
+export function launchRunner(dir, recover = false, recoveryToken = "", options = {}) {
   const args = [RUNNER_PATH, "--job-dir", dir];
   if (recover) args.push("--recover");
   const stdoutFile = join(dir, "runner.out.log");
@@ -647,10 +648,12 @@ function launchRunner(dir, recover = false, recoveryToken = "") {
   try {
     stdoutFd = openPrivateAppendFile(stdoutFile);
     stderrFd = openPrivateAppendFile(stderrFile);
-    child = spawn(process.execPath, args, {
+    const spawnProcess = typeof options.spawnProcess === "function" ? options.spawnProcess : spawn;
+    child = spawnProcess(process.execPath, args, {
       detached: true,
       stdio: ["ignore", stdoutFd, stderrFd],
       windowsHide: true,
+      shell: false,
       env: recoveryToken ? { ...process.env, MBM_RECOVERY_LOCK_TOKEN: recoveryToken } : process.env,
     });
   } finally {
@@ -659,8 +662,18 @@ function launchRunner(dir, recover = false, recoveryToken = "") {
   }
   ownerOnlyFile(stdoutFile);
   ownerOnlyFile(stderrFile);
+  const logger = options.logger || console;
+  child.once?.("error", (error) => {
+    logger.error?.("managed job runner process reported an asynchronous failure", {
+      job_id: basename(dir),
+      recovery: recover,
+      error_class: classifyOperationalError(error),
+    });
+  });
+  const pid = Number(child.pid);
+  if (!Number.isInteger(pid) || pid <= 0) throw new Error("managed job runner did not receive a process id");
   child.unref();
-  return child.pid;
+  return pid;
 }
 
 

package/src/local/process-contract.mjs

@@ -0,0 +1,19 @@
+export const MAX_COMMAND_BYTES = 64 * 1024;
+export const MAX_ARGV_ITEMS = 256;
+
+export function validateArgv(value) {
+  if (!Array.isArray(value) || !value.length || value.length > MAX_ARGV_ITEMS) {
+    throw new Error(`argv must contain 1-${MAX_ARGV_ITEMS} strings`);
+  }
+  const argv = value.map((item) => {
+    if (typeof item !== "string" || item.includes("\0")) {
+      throw new Error("argv entries must be strings without NUL bytes");
+    }
+    return item;
+  });
+  if (!argv[0]) throw new Error("argv[0] must not be empty");
+  if (Buffer.byteLength(JSON.stringify(argv)) > MAX_COMMAND_BYTES) {
+    throw new Error(`argv exceeds maximum size (${MAX_COMMAND_BYTES} bytes)`);
+  }
+  return argv;
+}

package/src/local/process-execution.mjs

@@ -2,12 +2,13 @@ import { spawn } from "node:child_process";
 import { stat } from "node:fs/promises";
 import { BoundedOutput } from "./bounded-output.mjs";
 import { executionEnv, workspaceShellCommand } from "./shell.mjs";
-import { MAX_COMMAND_BYTES, terminateProcessTreeWithEscalation, validateArgv } from "./process-sessions.mjs";
+import { MAX_COMMAND_BYTES, validateArgv } from "./process-contract.mjs";
+import { terminateProcessTreeWithEscalation } from "./process-tree.mjs";
 import { BridgeError } from "./errors.mjs";
 import { clampInteger } from "./numbers.mjs";
-
-const MAX_STDIN_BYTES = 1024 * 1024;
-const DEFAULT_OUTPUT_BYTES = 512 * 1024;
+import {
+  DEFAULT_PROCESS_OUTPUT_BYTES, MAX_PROCESS_STDIN_BYTES, MAX_PROCESS_TIMEOUT_SECONDS, MIN_PROCESS_TIMEOUT_SECONDS,
+} from "./execution-limits.mjs";
 
 function spawnDirectProcess(command, args, options) {
   // Keep the production child_process API call structurally separate from the
@@ -41,7 +42,7 @@ export class ProcessExecutionService {
     const argv = validateArgv(args.argv);
     const cwd = await this.resolveExistingPath(args.cwd || ".");
     if (!(await stat(cwd)).isDirectory()) throw new BridgeError("invalid_request", "cwd is not a directory");
-    return this.run(argv[0], argv.slice(1), clampInteger(args.timeout_seconds, 120, 1, 600) * 1000, false, DEFAULT_OUTPUT_BYTES, context, cwd);
+    return this.run(argv[0], argv.slice(1), clampInteger(args.timeout_seconds, 120, MIN_PROCESS_TIMEOUT_SECONDS, MAX_PROCESS_TIMEOUT_SECONDS) * 1000, false, DEFAULT_PROCESS_OUTPUT_BYTES, context, cwd);
   }
 
   async runRegistered(args, context = {}) {
@@ -52,9 +53,9 @@ export class ProcessExecutionService {
     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, 1, 600);
+      : 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.run(argv[0], argv.slice(1), timeoutSeconds * 1000, false, DEFAULT_OUTPUT_BYTES, context, cwd);
+    const result = await this.run(argv[0], argv.slice(1), timeoutSeconds * 1000, false, DEFAULT_PROCESS_OUTPUT_BYTES, context, cwd);
     return { name: command.name, cwd: this.displayPath(cwd), timeout_seconds: timeoutSeconds, ...result };
   }
 
@@ -69,16 +70,16 @@ export class ProcessExecutionService {
     if (command.includes("\0")) throw new BridgeError("invalid_request", "command contains a NUL byte");
     if (Buffer.byteLength(command) > MAX_COMMAND_BYTES) throw new BridgeError("limit_exceeded", `command exceeds maximum size (${MAX_COMMAND_BYTES} bytes)`);
     const shell = workspaceShellCommand(command);
-    return this.run(shell.cmd, shell.args, clampInteger(timeoutSeconds, 120, 1, 600) * 1000, false, DEFAULT_OUTPUT_BYTES, context);
+    return this.run(shell.cmd, shell.args, clampInteger(timeoutSeconds, 120, MIN_PROCESS_TIMEOUT_SECONDS, MAX_PROCESS_TIMEOUT_SECONDS) * 1000, false, DEFAULT_PROCESS_OUTPUT_BYTES, context);
   }
 
   terminateAll(signal = "SIGTERM", escalate = false) {
     this.processTracker.terminateAll(signal, escalate);
   }
 
-  async run(cmd, args, timeoutMs, allowFailure = false, maxOutputBytes = DEFAULT_OUTPUT_BYTES, context = {}, cwd = this.workspace, stdin = null) {
+  async run(cmd, args, timeoutMs, allowFailure = false, maxOutputBytes = DEFAULT_PROCESS_OUTPUT_BYTES, context = {}, cwd = this.workspace, stdin = null) {
     this.throwIfCancelled(context);
-    if (stdin !== null && Buffer.byteLength(String(stdin)) > MAX_STDIN_BYTES) {
+    if (stdin !== null && Buffer.byteLength(String(stdin)) > MAX_PROCESS_STDIN_BYTES) {
       throw new BridgeError("limit_exceeded", "process stdin exceeds 1 MiB");
     }
 

package/src/local/process-sessions.mjs

@@ -2,16 +2,14 @@ import { spawn } from "node:child_process";
 import { randomBytes } from "node:crypto";
 import { basename } from "node:path";
 import { executionEnv } from "./shell.mjs";
+import { validateArgv } from "./process-contract.mjs";
+import { terminateProcessTree, terminateProcessTreeWithEscalation } from "./process-tree.mjs";
 import { createToolAuthorizer } from "./policy.mjs";
 import { createMonotonicDeadline } from "./monotonic-deadline.mjs";
 import { clampInteger } from "./numbers.mjs";
-
-export const MAX_COMMAND_BYTES = 64 * 1024;
-const MAX_ARGV_ITEMS = 256;
-const MAX_PROCESS_SESSIONS = 8;
-const MAX_SESSION_OUTPUT_BYTES = 1024 * 1024;
-const MAX_PROCESS_STDIN_BYTES = 64 * 1024;
-const PROCESS_SESSION_RETENTION_MS = 30 * 60 * 1000;
+import {
+  MAX_PROCESS_SESSIONS, MAX_PROCESS_SESSION_OUTPUT_BYTES, MAX_PROCESS_SESSION_STDIN_BYTES, PROCESS_SESSION_RETENTION_MS,
+} from "./execution-limits.mjs";
 
 export class ProcessSessionManager {
   constructor({ workspace, policy, authorizeTool = null, runtimeDir, processTracker, resolveCwd, displayPath, throwIfCancelled }) {
@@ -70,6 +68,7 @@ export class ProcessSessionManager {
       signal: null,
       stdinClosed: false,
       waiters: new Set(),
+      terminationTimer: null,
     };
     this.sessions.set(session.id, session);
     this.trackChild(child, context.callId);
@@ -94,6 +93,11 @@ export class ProcessSessionManager {
       notifySessionWaiters(session);
     });
 
+    child.on("error", (error) => {
+      appendSessionStream(session.stderr, Buffer.from(`${boundedErrorMessage(error)}\n`));
+      session.lastActivity = Date.now();
+      notifySessionWaiters(session);
+    });
     try {
       await waitForSpawn(child);
     } catch (error) {
@@ -101,12 +105,6 @@ export class ProcessSessionManager {
       this.untrackChild(child);
       throw error;
     }
-
-    child.on("error", (error) => {
-      appendSessionStream(session.stderr, Buffer.from(`${boundedErrorMessage(error)}\n`));
-      session.lastActivity = Date.now();
-      notifySessionWaiters(session);
-    });
     this.throwIfCancelled(context);
     return this.summary(session);
   }
@@ -144,7 +142,7 @@ export class ProcessSessionManager {
     const session = this.get(args.session_id);
     if (session.closedAt !== null) throw new Error("process session has already exited");
     const data = String(args.data ?? "");
-    if (Buffer.byteLength(data) > MAX_PROCESS_STDIN_BYTES) throw new Error(`stdin data exceeds maximum size (${MAX_PROCESS_STDIN_BYTES} bytes)`);
+    if (Buffer.byteLength(data) > MAX_PROCESS_SESSION_STDIN_BYTES) throw new Error(`stdin data exceeds maximum size (${MAX_PROCESS_SESSION_STDIN_BYTES} bytes)`);
     if (session.stdinClosed || session.child.stdin.destroyed) throw new Error("process session stdin is closed");
     this.throwIfCancelled(context);
     if (data) {
@@ -165,9 +163,18 @@ export class ProcessSessionManager {
     const session = this.get(args.session_id);
     this.throwIfCancelled(context);
     const wasRunning = session.closedAt === null;
-    if (wasRunning) terminateProcessTree(session.child, args.force === true ? "SIGKILL" : "SIGTERM");
+    const force = args.force === true;
+    if (wasRunning && force) terminateProcessTree(session.child, "SIGKILL");
+    else if (wasRunning && !session.terminationTimer) {
+      session.terminationTimer = terminateProcessTreeWithEscalation(session.child);
+    }
     session.lastActivity = Date.now();
-    return { ...this.summary(session), termination_requested: wasRunning, force: args.force === true };
+    return {
+      ...this.summary(session),
+      termination_requested: wasRunning,
+      force,
+      force_after_ms: wasRunning && !force ? 2000 : null,
+    };
   }
 
   get(sessionId) {
@@ -220,38 +227,6 @@ export class ProcessSessionManager {
   }
 }
 
-export function validateArgv(value) {
-  if (!Array.isArray(value) || !value.length || value.length > MAX_ARGV_ITEMS) throw new Error(`argv must contain 1-${MAX_ARGV_ITEMS} strings`);
-  const argv = value.map((item) => {
-    if (typeof item !== "string" || item.includes("\0")) throw new Error("argv entries must be strings without NUL bytes");
-    return item;
-  });
-  if (!argv[0]) throw new Error("argv[0] must not be empty");
-  if (Buffer.byteLength(JSON.stringify(argv)) > MAX_COMMAND_BYTES) throw new Error(`argv exceeds maximum size (${MAX_COMMAND_BYTES} bytes)`);
-  return argv;
-}
-
-export function terminateProcessTree(child, signal) {
-  if (!child?.pid) return;
-  if (process.platform === "win32") {
-    try {
-      const killer = spawn("taskkill.exe", ["/PID", String(child.pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
-      killer.unref();
-      return;
-    } catch {}
-  }
-  try { process.kill(-child.pid, signal); } catch {
-    try { child.kill(signal); } catch {}
-  }
-}
-
-export function terminateProcessTreeWithEscalation(child, options = {}) {
-  const graceMs = Number.isFinite(Number(options.graceMs)) ? Math.max(0, Number(options.graceMs)) : 2000;
-  const schedule = typeof options.setTimeout === "function" ? options.setTimeout : setTimeout;
-  terminateProcessTree(child, "SIGTERM");
-  return schedule(() => terminateProcessTree(child, "SIGKILL"), graceMs);
-}
-
 function waitForSpawn(child) {
   return new Promise((resolvePromise, rejectPromise) => {
     const onSpawn = () => { cleanup(); resolvePromise(); };
@@ -273,8 +248,8 @@ function appendSessionStream(stream, chunk) {
   const input = Buffer.isBuffer(chunk) ? chunk : Buffer.from(String(chunk ?? ""));
   stream.totalBytes += input.length;
   let combined = stream.buffer.length ? Buffer.concat([stream.buffer, input]) : Buffer.from(input);
-  if (combined.length > MAX_SESSION_OUTPUT_BYTES) {
-    const dropped = combined.length - MAX_SESSION_OUTPUT_BYTES;
+  if (combined.length > MAX_PROCESS_SESSION_OUTPUT_BYTES) {
+    const dropped = combined.length - MAX_PROCESS_SESSION_OUTPUT_BYTES;
     combined = combined.subarray(dropped);
     stream.baseOffset += dropped;
   }

package/src/local/process-tracker.mjs

@@ -1,4 +1,4 @@
-import { terminateProcessTree, terminateProcessTreeWithEscalation } from "./process-sessions.mjs";
+import { terminateProcessTree, terminateProcessTreeWithEscalation } from "./process-tree.mjs";
 
 export class ProcessTracker {
   constructor(options = {}) {

package/src/local/process-tree.mjs

@@ -0,0 +1,53 @@
+import { spawn } from "node:child_process";
+
+export const DEFAULT_PROCESS_TERMINATION_GRACE_MS = 2000;
+
+export function terminateProcessTree(child, signal = "SIGTERM", options = {}) {
+  if (!child?.pid) return false;
+  const platform = options.platform || process.platform;
+  if (platform === "win32") {
+    try {
+      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,
+      });
+      const fallback = () => {
+        try { child.kill(signal); } catch {}
+      };
+      killer?.once?.("error", fallback);
+      killer?.once?.("exit", (code) => { if (code !== 0) fallback(); });
+      killer?.unref?.();
+      return true;
+    } catch {
+      // 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;
+    }
+  }
+}
+
+export function terminateProcessTreeWithEscalation(child, options = {}) {
+  const graceMs = Number.isFinite(Number(options.graceMs))
+    ? Math.max(0, Number(options.graceMs))
+    : DEFAULT_PROCESS_TERMINATION_GRACE_MS;
+  const schedule = typeof options.setTimeout === "function" ? options.setTimeout : setTimeout;
+  const terminate = typeof options.terminate === "function" ? options.terminate : terminateProcessTree;
+  terminate(child, "SIGTERM", options);
+  return schedule(() => {
+    terminate(child, "SIGKILL", options);
+    options.onEscalated?.();
+  }, graceMs);
+}

package/src/local/relay-connection.mjs

@@ -319,7 +319,11 @@ export class RelayConnection {
       if (this.socket !== socket || this.closed) return;
       this.lastInboundAt = this.now();
       // Bind results to the generation that received this message.
-      const relayContext = { sessionId: this.activeSessionId, authenticated: this.authenticated, ready: this.ready };
+      const relayContext = {
+        sessionId: this.activeSessionId,
+        authenticated: this.authenticated === true,
+        ready: this.ready === true,
+      };
       try {
         const outcome = this.onMessage(data, relayContext);
         if (outcome && typeof outcome.catch === "function") {
@@ -638,6 +642,12 @@ export function readinessMismatch(message, expectedServer = "", expectedVersion
   return "";
 }
 
+export function isRelayReadyContext(relayContext = {}, relay = null) {
+  if (relayContext?.ready === true) return true;
+  if (relayContext?.ready === false) return false;
+  return Number(relayContext?.sessionId) > 0 && relay?.status?.()?.ready === true;
+}
+
 export function isSupersededClose(code, reason) {
   return Number(code) === 1012 && String(reason || "") === "replaced by verified daemon";
 }