@the-open-engine/zeroshot 6.21.0 → 6.23.0

package/src/watcher-prompt-channel.js

@@ -0,0 +1,209 @@
+/**
+ * Private parent -> detached-watcher prompt channel.
+ *
+ * The OMP prompt is task content (repository text, instructions, whatever a caller pasted in), so
+ * it must never travel in the watcher's argv: `ps` and /proc/<pid>/cmdline expose argv to every
+ * local user for the entire lifetime of a long-lived watcher. task-lib/runner.js therefore hands
+ * the prompt to task-lib/rpc-watcher.js over the anonymous stdin pipe fork() creates for it. The
+ * pipe has exactly two ends and no name, so nothing is written to the filesystem, the task log, or
+ * the ledger while the prompt is in transit.
+ *
+ * Framing is a newline-terminated JSON header followed by exactly `promptBytes` UTF-8 bytes. That
+ * declared length is what lets the receiver tell a complete payload apart from an absent,
+ * truncated, over-long, or over-contract one, so it can fail closed instead of prompting the
+ * provider with a partial instruction.
+ */
+
+const { TextDecoder } = require('util');
+
+const PROMPT_CHANNEL_KIND = 'zeroshot-watcher-prompt-v1';
+
+// The header is a single short JSON object ({"kind":"...","promptBytes":1048576} is 56 bytes), so a
+// peer that never sends a newline must not be able to make the receiver buffer without bound before
+// the declared payload length is even known.
+const MAX_PROMPT_CHANNEL_HEADER_BYTES = 256;
+
+class WatcherPromptChannelError extends Error {
+  constructor(code, message) {
+    super(message);
+    this.name = 'WatcherPromptChannelError';
+    this.code = code;
+  }
+}
+
+function encodeWatcherPromptFrame(prompt) {
+  const body = Buffer.from(prompt, 'utf8');
+  const header = `${JSON.stringify({ kind: PROMPT_CHANNEL_KIND, promptBytes: body.byteLength })}\n`;
+  return Buffer.concat([Buffer.from(header, 'utf8'), body]);
+}
+
+/**
+ * Write the framed prompt into the watcher's stdin pipe and close the write end.
+ *
+ * The receiver owns fail-closed handling for a short or missing payload, so a watcher that already
+ * exited (a cancellation requested before spawn closes the read end) has to surface here as a
+ * swallowed EPIPE rather than as an unhandled 'error' that would take down the spawning process.
+ */
+function sendWatcherPrompt(stream, prompt) {
+  stream.on('error', () => {});
+  stream.end(encodeWatcherPromptFrame(prompt));
+}
+
+function parsePromptChannelHeader(headerText, maxBytes) {
+  let header;
+  try {
+    header = JSON.parse(headerText);
+  } catch {
+    throw new WatcherPromptChannelError(
+      'malformed-header',
+      'Prompt channel header is not valid JSON.'
+    );
+  }
+  if (header === null || typeof header !== 'object' || header.kind !== PROMPT_CHANNEL_KIND) {
+    throw new WatcherPromptChannelError(
+      'malformed-header',
+      `Prompt channel header is not a ${PROMPT_CHANNEL_KIND} frame.`
+    );
+  }
+  const { promptBytes } = header;
+  if (!Number.isSafeInteger(promptBytes) || promptBytes < 0) {
+    throw new WatcherPromptChannelError(
+      'malformed-header',
+      "Prompt channel header has an invalid 'promptBytes' value."
+    );
+  }
+  if (promptBytes > maxBytes) {
+    throw new WatcherPromptChannelError(
+      'prompt-too-large',
+      `Prompt channel declared ${promptBytes} bytes, above the ${maxBytes}-byte contract.`
+    );
+  }
+  return promptBytes;
+}
+
+/**
+ * Read exactly one framed prompt off `stream`, or reject with a WatcherPromptChannelError.
+ *
+ * Every rejection path is a fail-closed one: an absent channel, a header that never arrives, a
+ * declared length above `maxBytes`, a payload that ends short of (or overruns) the declared length,
+ * and invalid UTF-8 all reject rather than resolving with partial text.
+ */
+function receiveWatcherPrompt(stream, { maxBytes }) {
+  return new Promise((resolve, reject) => {
+    if (!stream || typeof stream.on !== 'function' || stream.isTTY) {
+      reject(
+        new WatcherPromptChannelError(
+          'absent',
+          'No private prompt pipe is attached to this watcher.'
+        )
+      );
+      return;
+    }
+
+    let buffer = Buffer.alloc(0);
+    let declaredBytes = null;
+    let settled = false;
+
+    function detach() {
+      stream.removeListener('data', onData);
+      stream.removeListener('end', onEnd);
+      stream.removeListener('error', onError);
+      // destroy() can emit 'error' after the listeners above are gone, which would otherwise throw
+      // as an unhandled 'error' event and mask the real channel outcome.
+      stream.on('error', () => {});
+      try {
+        stream.destroy();
+      } catch {
+        // Already released; nothing further to close.
+      }
+    }
+
+    function fail(code, message) {
+      if (settled) return;
+      settled = true;
+      detach();
+      reject(new WatcherPromptChannelError(code, message));
+    }
+
+    function succeed(prompt) {
+      if (settled) return;
+      settled = true;
+      detach();
+      resolve(prompt);
+    }
+
+    function readHeader() {
+      const newlineIndex = buffer.indexOf(0x0a);
+      if (newlineIndex === -1) {
+        if (buffer.byteLength > MAX_PROMPT_CHANNEL_HEADER_BYTES) {
+          fail(
+            'malformed-header',
+            `Prompt channel header exceeded ${MAX_PROMPT_CHANNEL_HEADER_BYTES} bytes without a newline.`
+          );
+        }
+        return false;
+      }
+      const headerText = buffer.subarray(0, newlineIndex).toString('utf8');
+      buffer = buffer.subarray(newlineIndex + 1);
+      try {
+        declaredBytes = parsePromptChannelHeader(headerText, maxBytes);
+      } catch (error) {
+        fail(error.code, error.message);
+        return false;
+      }
+      return true;
+    }
+
+    function consume() {
+      if (declaredBytes === null && !readHeader()) return;
+      if (buffer.byteLength > declaredBytes) {
+        fail(
+          'overlong-payload',
+          `Prompt channel delivered more than the declared ${declaredBytes} bytes.`
+        );
+        return;
+      }
+      if (buffer.byteLength < declaredBytes) return;
+      let prompt;
+      try {
+        prompt = new TextDecoder('utf-8', { fatal: true }).decode(buffer);
+      } catch {
+        fail('invalid-utf8', 'Prompt channel payload is not valid UTF-8.');
+        return;
+      }
+      succeed(prompt);
+    }
+
+    function onData(chunk) {
+      if (settled) return;
+      buffer = Buffer.concat([buffer, chunk]);
+      consume();
+    }
+
+    function onEnd() {
+      fail(
+        'truncated',
+        declaredBytes === null
+          ? 'Prompt channel closed before a complete header arrived.'
+          : `Prompt channel closed after ${buffer.byteLength} of ${declaredBytes} declared bytes.`
+      );
+    }
+
+    function onError(error) {
+      fail('channel-error', `Prompt channel failed: ${error.message}`);
+    }
+
+    stream.on('data', onData);
+    stream.on('end', onEnd);
+    stream.on('error', onError);
+  });
+}
+
+module.exports = {
+  MAX_PROMPT_CHANNEL_HEADER_BYTES,
+  PROMPT_CHANNEL_KIND,
+  WatcherPromptChannelError,
+  encodeWatcherPromptFrame,
+  receiveWatcherPrompt,
+  sendWatcherPrompt,
+};

