@the-open-engine/zeroshot 6.22.0 → 6.24.0

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');
+});

package/task-lib/runner.js

@@ -6,7 +6,11 @@ import { addTask, generateId, ensureDirs } from './store.js';
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
-const { prepareSingleAgentProviderCommand } = require('./provider-helper-runtime.js');
+const {
+  buildOmpPrompt,
+  getProviderRegistryEntry,
+  prepareSingleAgentProviderCommand,
+} = require('./provider-helper-runtime.js');
 const {
   ISOLATED_SETTINGS_FILE_ENV,
   ISOLATED_SETTINGS_FILE_MARKER,
@@ -18,6 +22,7 @@ const {
   isClaudeSettingsOverlayPath,
 } = require('../src/worktree-claude-config');
 const { TASK_SPAWN_OWNERSHIP_TOKEN_ENV } = require('../src/task-spawn-cleanup-ownership');
+const { sendWatcherPrompt } = require('../src/watcher-prompt-channel');
 export {
   isOwnedProcessTreeRunning,
   isProcessRunning,
@@ -79,6 +84,12 @@ export function spawnTask(prompt, options = {}) {
     logFile,
     finalArgs: commandSpec.args,
     watcherConfig,
+    // Prompt bytes never enter argv: the rpc-stdio watcher receives them over a private pipe
+    // (src/watcher-prompt-channel.js). Every other lane passes the prompt to the provider through
+    // commandSpec.args, which the provider process — not a long-lived watcher — then owns.
+    ...(isRpcStdioLane(providerName)
+      ? { rpcPrompt: buildOmpPrompt(prompt, prepared.options || {}) }
+      : {}),
   });
 
   return task;
@@ -250,6 +261,13 @@ export function buildTaskRecord({
   };
 }
 
+function isRpcStdioLane(providerName) {
+  return getProviderRegistryEntry(providerName).invoke.lane === 'rpc-stdio';
+}
+
+// The returned object is JSON-serialized into the detached watcher's argv, so it must never carry
+// prompt or other task content: `ps` and /proc/<pid>/cmdline expose argv to every local user for
+// the whole lifetime of the watcher.
 function buildWatcherConfig(outputFormat, jsonSchema, options, providerName, commandSpec) {
   return {
     outputFormat,
@@ -259,13 +277,13 @@ function buildWatcherConfig(outputFormat, jsonSchema, options, providerName, com
     provider: providerName,
     command: commandSpec.binary,
     env: commandSpec.env || {},
-    commandSpec: buildWatcherCommandSpec(commandSpec),
+    commandSpec: buildWatcherCommandSpec(commandSpec, isRpcStdioLane(providerName)),
   };
 }
 
-function buildWatcherCommandSpec(commandSpec) {
+function buildWatcherCommandSpec(commandSpec, keepArgs = false) {
   const watcherCommandSpec = { ...commandSpec };
-  delete watcherCommandSpec.args;
+  if (!keepArgs) delete watcherCommandSpec.args;
   return watcherCommandSpec;
 }
 
@@ -274,6 +292,12 @@ export function shouldUseAttachableWatcher(options, providerName) {
     return false;
   }
 
+  // The rpc-stdio lane owns bidirectional correlated RPC over stdio itself (see
+  // omp-rpc-driver.ts) and always uses rpc-watcher.js instead of the attachable PTY watcher.
+  if (isRpcStdioLane(providerName)) {
+    return false;
+  }
+
   // Claude strict structured output still needs the non-PTY watcher. Claude
   // can treat PTY notifications as streaming commands and reject the run.
   // Other providers, including Codex, support their structured-output mode in
@@ -282,23 +306,33 @@ export function shouldUseAttachableWatcher(options, providerName) {
 }
 
 function resolveWatcherScript(options, providerName) {
+  if (isRpcStdioLane(providerName)) {
+    return join(__dirname, 'rpc-watcher.js');
+  }
   const useAttachable = shouldUseAttachableWatcher(options, providerName);
   return useAttachable ? join(__dirname, 'attachable-watcher.js') : join(__dirname, 'watcher.js');
 }
 
-function spawnWatcher({ watcherScript, id, cwd, logFile, finalArgs, watcherConfig }) {
+function spawnWatcher({ watcherScript, id, cwd, logFile, finalArgs, watcherConfig, rpcPrompt }) {
+  const sendsPrompt = typeof rpcPrompt === 'string';
   const watcherEnv = buildWatcherEnv();
   const watcher = fork(
     watcherScript,
     [id, cwd, logFile, JSON.stringify(finalArgs), JSON.stringify(watcherConfig)],
     {
       detached: true,
-      stdio: 'ignore',
+      // A prompt-carrying lane needs a real pipe on fd 0 to receive it; every other lane keeps
+      // stdio fully ignored. fork() requires an explicit 'ipc' slot once stdio is an array.
+      stdio: sendsPrompt ? ['pipe', 'ignore', 'ignore', 'ipc'] : 'ignore',
       windowsHide: true,
       env: watcherEnv,
     }
   );
 
+  // Only the pipe write holds the event loop (until it drains), never the watcher itself: the
+  // parent still exits without waiting for the detached task to finish.
+  if (sendsPrompt) sendWatcherPrompt(watcher.stdin, rpcPrompt);
+
   watcher.unref();
   watcher.disconnect(); // Close IPC channel so parent can exit
 }

package/task-lib/watcher-output-runtime.js

@@ -140,6 +140,38 @@ export function completeWatcherFailure({ error, source, ...completionOptions })
   });
 }
 
+/**
+ * Output runtime for the rpc-stdio lane (see task-lib/rpc-watcher.js). Unlike
+ * createWatcherOutputRuntime, there is no raw stdout/stderr byte stream to parse: the
+ * OMP RPC driver (omp-rpc-driver.ts) already normalizes every frame into an OutputEvent before
+ * calling onEvent, so this runtime only ever logs already-normalized events — never raw RPC
+ * frames, prompt text, or control payloads.
+ */
+export function createRpcWatcherOutputRuntime({ log }) {
+  function logEvent(event) {
+    log(`[${Date.now()}]${JSON.stringify(event)}\n`);
+  }
+
+  function complete(result) {
+    const lastResult = [...result.events].reverse().find((event) => event.type === 'result');
+    const turnFailed = lastResult !== undefined && lastResult.success === false;
+    const success = result.stopReason === 'completed' && !turnFailed;
+    const resolvedCode = success ? 0 : 1;
+    log(`\n${'='.repeat(50)}\n`);
+    log(`Finished: ${new Date().toISOString()}\n`);
+    log(
+      `Stop reason: ${result.stopReason}, Exit code: ${result.exitCode}, Signal: ${result.signal}\n`
+    );
+    return {
+      resolvedCode,
+      status: success ? 'completed' : 'failed',
+      error: success ? null : (lastResult && lastResult.error) || result.stopReason,
+    };
+  }
+
+  return { logEvent, complete };
+}
+
 export function createWatcherOutputRuntime({
   config,
   providerName,