chainlesschain 0.162.154 → 0.162.155

package/src/runtime/headless-runner.js

@@ -15,9 +15,11 @@
  * Permission model: headless cannot show an interactive approval prompt, so the
  * default is fail-closed (deny MEDIUM/HIGH-risk shell). --permission-mode opts
  * into a looser tier:
- *  - (default) / plan   → STRICT  + deny-confirmer  (plan also restricts tools)
- *  - acceptEdits        → TRUSTED + deny-confirmer  (HIGH-risk shell still denied)
- *  - bypassPermissions  → AUTOPILOT (everything allowed, no confirm)
+ *  - (default) / manual / dontAsk / plan → STRICT + deny-confirmer
+ *    (plan also restricts tools)
+ *  - auto / acceptEdits                  → TRUSTED + deny-confirmer
+ *    (HIGH-risk shell still denied)
+ *  - bypassPermissions                   → AUTOPILOT (everything allowed)
  */
 
 import { bootstrap } from "./bootstrap.js";
@@ -33,6 +35,7 @@ import {
   resolvePermissionPromptTool,
   makePermissionPromptConfirmer,
 } from "./mcp-config.js";
+import { maybeApplyToolSearch } from "./mcp-tool-search.js";
 import { IterationBudget } from "../lib/iteration-budget.js";
 import {
   startSession as jsonlStartSession,
@@ -68,6 +71,9 @@ export const READ_ONLY_TOOLS = Object.freeze([
 
 const VALID_PERMISSION_MODES = Object.freeze([
   "default",
+  "manual",
+  "auto",
+  "dontAsk",
   "plan",
   "acceptEdits",
   "bypassPermissions",
@@ -81,19 +87,30 @@ export { installPipeSafety } from "./pipe-safety.js";
 import { installPipeSafety } from "./pipe-safety.js";
 
 /**
- * Resolve a --permission-mode string into the session-policy tier + a
- * non-interactive confirmer + whether to clamp tools to the read-only set.
+ * Normalize a public --permission-mode spelling to the canonical internal mode.
  *
- * @param {string} mode
- * @returns {{ sessionPolicy: string, confirmer: (ctx:any)=>Promise<boolean>, readOnly: boolean }}
+ * @param {string} [mode]
+ * @returns {string}
  */
-export function resolvePermissionMode(mode = "default") {
+export function normalizePermissionMode(mode = "default") {
   const m = mode || "default";
   if (!VALID_PERMISSION_MODES.includes(m)) {
     throw new Error(
       `Invalid --permission-mode "${m}". Expected one of: ${VALID_PERMISSION_MODES.join(", ")}`,
     );
   }
+  return m;
+}
+
+/**
+ * Resolve a --permission-mode string into the session-policy tier + a
+ * non-interactive confirmer + whether to clamp tools to the read-only set.
+ *
+ * @param {string} mode
+ * @returns {{ sessionPolicy: string, confirmer: (ctx:any)=>Promise<boolean>, readOnly: boolean, allowInteractiveApprovals: boolean }}
+ */
+export function resolvePermissionMode(mode = "default") {
+  const m = normalizePermissionMode(mode);
   // Headless can't ask a human — deny when a confirm would be required.
   const denyConfirmer = async () => false;
   const allowConfirmer = async () => true;
@@ -103,25 +120,38 @@ export function resolvePermissionMode(mode = "default") {
         sessionPolicy: "autopilot",
         confirmer: allowConfirmer,
         readOnly: false,
+        allowInteractiveApprovals: false,
       };
+    case "auto":
     case "acceptEdits":
       return {
         sessionPolicy: "trusted",
         confirmer: denyConfirmer,
         readOnly: false,
+        allowInteractiveApprovals: true,
       };
     case "plan":
       return {
         sessionPolicy: "strict",
         confirmer: denyConfirmer,
         readOnly: true,
+        allowInteractiveApprovals: true,
+      };
+    case "dontAsk":
+      return {
+        sessionPolicy: "strict",
+        confirmer: denyConfirmer,
+        readOnly: false,
+        allowInteractiveApprovals: false,
       };
+    case "manual":
     case "default":
     default:
       return {
         sessionPolicy: "strict",
         confirmer: denyConfirmer,
         readOnly: false,
+        allowInteractiveApprovals: true,
       };
   }
 }
@@ -610,6 +640,28 @@ export async function runAgentHeadless(options = {}, deps = {}) {
   let approvalGate = null;
   try {
     approvalGate = await getApprovalGate();
+    if (approvalGate && (options.permissionMode || "default") === "auto") {
+      // autoMode.decisions: user-configured riskLevel → allow/ask/deny
+      // classifier. Only wrap when settings actually customize the map so the
+      // unconfigured auto path keeps the byte-identical trusted-tier mapping.
+      try {
+        const {
+          loadAutoModeConfig,
+          resolveAutoModeDecisions,
+          createAutoModeApprovalGate,
+        } = await import("../lib/auto-mode-config.js");
+        const autoConfig = loadAutoModeConfig({
+          cwd,
+          settingsFile: options.settingsFile,
+        });
+        const resolved = resolveAutoModeDecisions(autoConfig.effective);
+        if (resolved.customized) {
+          approvalGate = createAutoModeApprovalGate(approvalGate, resolved);
+        }
+      } catch {
+        // fail to the default trusted mapping — never block the run
+      }
+    }
     if (approvalGate) {
       if (typeof approvalGate.setSessionPolicy === "function") {
         approvalGate.setSessionPolicy(sessionId, perm.sessionPolicy);
@@ -800,6 +852,22 @@ export async function runAgentHeadless(options = {}, deps = {}) {
           writeErr(`  mcp: ${c.server} (${c.tools} tools)\n`);
         }
       }
+      // MCP tool search (context scaling): when the tool schemas would eat a
+      // significant share of the context window, defer them behind the
+      // internal tool_search tool. Below-threshold / disabled → no-op, the
+      // wiring object is untouched.
+      if (mcp) {
+        try {
+          (deps.maybeApplyToolSearch || maybeApplyToolSearch)(mcp, {
+            model,
+            provider,
+            cwd: options.cwd || process.cwd(),
+            writeErr: isText ? writeErr : () => {},
+          });
+        } catch {
+          // best-effort — full schemas still work without deferral
+        }
+      }
     } catch (err) {
       writeErr(`Error: ${err.message}\n`);
       emitHeadlessError(err.message);
@@ -861,6 +929,35 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     }
   }
 
+  // --remote-control: route CONFIRM-tier approvals to paired mobile/web
+  // devices (第四阶段 #2). Self-hosts a lightweight WS server + approval
+  // bridge for THIS run's session, prints the pairing URI/QR to stderr, and
+  // installs the remote confirmer on the gate (same override point as
+  // --permission-prompt-tool; that flag wins when both are given since it is
+  // installed above and this block skips). Fail-closed on timeout.
+  let _remoteApproval = null;
+  if (options.remoteControl && !options.permissionPromptTool) {
+    try {
+      const { startHeadlessRemoteApproval } =
+        await import("../lib/remote-approval-bridge.js");
+      _remoteApproval = await (
+        deps.startHeadlessRemoteApproval || startHeadlessRemoteApproval
+      )({
+        agentSessionId: sessionId,
+        writeErr,
+        isText,
+      });
+      if (approvalGate && typeof approvalGate.setConfirmer === "function") {
+        approvalGate.setConfirmer(_remoteApproval.confirmer);
+      }
+    } catch (err) {
+      // Remote approval could not come up → keep headless fail-closed rather
+      // than running un-gated; say why so the user can fix pairing.
+      writeErr(`  remote-control: unavailable (${err.message})\n`);
+      _remoteApproval = null;
+    }
+  }
+
   // --otlp <file>: attach an OpenTelemetry recorder so the real agent loop's
   // model/tool/retry spans are captured and exported as OTLP/JSON on exit.
   // Off by default (zero cost) — only built when a path is requested.
@@ -1350,6 +1447,15 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     } catch {
       // best-effort — never mask the run's own outcome
     }
+    // Tear down the --remote-control approval bridge + its self-hosted WS
+    // server so the run's port/socket never outlives the invocation.
+    if (_remoteApproval) {
+      try {
+        await _remoteApproval.close();
+      } catch {
+        // best-effort — never mask the run's own outcome
+      }
+    }
     // settings.json Stop + SessionEnd hooks when the run finishes. Stop is the
     // canonical async-hook trigger ("run the test suite at turn end"); fire its
     // async hooks fire-and-forget, then settle so a fast background check can
@@ -1502,6 +1608,18 @@ export async function runAgentHeadless(options = {}, deps = {}) {
     } else if (isStream) {
       emitStream({ type: "denials_summary", count: denials.length, denials });
     }
+    try {
+      const { appendRecentDenials } =
+        await import("../lib/permission-denial-store.js");
+      appendRecentDenials(denials, {
+        sessionId,
+        permissionMode: options.permissionMode || "default",
+        cwd,
+        source: "headless",
+      });
+    } catch {
+      // Persisting the review surface is best-effort; never affect the run.
+    }
   }
 
   if (isStream) {

package/src/runtime/headless-stream.js

@@ -42,6 +42,7 @@ import {
   resolvePermissionPromptTool,
   makePermissionPromptConfirmer,
 } from "./mcp-config.js";
+import { maybeApplyToolSearch } from "./mcp-tool-search.js";
 import { IterationBudget } from "../lib/iteration-budget.js";
 import { CostBudget } from "../lib/cost-budget.js";
 import {
@@ -723,10 +724,34 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
   let approvalGate = null;
   try {
     approvalGate = await getApprovalGate();
+    if (approvalGate && (options.permissionMode || "default") === "auto") {
+      // autoMode.decisions: user-configured riskLevel → allow/ask/deny
+      // classifier (same wiring as headless-runner). Only wrap when settings
+      // customize the map so the unconfigured path stays byte-identical.
+      try {
+        const {
+          loadAutoModeConfig,
+          resolveAutoModeDecisions,
+          createAutoModeApprovalGate,
+        } = await import("../lib/auto-mode-config.js");
+        const autoConfig = loadAutoModeConfig({
+          cwd,
+          settingsFile: options.settingsFile,
+        });
+        const resolved = resolveAutoModeDecisions(autoConfig.effective);
+        if (resolved.customized) {
+          approvalGate = createAutoModeApprovalGate(approvalGate, resolved);
+        }
+      } catch {
+        // fail to the default trusted mapping — never block the run
+      }
+    }
     if (approvalGate) {
       approvalGate.setSessionPolicy?.(sessionId, perm.sessionPolicy);
       approvalGate.setConfirmer?.(
-        interactive ? interactiveConfirm : perm.confirmer,
+        interactive && perm.allowInteractiveApprovals
+          ? interactiveConfirm
+          : perm.confirmer,
       );
     }
   } catch {
@@ -949,6 +974,20 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
           loadJetbrainsMcp: deps.loadJetbrainsMcp,
         },
       );
+      // MCP tool search (context scaling): defer big tool schemas behind the
+      // internal tool_search tool. Below-threshold / disabled → no-op.
+      if (mcp) {
+        try {
+          (deps.maybeApplyToolSearch || maybeApplyToolSearch)(mcp, {
+            model,
+            provider,
+            cwd: options.cwd || process.cwd(),
+            writeErr,
+          });
+        } catch {
+          // best-effort — full schemas still work without deferral
+        }
+      }
     } catch (err) {
       emit({
         type: "result",
@@ -987,6 +1026,43 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
     }
   }
 
+  // --remote-control: route CONFIRM-tier approvals to paired mobile/web
+  // devices (第四阶段 #2). Pairing info is emitted as a stream event so panel
+  // hosts can render the QR. --permission-prompt-tool and --interactive-
+  // approvals win when given (this block skips) — explicit routing beats the
+  // ambient device bridge.
+  let _remoteApproval = null;
+  if (
+    options.remoteControl &&
+    !options.permissionPromptTool &&
+    options.interactiveApprovals !== true
+  ) {
+    try {
+      const { startHeadlessRemoteApproval } =
+        await import("../lib/remote-approval-bridge.js");
+      _remoteApproval = await startHeadlessRemoteApproval({
+        agentSessionId: sessionId,
+      });
+      emit({
+        type: "remote_control",
+        subtype: "pairing",
+        pairing_uri: _remoteApproval.pairing.uri,
+        remote_session_id: _remoteApproval.pairing.remoteSessionId,
+        expires_at: _remoteApproval.pairing.expiresAt,
+      });
+      if (approvalGate && typeof approvalGate.setConfirmer === "function") {
+        approvalGate.setConfirmer(_remoteApproval.confirmer);
+      }
+    } catch (err) {
+      emit({
+        type: "remote_control",
+        subtype: "unavailable",
+        error: err.message,
+      });
+      _remoteApproval = null;
+    }
+  }
+
   const loopOptionsBase = {
     model,
     provider,
@@ -1723,6 +1799,16 @@ export async function runAgentHeadlessStream(options = {}, deps = {}) {
     }
   }
 
+  // Tear down the --remote-control approval bridge + its self-hosted WS
+  // server so the stream session's port never outlives the invocation.
+  if (_remoteApproval) {
+    try {
+      await _remoteApproval.close();
+    } catch {
+      // best-effort
+    }
+  }
+
   // settings.json SessionEnd hooks (observe-only) when stdin closes.
   if (settingsHooks) {
     try {

package/src/runtime/mcp-config.js

@@ -169,6 +169,14 @@ export async function setupMcpFromConfig(servers, deps = {}) {
   // (created before this field existed) is passed in.
   if (!Array.isArray(result.resources)) result.resources = [];
   if (!Array.isArray(result.prompts)) result.prompts = [];
+  // Per-server usage instructions from the MCP initialize response (surfaced
+  // by tool search; absent for servers that send none).
+  if (
+    !result.instructionsByServer ||
+    typeof result.instructionsByServer !== "object"
+  ) {
+    result.instructionsByServer = {};
+  }
   const {
     mcpClient,
     extraToolDefinitions,
@@ -261,6 +269,9 @@ export async function setupMcpFromConfig(servers, deps = {}) {
       resources: resources.length,
       prompts: prompts.length,
     });
+    if (typeof res?.instructions === "string" && res.instructions.trim()) {
+      result.instructionsByServer[name] = res.instructions.trim();
+    }
     for (const r of resources) {
       if (!r || !r.uri) continue;
       result.resources.push({ ...r, server: name });

package/src/runtime/policies/agent-policy.js

@@ -44,6 +44,17 @@ export function resolveAgentPolicy({
     // IDEA built-in MCP tri-state (undefined=auto when the JetBrains plugin
     // injected the endpoint / true=--jetbrains / false=--no-jetbrains).
     jetbrains: overrides.jetbrains,
+    // Consumed by the interactive REPL (startAgentRepl) — plain passthrough
+    // (undefined = unset). These were silently dropped by this allowlist
+    // before 2026-07-09, breaking --vim/--think/--thinking-budget/
+    // --fallback-model/--pdh/--permission-mode for interactive sessions.
+    permissionMode: overrides.permissionMode,
+    vimMode: overrides.vimMode,
+    thinking: overrides.thinking,
+    thinkingBudget: overrides.thinkingBudget,
+    fallbackModels: overrides.fallbackModels,
+    pdh: overrides.pdh,
+    outputStyle: overrides.outputStyle,
   };
 }
 
@@ -58,6 +69,12 @@ export function resolveServerPolicy(overrides = {}) {
     project: overrides.project || process.cwd(),
     httpPort: overrides.httpPort || null,
     bundlePath: overrides.bundlePath || null,
+    // startServer() reads these for the Remote Session E2EE relay. They were
+    // silently dropped by this allowlist before 2026-07-09 — `cc serve
+    // --remote-session-relay-url` never actually enabled the relay (same
+    // allowlist-drop class as the batch-9 resolveAgentPolicy fix).
+    remoteSessionRelayUrl: overrides.remoteSessionRelayUrl || null,
+    remoteSessionPeerId: overrides.remoteSessionPeerId || null,
   };
 }
 

package/src/workers/background-agent-worker.js

@@ -1,60 +1,241 @@
+/**
+ * background-agent-worker — detached supervisor process for one background
+ * session. Spawns the agent CLI child with output to the session log, keeps a
+ * heartbeat in the state file, and (since batch 10) hosts a local session
+ * transport so `cc attach <id>` can send follow-up prompts interactively.
+ *
+ * Turn loop: the initial task runs as turn 1. While a client is attached the
+ * worker stays alive between turns (phase "idle"); a received prompt starts
+ * the next turn via `job.followUpArgv + ["-p", text]` on the same session id
+ * (headless `--session` resumes the conversation). The worker finalizes and
+ * exits only when the current turn has ended, the prompt queue is empty, and
+ * no client is attached.
+ */
+
 import { spawn } from "node:child_process";
 import { readFileSync } from "node:fs";
+import { randomBytes } from "node:crypto";
 import {
+  DEFAULT_HEARTBEAT_INTERVAL_MS,
+  backgroundAgentsDir,
   openBackgroundLogFile,
   readBackgroundAgentState,
   removeJobFile,
   writeBackgroundAgentState,
 } from "../lib/background-agent-supervisor.js";
+import { startBackgroundSessionServer } from "../lib/background-session-transport.js";
 
 const jobFile = process.argv[2];
 let job;
-try {
-  job = JSON.parse(readFileSync(jobFile, "utf8"));
-  removeJobFile(jobFile);
-  const log = openBackgroundLogFile(job.id);
-  const child = spawn(process.execPath, [job.cliEntry, ...job.argv], {
+let log;
+let server = null;
+let child = null;
+let heartbeat = null;
+let finalized = false;
+let phase = "turn";
+let turnCount = 0;
+let lastExit = { code: 0, signal: null };
+let transportState = null;
+const promptQueue = [];
+
+function mergeState(patch) {
+  const current = readBackgroundAgentState(job.id) || { id: job.id };
+  const next = { ...current, id: job.id, ...patch };
+  writeBackgroundAgentState(next);
+  return next;
+}
+
+function writeHeartbeat() {
+  const current = readBackgroundAgentState(job.id) || { id: job.id };
+  if (current.status && current.status !== "running") return false;
+  writeBackgroundAgentState({
+    ...current,
+    id: job.id,
+    pid: process.pid,
+    workerPid: process.pid,
+    agentPid: child?.pid ?? current.agentPid ?? null,
+    status: "running",
+    heartbeatAt: Date.now(),
+    // Re-assert the transport endpoint so a launcher write racing the
+    // worker's initial merge self-heals within one heartbeat.
+    ...(transportState ? { transport: transportState } : {}),
+  });
+  return true;
+}
+
+function finalize(code, signal, errorMessage) {
+  if (finalized) return;
+  finalized = true;
+  clearInterval(heartbeat);
+  const current = readBackgroundAgentState(job.id) || { id: job.id };
+  // An external `cc daemon stop` already recorded its own terminal status —
+  // don't overwrite it; just clear the dead transport endpoint.
+  if (!current.status || current.status === "running") {
+    writeBackgroundAgentState({
+      ...current,
+      id: job.id,
+      status: errorMessage ? "failed" : code === 0 ? "completed" : "failed",
+      endedAt: Date.now(),
+      exitCode: errorMessage ? (code ?? 1) : code,
+      signal: signal || null,
+      ...(errorMessage ? { error: errorMessage } : {}),
+      phase: null,
+      transport: null,
+    });
+  } else {
+    writeBackgroundAgentState({ ...current, phase: null, transport: null });
+  }
+  const done = () => {
+    try {
+      log?.close();
+    } catch {
+      /* log fd already closed */
+    }
+    process.exit(errorMessage ? 1 : (code ?? 1));
+  };
+  if (server) {
+    server.broadcast({ type: "closing" });
+    server.close().then(done, done);
+  } else {
+    done();
+  }
+}
+
+function startTurn(argv, promptText) {
+  phase = "turn";
+  turnCount++;
+  child = spawn(process.execPath, [job.cliEntry, ...argv], {
     cwd: job.cwd,
     env: { ...process.env, CC_BACKGROUND_AGENT_ID: job.id },
     stdio: ["ignore", log.fd, log.fd],
     windowsHide: true,
   });
+  mergeState({
+    status: "running",
+    phase,
+    turnCount,
+    agentPid: child.pid,
+    heartbeatAt: Date.now(),
+  });
+  server?.broadcast({
+    type: "turn-started",
+    turn: turnCount,
+    prompt: promptText || null,
+  });
   child.on("exit", (code, signal) => {
-    const current = readBackgroundAgentState(job.id) || {};
-    if (current.status === "running") {
-      writeBackgroundAgentState({
-        ...current,
-        status: code === 0 ? "completed" : "failed",
-        endedAt: Date.now(),
-        exitCode: code,
-        signal: signal || null,
-      });
-    }
-    log.close();
-    process.exit(code ?? 1);
+    lastExit = { code, signal };
+    child = null;
+    server?.broadcast({ type: "turn-ended", turn: turnCount, exitCode: code });
+    maybeContinue();
   });
   child.on("error", (error) => {
-    const current = readBackgroundAgentState(job.id) || { id: job.id };
-    writeBackgroundAgentState({
-      ...current,
-      status: "failed",
-      endedAt: Date.now(),
-      exitCode: 1,
-      error: error.message,
-    });
-    log.close();
-    process.exit(1);
+    child = null;
+    finalize(1, null, error.message);
   });
-} catch (error) {
-  if (job?.id) {
-    const current = readBackgroundAgentState(job.id) || { id: job.id };
-    writeBackgroundAgentState({
-      ...current,
-      status: "failed",
-      endedAt: Date.now(),
-      exitCode: 1,
-      error: error.message,
+}
+
+function maybeContinue() {
+  if (finalized) return;
+  // External stop marked the session terminal while a turn was in flight —
+  // don't start another turn against a stopped session.
+  const current = readBackgroundAgentState(job.id);
+  if (current?.status && current.status !== "running") {
+    finalize(lastExit.code, lastExit.signal);
+    return;
+  }
+  if (promptQueue.length && Array.isArray(job.followUpArgv)) {
+    const text = promptQueue.shift();
+    startTurn([...job.followUpArgv, "-p", text], text);
+    return;
+  }
+  if (server && server.clientCount() > 0) {
+    phase = "idle";
+    mergeState({ phase, agentPid: null, heartbeatAt: Date.now() });
+    server.broadcast({ type: "idle", turn: turnCount });
+    return;
+  }
+  finalize(lastExit.code, lastExit.signal);
+}
+
+function getStatus() {
+  return {
+    id: job.id,
+    sessionId: job.sessionId || null,
+    title: job.title || null,
+    phase,
+    turn: turnCount,
+    interactive: Array.isArray(job.followUpArgv),
+  };
+}
+
+async function main() {
+  job = JSON.parse(readFileSync(jobFile, "utf8"));
+  removeJobFile(jobFile);
+  log = openBackgroundLogFile(job.id);
+
+  // Session transport (best-effort): interactive attach needs it, but a
+  // transport failure must never take down the background task itself.
+  try {
+    const token = randomBytes(16).toString("hex");
+    server = await startBackgroundSessionServer({
+      id: job.id,
+      dir: backgroundAgentsDir(),
+      token,
+      getStatus,
+      onPrompt: (text) => {
+        if (!Array.isArray(job.followUpArgv)) {
+          throw new Error(
+            "this session was launched without follow-up support — start a new one with cc agent --bg",
+          );
+        }
+        promptQueue.push(text);
+        const queued = promptQueue.length;
+        if (!child) maybeContinue();
+        return { queued };
+      },
+      onStop: () => {
+        child?.kill("SIGTERM");
+      },
+      onClientChange: (count) => {
+        // Last client detached while the session is idle → nothing left to
+        // wait for; finalize with the last turn's exit code.
+        if (count === 0 && !child && promptQueue.length === 0) {
+          finalize(lastExit.code, lastExit.signal);
+        }
+      },
     });
+    transportState = { pipe: server.pipePath, token };
+    mergeState({ transport: transportState });
+  } catch {
+    server = null;
   }
-  process.exit(1);
+
+  writeHeartbeat();
+  heartbeat = setInterval(() => {
+    try {
+      if (!writeHeartbeat()) {
+        clearInterval(heartbeat);
+        // External stop: the child tree is being killed by the stopper; make
+        // sure the worker itself never lingers holding the pipe.
+        if (!child) finalize(lastExit.code, lastExit.signal);
+      }
+    } catch {
+      /* do not let heartbeat persistence kill the worker */
+    }
+  }, DEFAULT_HEARTBEAT_INTERVAL_MS);
+  heartbeat.unref?.();
+
+  startTurn(job.argv, null);
 }
+
+main().catch((error) => {
+  if (job?.id) {
+    try {
+      finalize(1, null, error.message);
+      return;
+    } catch {
+      /* fall through to hard exit */
+    }
+  }
+  process.exit(1);
+});