package/task-lib/command-spec-cleanup.js

@@ -1,265 +1,4 @@
-import { lstat, realpath, rm, unlink } from 'fs/promises';
-import { lstatSync, realpathSync, rmSync, unlinkSync } from 'fs';
-import { tmpdir } from 'os';
-import { basename, dirname, isAbsolute, resolve } from 'path';
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
-const {
-  isCanonicalClaudeSettingsOverlayDirectory,
-  isClaudeSettingsOverlayDirectory,
-} = require('../src/worktree-claude-config');
-
-const CLEANUP_METADATA_KEYS = ['kind', 'path', 'provider', 'reason'];
-const SCHEMA_DIRECTORY_PATTERN = /^zeroshot-schema-[A-Za-z0-9_-]+$/u;
-const SCHEMA_FILE_PATTERN =
-  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.json$/u;
-const POLICY_DIRECTORY_PATTERN = /^zeroshot-gemini-policy-[A-Za-z0-9_-]+$/u;
-const POLICY_FILE_PATTERN =
-  /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}\.toml$/u;
-const OPENCODE_CONFIG_DIRECTORY_PATTERN = /^zeroshot-opencode-config-[A-Za-z0-9_-]+$/u;
-
-function assertClosedCleanupMetadata(cleanupPath, metadata) {
-  if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata)) {
-    throw new Error(`Refusing cleanup without closed ownership metadata: ${cleanupPath}`);
-  }
-  const keys = Object.keys(metadata).sort();
-  if (
-    keys.length !== CLEANUP_METADATA_KEYS.length ||
-    keys.some((key, index) => key !== CLEANUP_METADATA_KEYS[index])
-  ) {
-    throw new Error(`Refusing cleanup with open ownership metadata: ${cleanupPath}`);
-  }
-  if (metadata.path !== cleanupPath) {
-    throw new Error(`Refusing cleanup with mismatched ownership path: ${cleanupPath}`);
-  }
-}
-
-function createCleanupPlan(commandSpec) {
-  if (!Array.isArray(commandSpec?.cleanup) || !Array.isArray(commandSpec?.cleanupMetadata)) {
-    throw new Error('Refusing cleanup with malformed cleanup collections');
-  }
-  if (commandSpec.cleanup.length !== commandSpec.cleanupMetadata.length) {
-    throw new Error('Refusing cleanup without one closed metadata receipt per path');
-  }
-  const uniquePaths = new Set(commandSpec.cleanup);
-  if (uniquePaths.size !== commandSpec.cleanup.length) {
-    throw new Error('Refusing cleanup with duplicate cleanup paths');
-  }
-
-  return commandSpec.cleanup.map((cleanupPath) => {
-    if (typeof cleanupPath !== 'string' || cleanupPath.length === 0) {
-      throw new Error('Refusing cleanup with a non-string or empty path');
-    }
-    const matches = commandSpec.cleanupMetadata.filter(
-      (metadata) => metadata?.path === cleanupPath
-    );
-    if (matches.length !== 1) {
-      throw new Error(`Refusing cleanup without exact ownership metadata: ${cleanupPath}`);
-    }
-    assertClosedCleanupMetadata(cleanupPath, matches[0]);
-    return { cleanupPath, metadata: matches[0] };
-  });
-}
-
-function assertOwnedTempDirectory(cleanupPath, metadata) {
-  const isOpenCodeConfig =
-    metadata.provider === 'opencode' && metadata.reason === 'isolated-config';
-  if (isOpenCodeConfig) {
-    const canonical =
-      isAbsolute(cleanupPath) &&
-      resolve(cleanupPath) === cleanupPath &&
-      dirname(cleanupPath) === resolve(tmpdir()) &&
-      OPENCODE_CONFIG_DIRECTORY_PATTERN.test(basename(cleanupPath));
-    if (!canonical) {
-      throw new Error(`Refusing unowned temporary directory cleanup: ${cleanupPath}`);
-    }
-    let stat;
-    try {
-      stat = lstatSync(cleanupPath);
-    } catch (error) {
-      if (error?.code === 'ENOENT') return true;
-      throw error;
-    }
-    const tempRoot = realpathSync(tmpdir());
-    const realDirectory = realpathSync(cleanupPath);
-    if (
-      stat.isSymbolicLink() ||
-      !stat.isDirectory() ||
-      dirname(realDirectory) !== tempRoot ||
-      basename(realDirectory) !== basename(cleanupPath)
-    ) {
-      throw new Error(`Refusing unowned temporary directory cleanup: ${cleanupPath}`);
-    }
-    return false;
-  }
-
-  if (
-    metadata.provider !== 'claude' ||
-    metadata.reason !== 'settings-overlay' ||
-    !isCanonicalClaudeSettingsOverlayDirectory(cleanupPath)
-  ) {
-    throw new Error(`Refusing unowned temporary directory cleanup: ${cleanupPath}`);
-  }
-  if (isClaudeSettingsOverlayDirectory(cleanupPath)) {
-    return false;
-  }
-  try {
-    lstatSync(cleanupPath);
-  } catch (error) {
-    if (error?.code === 'ENOENT') return true;
-    throw error;
-  }
-  throw new Error(`Refusing unowned temporary directory cleanup: ${cleanupPath}`);
-}
-
-function assertCanonicalSchemaPath(cleanupPath, metadata) {
-  const isCodexSchema =
-    metadata.kind === 'temp-file' &&
-    metadata.provider === 'codex' &&
-    metadata.reason === 'output-schema';
-  const isGeminiPolicy =
-    metadata.kind === 'temp-file' &&
-    metadata.provider === 'gemini' &&
-    metadata.reason === 'admin-policy';
-  if (
-    (!isCodexSchema && !isGeminiPolicy) ||
-    !isAbsolute(cleanupPath) ||
-    resolve(cleanupPath) !== cleanupPath
-  ) {
-    throw new Error(
-      `Refusing unowned ${isGeminiPolicy ? 'admin-policy' : 'output-schema'} cleanup: ${cleanupPath}`
-    );
-  }
-  const ownedDirectory = dirname(cleanupPath);
-  const matchesOwnedName = isCodexSchema
-    ? SCHEMA_DIRECTORY_PATTERN.test(basename(ownedDirectory)) &&
-      SCHEMA_FILE_PATTERN.test(basename(cleanupPath))
-    : POLICY_DIRECTORY_PATTERN.test(basename(ownedDirectory)) &&
-      POLICY_FILE_PATTERN.test(basename(cleanupPath));
-  if (dirname(ownedDirectory) !== resolve(tmpdir()) || !matchesOwnedName) {
-    throw new Error(
-      `Refusing non-canonical ${isGeminiPolicy ? 'admin-policy' : 'output-schema'} cleanup: ${cleanupPath}`
-    );
-  }
-}
-
-async function assertOwnedSchemaFile(cleanupPath, metadata) {
-  assertCanonicalSchemaPath(cleanupPath, metadata);
-  const schemaDirectory = dirname(cleanupPath);
-  const [tempRoot, realSchemaDirectory, directoryStat, schemaStat] = await Promise.all([
-    realpath(tmpdir()),
-    realpath(schemaDirectory),
-    lstat(schemaDirectory),
-    lstat(cleanupPath),
-  ]);
-  if (
-    directoryStat.isSymbolicLink() ||
-    !directoryStat.isDirectory() ||
-    dirname(realSchemaDirectory) !== tempRoot ||
-    basename(realSchemaDirectory) !== basename(schemaDirectory) ||
-    schemaStat.isSymbolicLink() ||
-    !schemaStat.isFile()
-  ) {
-    throw new Error(`Refusing non-regular or escaped output-schema cleanup: ${cleanupPath}`);
-  }
-}
-
-function assertOwnedSchemaFileSync(cleanupPath, metadata) {
-  assertCanonicalSchemaPath(cleanupPath, metadata);
-  const schemaDirectory = dirname(cleanupPath);
-  const tempRoot = realpathSync(tmpdir());
-  const realSchemaDirectory = realpathSync(schemaDirectory);
-  const directoryStat = lstatSync(schemaDirectory);
-  const schemaStat = lstatSync(cleanupPath);
-  if (
-    directoryStat.isSymbolicLink() ||
-    !directoryStat.isDirectory() ||
-    dirname(realSchemaDirectory) !== tempRoot ||
-    basename(realSchemaDirectory) !== basename(schemaDirectory) ||
-    schemaStat.isSymbolicLink() ||
-    !schemaStat.isFile()
-  ) {
-    throw new Error(`Refusing non-regular or escaped output-schema cleanup: ${cleanupPath}`);
-  }
-}
-
-async function removeCleanupPath(cleanupPath, metadata) {
-  if (metadata.kind === 'temp-directory') {
-    if (assertOwnedTempDirectory(cleanupPath, metadata)) return;
-    await rm(cleanupPath, { recursive: true, force: true });
-    return;
-  }
-  await assertOwnedSchemaFile(cleanupPath, metadata);
-  await unlink(cleanupPath);
-}
-
-function removeCleanupPathSync(cleanupPath, metadata) {
-  if (metadata.kind === 'temp-directory') {
-    if (assertOwnedTempDirectory(cleanupPath, metadata)) return;
-    rmSync(cleanupPath, { recursive: true, force: true });
-    return;
-  }
-  assertOwnedSchemaFileSync(cleanupPath, metadata);
-  unlinkSync(cleanupPath);
-}
-
-/**
- * Build one idempotent cleanup owner for a provider command. Callers may run it
- * only after the persisted provider termination boundary is terminal.
- */
-export function createCommandSpecCleanup(commandSpec, logFailure) {
-  let started = false;
-  let result = true;
-
-  return {
-    async run() {
-      if (started) return result;
-      started = true;
-      let cleanupPlan;
-      try {
-        cleanupPlan = createCleanupPlan(commandSpec);
-      } catch (error) {
-        logFailure('<command-cleanup>', error);
-        result = false;
-        return result;
-      }
-      let succeeded = true;
-      for (const { cleanupPath, metadata } of cleanupPlan) {
-        try {
-          await removeCleanupPath(cleanupPath, metadata);
-        } catch (error) {
-          if (error?.code === 'ENOENT') continue;
-          succeeded = false;
-          logFailure(cleanupPath, error);
-        }
-      }
-      result = succeeded;
-      return result;
-    },
-    runSync() {
-      if (started) return result;
-      started = true;
-      let cleanupPlan;
-      try {
-        cleanupPlan = createCleanupPlan(commandSpec);
-      } catch (error) {
-        logFailure('<command-cleanup>', error);
-        result = false;
-        return result;
-      }
-      let succeeded = true;
-      for (const { cleanupPath, metadata } of cleanupPlan) {
-        try {
-          removeCleanupPathSync(cleanupPath, metadata);
-        } catch (error) {
-          if (error?.code === 'ENOENT') continue;
-          succeeded = false;
-          logFailure(cleanupPath, error);
-        }
-      }
-      result = succeeded;
-      return result;
-    },
-  };
-}
+export const { createCommandSpecCleanup } = require('../src/command-cleanup-ownership');

