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

package/src/local/job-runner.mjs

@@ -1,14 +1,25 @@
 import { spawn } from "node:child_process";
 import { createHash } from "node:crypto";
-import { chmodSync, existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { chmodSync, 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 { attachChildProcessSettlement, childExitedBeforeTimeout } from "./child-process-settlement.mjs";
 import { terminateProcessTreeWithEscalation } from "./process-tree.mjs";
-import { createExclusiveFileSync, removeOwnedJsonFileSync, replaceFileAtomicallySync } from "./exclusive-file.mjs";
+import { removeOwnedJsonFileSync, replaceFileAtomicallySync } from "./exclusive-file.mjs";
 import { createMonotonicDeadline } from "./monotonic-deadline.mjs";
-import { currentProcessStartTimeMs } from "./process-identity.mjs";
+import { currentProcessStartTimeMs, processState } from "./process-identity.mjs";
 import { readBoundedRegularFileSync } from "./secure-file.mjs";
+import { managedJobCancellationRequested } from "./managed-job-cancellation.mjs";
+import { MacosIdleSleepAssertion } from "./macos-idle-sleep-assertion.mjs";
+import relayContract from "../shared/relay-contract.json" with { type: "json" };
+import { MANAGED_JOB_ID } from "./managed-job-directory.mjs";
+import { ACTIVE_JOB_STATES, isTerminalManagedJobStatus, managedJobFinalStatus, persistManagedJobTerminal } from "./managed-job-terminal.mjs";
+import { sanitizeLogText } from "./log.mjs";
+import { confirmRunnerClaim } from "./managed-job-runner-claim.mjs";
+import { ResourceCoordinator } from "./resource-admission.mjs";
+import { acquireProcessResources, bindProcessResources, releaseProcessResources, releaseProcessResourcesQuietly } from "./resource-process-admission.mjs";
+import { delegatedProcessCommand } from "./delegated-process-sandbox.mjs";
 
 const RESOURCE_TOKEN = /\{\{resource:([a-z][a-z0-9._-]{0,63})\}\}/g;
 const TEMP_TOKEN = /\{\{temp:([a-z][a-z0-9._-]{0,63})\}\}/g;
@@ -17,16 +28,22 @@ const MAX_OUTPUT_BYTES = 64 * 1024;
 const MAX_JOB_CAPTURE_BYTES = 256 * 1024;
 const MAX_RESULT_BYTES = 4 * 1024 * 1024;
 const MAX_STATUS_BYTES = 256 * 1024;
-const JOB_ID = /^job_[A-Za-z0-9_-]{24,}$/;
+const RECOVERY_LOCK_HANDOFF_WAIT_MS = 30_000;
+const FATAL_IDENTITY_FIELDS = [
+  "job_id", "name", "plan_sha256", "created_at", "approval", "owner_kind", "owner_account_id",
+  "owner_account_version", "owner_client_id", "owner_family_id",
+];
 
 const options = parseArgs(process.argv.slice(2));
 const jobDirInput = typeof options.jobDir === "string" ? options.jobDir.trim() : "";
 if (!jobDirInput) throw new Error("--job-dir is required");
 const jobDir = resolve(jobDirInput);
-if (!JOB_ID.test(basename(jobDir))) throw new Error("--job-dir must name a managed job directory");
+if (!MANAGED_JOB_ID.test(basename(jobDir))) throw new Error("--job-dir must name a managed job directory");
 const recover = options.recover === true;
 const recoveryLockToken = typeof process.env.MBM_RECOVERY_LOCK_TOKEN === "string" ? process.env.MBM_RECOVERY_LOCK_TOKEN : "";
+const launchToken = typeof process.env.MBM_RUNNER_LAUNCH_TOKEN === "string" ? process.env.MBM_RUNNER_LAUNCH_TOKEN : "";
 delete process.env.MBM_RECOVERY_LOCK_TOKEN;
+delete process.env.MBM_RUNNER_LAUNCH_TOKEN;
 const planFile = join(jobDir, "plan.json");
 const statusFile = join(jobDir, "status.json");
 const resultFile = join(jobDir, "result.json");
@@ -36,6 +53,7 @@ const resourcesDir = join(runtimeDir, "resources");
 const temporaryFilesDir = join(runtimeDir, "files");
 const runnerPidFile = join(jobDir, "runner.pid");
 const RUNNER_PROCESS_STARTED_AT = new Date(currentProcessStartTimeMs()).toISOString();
+const resourceCoordinator = new ResourceCoordinator();
 
 class JobCancelledError extends Error {
   constructor() {
@@ -47,28 +65,41 @@ class JobCancelledError extends Error {
 
 let activeChild = null;
 let activeChildCancellationAware = false;
-let cancellationEscalation = null;
+let activeChildTermination = null;
 let cancelRequested = false;
+let runnerClaimConfirmed = false;
+let jobIdleSleepAssertion = null;
 for (const signal of ["SIGTERM", "SIGINT"]) {
   process.on(signal, () => requestCancellation());
 }
 
 const initial = readJson(statusFile, MAX_STATUS_BYTES);
 assertLaunchState(initial);
-createExclusiveFileSync(runnerPidFile, `${JSON.stringify({ pid: process.pid, processStartedAt: RUNNER_PROCESS_STARTED_AT })}\n`, { mode: 0o600 });
 try {
+  await confirmRunnerClaim({
+    file: runnerPidFile, pid: process.pid, processStartedAt: RUNNER_PROCESS_STARTED_AT, launchToken,
+  });
+  if (initial.owner_kind === "account") {
+    jobIdleSleepAssertion = new MacosIdleSleepAssertion({ logger: managedJobIdleSleepLogger() });
+    jobIdleSleepAssertion.acquire();
+  }
   if (recover) await releaseRecoveryClaim();
+  runnerClaimConfirmed = true;
   const plan = readJson(planFile, 1024 * 1024);
   assertPlanIntegrity(plan, initial);
   await main(plan, initial);
 } catch (error) {
   recordFatalRunnerError(error);
+  process.exitCode = 1;
+} finally {
+  jobIdleSleepAssertion?.release();
 }
 
+
 async function releaseRecoveryClaim() {
   if (!/^[a-f0-9]{32}$/.test(recoveryLockToken)) throw new Error("recovery runner is missing its ownership token");
   const file = join(jobDir, "recovery.lock");
-  const deadline = createMonotonicDeadline(5000);
+  const deadline = createMonotonicDeadline(RECOVERY_LOCK_HANDOFF_WAIT_MS);
   while (!deadline.expired()) {
     if (removeOwnedJsonFileSync(file, { pid: process.pid, token: recoveryLockToken })) return;
     await new Promise((resolvePromise) => { setTimeout(resolvePromise, 10); });
@@ -104,7 +135,7 @@ async function main(plan, initial) {
       for (let index = 0; index < plan.steps.length; index += 1) {
         if (isCancellationRequested()) throw new JobCancelledError();
         updateStatus(status, { status: "running", current_phase: "steps", current_step: index });
-        const result = await runStep(plan.steps[index], index, "steps", plan, resourceContext, true, captureBudget);
+        const result = await runStep(plan.steps[index], index, "steps", plan, resourceContext, true, captureBudget, status);
         mainResults.push(result);
         if (result.timed_out && !plan.steps[index].allow_failure) throw new Error(`step ${index + 1} timed out`);
         if (result.code !== 0 && !plan.steps[index].allow_failure) throw new Error(`step ${index + 1} exited ${result.code}`);
@@ -117,7 +148,7 @@ async function main(plan, initial) {
     try {
       for (let index = 0; index < plan.finally_steps.length; index += 1) {
         updateStatus(status, { status: "cleaning", current_phase: recover ? "recovery-cleanup" : "finally_steps", current_step: index });
-        const result = await runStep(plan.finally_steps[index], index, "finally_steps", plan, resourceContext, false, captureBudget);
+        const result = await runStep(plan.finally_steps[index], index, "finally_steps", plan, resourceContext, false, captureBudget, status);
         cleanupResults.push(result);
         if (result.timed_out && !plan.finally_steps[index].allow_failure && !cleanupError) cleanupError = new Error(`cleanup step ${index + 1} timed out`);
         if (result.code !== 0 && !plan.finally_steps[index].allow_failure && !cleanupError) cleanupError = new Error(`cleanup step ${index + 1} exited ${result.code}`);
@@ -125,15 +156,23 @@ async function main(plan, initial) {
     } catch (error) {
       cleanupError ||= error;
     }
-    rmSync(runtimeDir, { recursive: true, force: true });
   }
 
-  const cancelled = mainError instanceof JobCancelledError || existsSync(cancelFile);
-  let finalStatus;
-  if (recover) finalStatus = cleanupError ? "recovery_failed" : "recovered";
-  else if (cancelled) finalStatus = cleanupError ? "cancelled_cleanup_failed" : "cancelled";
-  else if (mainError) finalStatus = cleanupError ? "failed_cleanup_failed" : "failed";
-  else finalStatus = cleanupError ? "succeeded_cleanup_failed" : "succeeded";
+  let cancellationMarker = false;
+  try { cancellationMarker = managedJobCancellationRequested(cancelFile); }
+  catch (error) {
+    mainError = mainError
+      ? new AggregateError([mainError, error], "managed job failed and cancellation state could not be verified")
+      : error;
+  }
+  const cancelled = mainError instanceof JobCancelledError || cancellationMarker;
+  const finalStatus = managedJobFinalStatus({ recover, cancelled, mainError, cleanupError });
+  if (cleanupError && classifyError(cleanupError) === "resource_error") {
+    const stage = cleanupError?.details?.admission_reason || cleanupError?.details?.reason || cleanupError?.code
+      || (/resource lease/i.test(String(cleanupError?.message || "")) ? "resource_lease" : "resource_operation");
+    try { process.stderr.write(`managed job cleanup infrastructure failure: stage=${sanitizeLogText(stage, 64)}\n`); }
+    catch { /* Last-resort diagnostics must not replace the managed job's primary failure. */ }
+  }
 
   const result = {
     job_id: status.job_id,
@@ -148,24 +187,23 @@ async function main(plan, initial) {
     capture_remaining_bytes: captureBudget.remaining,
     finished_at: new Date().toISOString(),
   };
-  writeJson(resultFile, result, MAX_RESULT_BYTES);
-  updateStatus(status, {
-    status: finalStatus,
-    current_phase: null,
-    current_step: null,
-    finished_at: result.finished_at,
-    error_class: result.error_class || result.cleanup_error_class,
+  const terminal = persistManagedJobTerminal({
+    statusFile, resultFile,
+    artifacts: [runtimeDir, planFile, runnerPidFile, cancelFile],
+    status: { ...status, runner_pid: process.pid, runner_process_started_at: RUNNER_PROCESS_STARTED_AT },
+    result, writeJson,
+    removeFile: (file) => rmSync(file, { recursive: true, force: true }),
+    maxStatusBytes: MAX_STATUS_BYTES, maxResultBytes: MAX_RESULT_BYTES,
   });
-  try { rmSync(planFile, { force: true }); } catch {}
-  try { rmSync(runnerPidFile, { force: true }); } catch {}
-  try { rmSync(cancelFile, { force: true }); } catch {}
+  Object.assign(status, terminal.status);
+  reportTerminalPersistenceFailure(terminal);
 }
 
 function assertLaunchState(status) {
   if (!status || typeof status !== "object" || Array.isArray(status)) throw new Error("job status is unavailable or invalid");
   const expected = recover ? "interrupted" : "queued";
   if (status.status !== expected) throw new Error(`runner cannot start job in status: ${status.status}`);
-  if (status.approval === "pending-local-operator" || !status.approval) throw new Error("runner cannot start an unapproved managed job");
+  if (status.approval !== "mcp") throw new Error("runner cannot start a managed job without direct execution authority");
 }
 
 function assertPlanIntegrity(plan, status) {
@@ -176,10 +214,24 @@ function assertPlanIntegrity(plan, status) {
 }
 
 function recordFatalRunnerError(error) {
-  rmSync(runtimeDir, { recursive: true, force: true });
   const now = new Date().toISOString();
-  let status = {};
-  try { status = readJson(statusFile, MAX_STATUS_BYTES); } catch {}
+  try {
+    process.stderr.write(`managed job runner fatal: error_class=${classifyError(error)} message=${sanitizeLogText(error?.message || error, 512)}\n`);
+  } catch { /* Last-resort diagnostics must not prevent terminal-state recovery. */ }
+  if (!runnerClaimConfirmed) {
+    reportFatalRecordSkipped("runner_claim_unconfirmed");
+    return;
+  }
+  let status;
+  try { status = readJson(statusFile, MAX_STATUS_BYTES); }
+  catch (stateError) {
+    reportFatalRecordSkipped(classifyError(stateError));
+    return;
+  }
+  if (!fatalRunnerStatusIsCurrent(status, initial)) {
+    reportFatalRecordSkipped("state_integrity");
+    return;
+  }
   const finalStatus = recover ? "recovery_failed" : "runner_failed";
   const result = {
     job_id: status.job_id ?? null,
@@ -192,27 +244,62 @@ function recordFatalRunnerError(error) {
     cleanup_error_class: recover ? classifyError(error) : null,
     finished_at: now,
   };
-  try { writeJson(resultFile, result, MAX_RESULT_BYTES); } catch {}
-  try {
-    writeJson(statusFile, {
+  const terminal = persistManagedJobTerminal({
+    statusFile, resultFile,
+    artifacts: [runtimeDir, planFile, runnerPidFile, cancelFile],
+    status: {
       ...status,
-      status: finalStatus,
-      current_phase: null,
-      current_step: null,
       runner_pid: process.pid,
       runner_process_started_at: RUNNER_PROCESS_STARTED_AT,
-      updated_at: now,
-      finished_at: now,
-      error_class: result.error_class,
       cleanup_guarantee: "best-effort-finally-and-recovery",
-    }, MAX_STATUS_BYTES);
-  } catch {}
-  try { rmSync(planFile, { force: true }); } catch {}
-  try { rmSync(runnerPidFile, { force: true }); } catch {}
-  try { rmSync(cancelFile, { force: true }); } catch {}
+    },
+    result, writeJson,
+    removeFile: (file) => rmSync(file, { recursive: true, force: true }),
+    maxStatusBytes: MAX_STATUS_BYTES, maxResultBytes: MAX_RESULT_BYTES,
+  });
+  reportTerminalPersistenceFailure(terminal);
+}
+
+function fatalRunnerStatusIsCurrent(status, accepted) {
+  if (!status || typeof status !== "object" || Array.isArray(status)
+      || !accepted || typeof accepted !== "object" || Array.isArray(accepted)) return false;
+  if (isTerminalManagedJobStatus(status.status) || !ACTIVE_JOB_STATES.has(status.status)) return false;
+  if (status.job_id !== basename(jobDir) || FATAL_IDENTITY_FIELDS.some((field) => status[field] !== accepted[field])) return false;
+  const runnerPid = Number(status.runner_pid || 0);
+  const acceptedPid = Number(accepted.runner_pid || 0);
+  if (runnerPid && runnerPid !== process.pid && runnerPid !== acceptedPid) return false;
+  const runnerStartedAt = String(status.runner_process_started_at || "");
+  const acceptedStartedAt = String(accepted.runner_process_started_at || "");
+  return !runnerStartedAt || runnerStartedAt === RUNNER_PROCESS_STARTED_AT || runnerStartedAt === acceptedStartedAt;
+}
+
+function reportFatalRecordSkipped(reason) {
+  try { process.stderr.write(`managed job fatal terminal record skipped: reason=${sanitizeLogText(reason, 64)}\n`); }
+  catch { /* A closed diagnostic stream is irrelevant to the already-decided state transition. */ }
+}
+
+function reportTerminalPersistenceFailure(terminal) {
+  if (terminal.statusPersisted && terminal.artifactsScrubbed && !terminal.statusErrorClass) return;
+  const fields = [
+    `status_persisted=${terminal.statusPersisted}`,
+    `result_persisted=${terminal.resultPersisted}`,
+    `artifacts_scrubbed=${terminal.artifactsScrubbed}`,
+    `status_error=${terminal.statusErrorClass || "none"}`,
+    `result_error=${terminal.resultErrorClass || "none"}`,
+    `cleanup_error=${terminal.cleanupErrorClass || "none"}`,
+  ];
+  try { process.stderr.write(`managed job terminal persistence incomplete: ${fields.join(" ")}\n`); }
+  catch { /* Persistence outcome is authoritative even if its fallback diagnostic cannot be written. */ }
+}
+
+function managedJobIdleSleepLogger() {
+  return { event(_level, _name, fields) {
+    try { process.stderr.write(`managed job idle-sleep assertion unavailable: error_class=${sanitizeLogText(fields?.error_class || "unknown", 64)}\n`); }
+    catch { /* Auxiliary power diagnostics must not replace managed-job settlement. */ }
+  } };
 }
 
-async function runStep(step, index, phase, plan, resourceContext, cancellationAware, captureBudget) {
+async function runStep(step, index, phase, plan, resourceContext, cancellationAware, captureBudget, status) {
   const argv = step.argv.map((value) => substitute(value, plan, resourceContext));
   const envOverrides = Object.fromEntries(Object.entries(step.env || {}).map(([key, value]) => [key, substitute(value, plan, resourceContext)]));
   const envResourceValues = Object.fromEntries(Object.entries(step.env_resources || {}).map(([key, name]) => [key, resourceEnvValue(name, resourceContext.bytes)]));
@@ -235,6 +322,19 @@ async function runStep(step, index, phase, plan, resourceContext, cancellationAw
     cancellationAware,
     captureOutput: step.capture_output !== "discard",
     captureBudget,
+    resourcePriority: plan?.execution_priority === "interactive" ? "interactive" : "background",
+    delegatedProcess: plan?.delegated_process === true,
+    workspace: plan.workspace,
+    onAdmissionStart: () => updateStatus(status, {
+      status: phase === "steps" ? "running" : "cleaning",
+      current_phase: "resource_admission",
+      current_step: index,
+    }),
+    onAdmissionComplete: () => updateStatus(status, {
+      status: phase === "steps" ? "running" : "cleaning",
+      current_phase: phase === "finally_steps" && recover ? "recovery-cleanup" : phase,
+      current_step: index,
+    }),
   });
   return {
     index,
@@ -245,6 +345,7 @@ async function runStep(step, index, phase, plan, resourceContext, cancellationAw
     signal: raw.signal,
     timed_out: raw.timedOut,
     duration_ms: performance.now() - started,
+    resource_admission_ms: raw.resourceAdmissionMs,
     stdout: step.capture_output === "discard" ? "" : redactOutput(raw.stdout, resourceContext),
     stderr: step.capture_output === "discard" ? "" : redactOutput(raw.stderr, resourceContext),
     output_discarded: step.capture_output === "discard",
@@ -255,31 +356,87 @@ async function runStep(step, index, phase, plan, resourceContext, cancellationAw
   };
 }
 
-function spawnStep(argv, { cwd, env, input, timeoutMs, cancellationAware, captureOutput, captureBudget }) {
+async function spawnStep(argv, {
+  cwd, env, input, timeoutMs, cancellationAware, captureOutput, captureBudget,
+  resourcePriority = "background", delegatedProcess = false, workspace = "",
+  onAdmissionStart = null, onAdmissionComplete = null,
+}) {
+  if (cancellationAware && isCancellationRequested()) throw new JobCancelledError();
+  const admissionStarted = performance.now();
+  onAdmissionStart?.();
+  let admitted;
+  let resourceAdmissionMs = 0;
+  try {
+    admitted = await acquireProcessResources(resourceCoordinator, argv[0], argv.slice(1), env, {
+      cwd, priority: resourcePriority, waitMs: relayContract.maximumManagedJobResourceAdmissionWaitMs,
+      cancelCheck: () => { if (cancellationAware && isCancellationRequested()) throw new JobCancelledError(); },
+    });
+    onAdmissionComplete?.();
+    resourceAdmissionMs = performance.now() - admissionStarted;
+  } catch (error) {
+    if (admitted?.lease) {
+      try { await releaseProcessResources(admitted.lease); }
+      catch (cleanupError) {
+        throw new AggregateError([error, cleanupError], "managed job admission status update and resource lease cleanup both failed");
+      }
+    }
+    throw error;
+  }
   return new Promise((resolvePromise, rejectPromise) => {
-    if (cancellationAware && isCancellationRequested()) {
-      rejectPromise(new JobCancelledError());
+    let child;
+    try {
+      const launch = delegatedProcess
+        ? delegatedProcessCommand({
+            command: admitted.command,
+            args: admitted.args,
+            workspace,
+            runtimeDir,
+            forceDelegated: true,
+          })
+        : { command: admitted.command, args: admitted.args };
+      child = spawn(launch.command, launch.args, {
+        cwd, env: admitted.environment, detached: process.platform !== "win32", windowsHide: true,
+        stdio: ["pipe", "pipe", "pipe"],
+      });
+    } catch (error) {
+      void releaseProcessResourcesQuietly(admitted.lease).then(() => rejectPromise(error));
       return;
     }
-    const child = spawn(argv[0], argv.slice(1), {
-      cwd,
-      env,
-      detached: process.platform !== "win32",
-      windowsHide: true,
-      stdio: ["pipe", "pipe", "pipe"],
-    });
     activeChild = child;
     activeChildCancellationAware = cancellationAware;
+    let terminationSettlement = null;
+    const terminateAndSettle = () => {
+      if (terminationSettlement) return terminationSettlement;
+      terminationSettlement = new Promise((resolveTermination) => {
+        try {
+          terminateProcessTreeWithEscalation(child, {
+            onTerminationSettled: resolveTermination,
+          });
+        } catch {
+          resolveTermination();
+        }
+      });
+      return terminationSettlement;
+    };
+    activeChildTermination = terminateAndSettle;
+    let resourceBindError = null; let childError = null;
+    const resourceBinding = bindProcessResources(admitted.lease, child).catch((error) => {
+      resourceBindError = error;
+      void terminateAndSettle();
+    });
     let stdout = Buffer.alloc(0);
     let stderr = Buffer.alloc(0);
     let stdoutTruncated = 0;
     let stderrTruncated = 0;
     let timedOut = false;
     let closed = false;
-    let killTimer = null;
     const timer = setTimeout(() => {
+      if (childExitedBeforeTimeout({ exitCode: child.exitCode, signalCode: child.signalCode, processState: processState(child.pid) })) {
+        settlement.onExit(child.exitCode, child.signalCode);
+        return;
+      }
       timedOut = true;
-      killTimer = terminateProcessTreeWithEscalation(child);
+      void terminateAndSettle();
     }, timeoutMs);
     timer.unref?.();
     const cancellationPoll = setInterval(() => {
@@ -300,38 +457,37 @@ function spawnStep(argv, { cwd, env, input, timeoutMs, cancellationAware, captur
       stderr = next.buffer;
       stderrTruncated += next.truncated;
     });
-    child.on("error", (error) => finish(() => rejectPromise(error)));
-    child.on("close", (code, signal) => finish(() => {
-      if (cancellationAware && isCancellationRequested()) {
-        rejectPromise(new JobCancelledError());
-        return;
-      }
-      resolvePromise({
-        code: Number.isInteger(code) ? code : 1,
-        signal: signal ? String(signal) : null,
-        timedOut,
-        stdout,
-        stderr,
-        stdoutTruncated,
-        stderrTruncated,
-      });
-    }));
+    const settlement = attachChildProcessSettlement(child, {
+      onSettle(code, signal) {
+        finish(() => {
+          if (resourceBindError) { rejectPromise(resourceBindError); return; }
+          if (childError) { rejectPromise(childError); return; }
+          if (cancellationAware && isCancellationRequested()) { rejectPromise(new JobCancelledError()); return; }
+          resolvePromise({
+            code: Number.isInteger(code) ? code : 1,
+            signal: signal ? String(signal) : null,
+            timedOut, resourceAdmissionMs, stdout, stderr, stdoutTruncated, stderrTruncated,
+          });
+        });
+      },
+    });
+    child.on("error", (error) => { childError ||= error; });
     if (input && input.length) child.stdin.end(input);
     else child.stdin.end();
 
     function finish(callback) {
       if (closed) return;
       closed = true;
+      settlement.cancel();
       clearTimeout(timer);
-      if (killTimer && !timedOut) clearTimeout(killTimer);
       clearInterval(cancellationPoll);
       activeChild = null;
       activeChildCancellationAware = false;
-      if (cancellationEscalation && !isCancellationRequested()) {
-        clearTimeout(cancellationEscalation);
-        cancellationEscalation = null;
-      }
-      callback();
+      activeChildTermination = null;
+      void resourceBinding
+        .then(() => terminationSettlement || undefined)
+        .then(() => releaseProcessResources(admitted.lease))
+        .then(callback, rejectPromise);
     }
   });
 }
@@ -362,7 +518,7 @@ function materializeResources(resources) {
       if (text.length > 0) patterns.push(text);
       const trimmed = text.replace(/[\r\n]+$/, "");
       if (trimmed.length > 0 && trimmed !== text) patterns.push(trimmed);
-    } catch {}
+    } catch { /* Binary resources still use byte-level base64/hex redaction below. */ }
     if (data.length > 0 && data.length <= 64 * 1024) {
       patterns.push(data.toString("base64"), data.toString("hex"));
     }
@@ -471,16 +627,12 @@ function updateStatus(status, changes) {
 
 function requestCancellation() {
   cancelRequested = true;
-  const child = activeChild;
-  if (!child || !activeChildCancellationAware) return;
-  if (cancellationEscalation) return;
-  cancellationEscalation = terminateProcessTreeWithEscalation(child, {
-    onEscalated: () => { cancellationEscalation = null; },
-  });
+  if (!activeChild || !activeChildCancellationAware) return;
+  void activeChildTermination?.();
 }
 
 function isCancellationRequested() {
-  return cancelRequested || existsSync(cancelFile);
+  return cancelRequested || managedJobCancellationRequested(cancelFile);
 }
 
 function appendLimited(current, chunk, limit, budget) {
@@ -504,7 +656,10 @@ function writeJson(file, value, maxBytes) {
 }
 
 function readJson(file, maxBytes) {
-  return JSON.parse(readBoundedFile(file, maxBytes).toString("utf8"));
+  return JSON.parse(readBoundedRegularFileSync(file, maxBytes, "managed job runner state", {
+    verifyPathIdentity: true,
+    rejectMultipleLinks: true,
+  }).toString("utf8"));
 }
 
 function readBoundedFile(file, maxBytes) {

package/src/local/lifecycle.mjs

@@ -31,6 +31,12 @@ export class LifecycleController {
     this.transition("failed");
   }
 
+  markStopFailed(error) {
+    if (this.state !== "stopping") throw new BridgeError("conflict", `${this.name} cannot fail stop from state ${this.state}`);
+    this.failureCode = String(error?.code || error?.name || "execution_failed").slice(0, 64);
+    this.transition("stop_failed");
+  }
+
   beginStop() {
     if (this.state === "stopped" || this.state === "stopping") return false;
     this.transition("stopping");

package/src/local/log.mjs

@@ -1,6 +1,7 @@
 import process from "node:process";
 import os from "node:os";
 import { errorCode } from "./errors.mjs";
+import { sanitizePortableLogText } from "../shared/log-redaction.mjs";
 
 const COLORS = {
   reset: "\x1b[0m",
@@ -18,20 +19,6 @@ const MAX_LOG_OBJECT_KEYS = 48;
 const LEVEL_RANK = Object.freeze({ debug: 10, info: 20, success: 20, warn: 30, error: 40 });
 const SENSITIVE_KEY = /(authorization|cookie|password|passwd|secret|token|api[_-]?key|private[_-]?key|credential)/i;
 const LOCAL_PATH_KEY = /(path|paths|cwd|workspace|directory|(?:^|[_-])dir(?:$|[_-])|root|home)/i;
-const SECRET_VALUE = /\b(?:account_admin|account_password|daemon_secret|token_version|mcp_at|mcp_code)_[A-Za-z0-9_-]+\b/g;
-const BEARER_VALUE = /\bBearer\s+[A-Za-z0-9._~+\/-]+=*\b/gi;
-const EMAIL_VALUE = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
-const AWS_ACCESS_KEY = /\b(?:AKIA|ASIA)[A-Z0-9]{16}\b/g;
-const GITHUB_TOKEN = /\bgh[pousr]_[A-Za-z0-9_]{30,}\b/g;
-const GITLAB_TOKEN = /\bglpat-[A-Za-z0-9_-]{20,}\b/g;
-const NPM_TOKEN = /\bnpm_[A-Za-z0-9]{30,}\b/g;
-const SLACK_TOKEN = /\bxox[aboprs]-[A-Za-z0-9-]{10,}\b/g;
-const GOOGLE_API_KEY = /\bAIza[A-Za-z0-9_-]{30,}\b/g;
-const PAYMENT_API_KEY = /\b(?:sk|rk|pk)_live_[A-Za-z0-9]{16,}\b/g;
-const JWT_VALUE = /\beyJ[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\.[A-Za-z0-9_-]{8,}\b/g;
-const URL_CREDENTIALS = /https?:\/\/[^\s/@:"'<>]+:[^\s/@"'<>]+@[^\s/"'<>]+/gi;
-const API_SECRET = /\bsk-(?:proj-)?[A-Za-z0-9_-]{20,}\b/g;
-const PRIVATE_KEY_HEADER = /-----BEGIN\s+(?:(?:OPENSSH|RSA|EC|DSA)\s+|ENCRYPTED\s+)?PRIVATE\s+KEY-----/g;
 const HOME_PATHS = [...new Set([process.env.HOME, process.env.USERPROFILE, safeHomeDirectory()].filter(value => typeof value === "string" && value.length > 1))]
   .sort((left, right) => right.length - left.length);
 
@@ -46,24 +33,36 @@ export function createLogger(options = {}) {
 
   const write = (stream, level, label, color, message, fields) => {
     if (LEVEL_RANK[level] < LEVEL_RANK[minimumLevel]) return;
+    const sanitizedMessage = sanitizeLogText(message, MAX_LOG_MESSAGE_CHARS);
+    if (options.format === "json") {
+      const entry = sanitizeLogValue({
+        ...(fields && typeof fields === "object" ? fields : {}),
+        timestamp: new Date().toISOString(),
+        level: level === "success" ? "info" : level,
+        component,
+        message: sanitizedMessage,
+      });
+      stream.write(`${JSON.stringify(entry)}\n`);
+      return;
+    }
     const prefix = useColor ? `${color}${label}${COLORS.reset}` : label;
     const suffix = formatFields(fields);
-    stream.write(`${prefix} ${component}: ${sanitizeLogText(message, MAX_LOG_MESSAGE_CHARS)}${suffix}\n`);
+    stream.write(`${prefix} ${component}: ${sanitizedMessage}${suffix}\n`);
   };
 
   const event = (level, name, fields = {}, message = "") => {
     const normalizedLevel = normalizeEventLevel(level);
     const eventName = sanitizeEventName(name);
-    const payload = { event: eventName, ...fields };
+    const payload = { ...fields, event: eventName };
     const humanMessage = message || humanizeEventName(eventName);
     if (options.format === "json") {
       if (LEVEL_RANK[normalizedLevel] < LEVEL_RANK[minimumLevel]) return;
       const entry = sanitizeLogValue({
+        ...payload,
         timestamp: new Date().toISOString(),
         level: normalizedLevel === "success" ? "info" : normalizedLevel,
         component,
         message: sanitizeLogText(humanMessage, MAX_LOG_MESSAGE_CHARS),
-        ...payload,
       });
       const target = normalizedLevel === "info" || normalizedLevel === "success" ? stdout : stderr;
       target.write(`${JSON.stringify(entry)}\n`);
@@ -83,6 +82,7 @@ export function createLogger(options = {}) {
   return {
     verbose: minimumLevel === "debug",
     level: minimumLevel,
+    format: options.format === "json" ? "json" : "text",
     child(childComponent) {
       return createLogger({ ...options, component: childComponent });
     },
@@ -137,7 +137,7 @@ function sanitizeLogValue(value, key = "", seen = new WeakSet(), depth = 0) {
   if (seen.has(value)) return "<circular>";
   seen.add(value);
   if (Array.isArray(value)) return value.slice(0, MAX_LOG_ARRAY_ITEMS).map(item => sanitizeLogValue(item, "", seen, depth + 1));
-  const out = {};
+  const out = Object.create(null);
   for (const [childKey, childValue] of Object.entries(value).slice(0, MAX_LOG_OBJECT_KEYS)) {
     out[childKey] = sanitizeLogValue(childValue, childKey, seen, depth + 1);
   }
@@ -145,33 +145,7 @@ function sanitizeLogValue(value, key = "", seen = new WeakSet(), depth = 0) {
 }
 
 export function sanitizeLogText(value, maxChars = MAX_LOG_MESSAGE_CHARS) {
-  let raw;
-  try { raw = String(value ?? ""); } catch { raw = "<unprintable>"; }
-  let sanitized = raw
-    .replace(SECRET_VALUE, "<redacted-secret>")
-    .replace(BEARER_VALUE, "Bearer <redacted>")
-    .replace(AWS_ACCESS_KEY, "<redacted-cloud-key>")
-    .replace(GITHUB_TOKEN, "<redacted-access-token>")
-    .replace(GITLAB_TOKEN, "<redacted-access-token>")
-    .replace(NPM_TOKEN, "<redacted-access-token>")
-    .replace(SLACK_TOKEN, "<redacted-access-token>")
-    .replace(GOOGLE_API_KEY, "<redacted-cloud-key>")
-    .replace(PAYMENT_API_KEY, "<redacted-api-secret>")
-    .replace(JWT_VALUE, "<redacted-bearer-token>")
-    .replace(URL_CREDENTIALS, "<redacted-credential-url>")
-    .replace(API_SECRET, "<redacted-api-secret>")
-    .replace(PRIVATE_KEY_HEADER, "<redacted-private-key-header>")
-    .replace(EMAIL_VALUE, "<redacted-email>");
-  for (const home of HOME_PATHS) sanitized = sanitized.split(home).join("<home>");
-  sanitized = sanitized
-    .replace(/\/(?:Users|home)\/[^/\s"'<>]+(?=\/|$)/g, "<home>")
-    .replace(/\b[A-Za-z]:\\Users\\[^\\\s"'<>]+(?=\\|$)/g, "<home>")
-    .replace(/[\u200B-\u200F\u202A-\u202E\u2066-\u2069\uFEFF]/g, "")
-    .replace(/[\r\n\t]/g, match => match === "\t" ? "\\t" : "\\n")
-    .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f]/g, "?");
-  if (!Number.isFinite(Number(maxChars)) || Number(maxChars) <= 0) return "";
-  const limit = Math.max(16, Number(maxChars));
-  return sanitized.length > limit ? `${sanitized.slice(0, limit - 1)}…` : sanitized;
+  return sanitizePortableLogText(value, { maxChars, homePaths: HOME_PATHS });
 }
 
 function safeHomeDirectory() {