@the-open-engine/zeroshot 6.21.0 → 6.23.0

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,