package/task-lib/provider-helper-runtime.js

@@ -13,8 +13,13 @@ try {
 }
 
 export const {
+  ABORT_GRACE_MS,
+  DEFAULT_OMP_RPC_DECODER_LIMITS,
+  EXIT_GRACE_MS,
   NO_MESSAGES_RETURNED,
+  OMP_SUPPORTED_VERSION,
   STREAMING_MODE_ERROR,
+  buildOmpPrompt,
   buildProviderCommand,
   classifyProviderError,
   detectProviderFatalError,
@@ -32,6 +37,7 @@ export const {
   recoverProviderStructuredOutput,
   resolveProviderCommand,
   resolveModelSpec,
+  runOmpRpcTask,
   supportsProviderCapability,
   providerAliasMap,
   providerAliases,

package/task-lib/rpc-watcher.js

@@ -0,0 +1,186 @@
+#!/usr/bin/env node
+
+/**
+ * Watcher process for the rpc-stdio invoke lane (OMP RPC v2). Runs detached from the parent,
+ * drives the session over stdio via the shared runOmpRpcTask driver (task-lib/runner.js resolves
+ * this script instead of watcher.js whenever the resolved provider's invoke.lane is 'rpc-stdio'),
+ * and updates task status on completion. Foreground (contract-invoke.ts) and this detached watcher
+ * both call runOmpRpcTask and therefore produce identical result semantics; the only difference is
+ * that this watcher persists OmpRpcSpawnEvidence via updateTask before the prompt is written.
+ *
+ * The prompt itself never appears in argv (`ps` and /proc/<pid>/cmdline would expose it for as long
+ * as this watcher lives). task-lib/runner.js sends it over the private stdin pipe described in
+ * src/watcher-prompt-channel.js, and OMP is not spawned until a complete payload has arrived.
+ */
+
+import { appendFileSync } from 'fs';
+import { getTask, updateTask } from './store.js';
+import { createCommandSpecCleanup } from './command-spec-cleanup.js';
+import {
+  completeWatcherFailure,
+  completePendingWatcherCancellation,
+  completeWatcherTask,
+  createRpcWatcherOutputRuntime,
+  terminateWatcherProvider,
+} from './watcher-output-runtime.js';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const {
+  ABORT_GRACE_MS,
+  DEFAULT_OMP_RPC_DECODER_LIMITS,
+  EXIT_GRACE_MS,
+  OMP_SUPPORTED_VERSION,
+  runOmpRpcTask,
+} = require('./provider-helper-runtime.js');
+const { receiveWatcherPrompt } = require('../src/watcher-prompt-channel.js');
+
+// No overall task timeout: detached tasks run until the provider produces a terminal frame,
+// matching watcher.js's unbounded child.on('close') wait for every other lane.
+const NO_TIMEOUT_MS = 2_147_483_647;
+
+const [, , taskId, cwd, logFile, , configJson] = process.argv;
+const config = configJson ? JSON.parse(configJson) : {};
+const commandSpec = config.commandSpec || {};
+
+function log(msg) {
+  appendFileSync(logFile, msg);
+}
+
+function emergencyLog(msg) {
+  try {
+    log(msg);
+  } catch {
+    process.stderr.write(msg);
+  }
+}
+
+const commandCleanup = createCommandSpecCleanup(commandSpec, (cleanupPath, error) => {
+  emergencyLog(`[${Date.now()}][CLEANUP] Failed to delete ${cleanupPath}: ${error.message}\n`);
+});
+
+const outputRuntime = createRpcWatcherOutputRuntime({ log });
+
+let crashStarted = false;
+let spawnEvidence = null;
+
+function terminateOwnedProviderBoundary(exitObserved = false) {
+  if (!spawnEvidence) return true;
+  return terminateWatcherProvider(
+    { pid: spawnEvidence.pid },
+    { exitObserved, platform: process.platform }
+  );
+}
+
+async function crashWithError(error, source) {
+  if (crashStarted) return;
+  crashStarted = true;
+  await completeWatcherFailure({
+    taskId,
+    error,
+    source,
+    commandCleanup,
+    terminateProvider: terminateOwnedProviderBoundary,
+    updateTask,
+    emergencyLog,
+  });
+  process.exit(1);
+}
+
+process.on('uncaughtException', (error) => {
+  void crashWithError(error, 'uncaughtException');
+});
+
+process.on('unhandledRejection', (reason) => {
+  void crashWithError(reason, 'unhandledRejection');
+});
+
+async function run() {
+  if (
+    await completePendingWatcherCancellation({
+      taskId,
+      getTask,
+      commandCleanup,
+      terminateProvider: () => true,
+      updateTask,
+      emergencyLog,
+    })
+  ) {
+    process.exit(0);
+    return;
+  }
+
+  // Fail closed before any provider process exists: an absent, truncated, over-contract, or
+  // early-closed prompt channel must end the task through the same ownership-aware cleanup path as
+  // any other crash, never spawn OMP with a partial instruction. The 1 MiB ceiling is the pinned
+  // physical RPC frame limit — a larger prompt could never be written as a `prompt` command anyway.
+  let prompt;
+  try {
+    prompt = await receiveWatcherPrompt(process.stdin, {
+      maxBytes: DEFAULT_OMP_RPC_DECODER_LIMITS.maxPhysicalFrameBytes,
+    });
+  } catch (error) {
+    await crashWithError(error, 'prompt-channel');
+    return;
+  }
+
+  const controller = new AbortController();
+
+  const result = await runOmpRpcTask(
+    {
+      commandSpec: { ...commandSpec, cwd: commandSpec.cwd || cwd },
+      prompt,
+      expectedVersion: OMP_SUPPORTED_VERSION,
+      session: { kind: 'none' },
+      signal: controller.signal,
+      timeoutMs: NO_TIMEOUT_MS,
+      abortGraceMs: ABORT_GRACE_MS,
+      exitGraceMs: EXIT_GRACE_MS,
+    },
+    {
+      onSpawn: async (evidence) => {
+        spawnEvidence = evidence;
+        await updateTask(taskId, {
+          pid: evidence.pid,
+          processGroupId: evidence.processGroupId,
+          terminationStrategy: evidence.terminationStrategy,
+        });
+        if (getTask(taskId)?.cancelRequested) {
+          crashStarted = true;
+          controller.abort();
+          await completePendingWatcherCancellation({
+            taskId,
+            getTask,
+            commandCleanup,
+            terminateProvider: terminateOwnedProviderBoundary,
+            updateTask,
+            emergencyLog,
+          });
+          process.exit(0);
+        }
+      },
+      onEvent: (event) => {
+        outputRuntime.logEvent(event);
+        return Promise.resolve();
+      },
+      onSession: async () => {},
+    }
+  );
+
+  if (crashStarted) return; // Cancelled mid-spawn; the onSpawn hook already exited the process.
+
+  const completion = outputRuntime.complete(result);
+  await completeWatcherTask({
+    taskId,
+    completion,
+    commandCleanup,
+    terminateProvider: () => terminateOwnedProviderBoundary(true),
+    updateTask,
+    emergencyLog,
+  });
+  process.exit(0);
+}
+
+run().catch((error) => {
+  void crashWithError(error, 'run');
+});