@the-open-engine/zeroshot 6.39.1 → 6.40.0

package/task-lib/commands/logs.js

@@ -7,6 +7,7 @@ import { createRequire } from 'module';
 // Import cluster's stream parser (shared between task and cluster)
 const require = createRequire(import.meta.url);
 const { parseChunk } = require('../../lib/stream-json-parser');
+const { decodeTaskLogLine } = require('../../src/task-log-line');
 
 // Tool icons for different tool types
 const TOOL_ICONS = {
@@ -271,16 +272,12 @@ function handleMulti(event) {
 }
 
 // Parse a raw log line (may have timestamp prefix)
-function parseLogLine(line) {
-  let trimmed = line.trim();
+export function parseLogLine(line) {
+  const decoded = decodeTaskLogLine(line);
+  if (!decoded.providerOutput) return [];
+  const trimmed = decoded.content.trim();
   if (!trimmed) return [];
 
-  // Strip timestamp prefix if present: [1234567890]{...} -> {...}
-  const timestampMatch = trimmed.match(/^\[\d+\](.*)$/);
-  if (timestampMatch) {
-    trimmed = timestampMatch[1];
-  }
-
   // Non-JSON lines output as-is
   if (!trimmed.startsWith('{')) {
     return [{ type: 'text', text: trimmed + '\n' }];

package/task-lib/runner.js

@@ -1,5 +1,5 @@
-import { fork } from 'child_process';
-import { join, dirname, resolve as resolvePath } from 'path';
+import { execFileSync, spawn } from 'child_process';
+import { isAbsolute, join, dirname, relative, resolve as resolvePath } from 'path';
 import { fileURLToPath } from 'url';
 import { mkdirSync } from 'fs';
 import { LOGS_DIR } from './config.js';
@@ -17,6 +17,8 @@ import {
 import { createRequire } from 'module';
 
 const require = createRequire(import.meta.url);
+const { resolveTaskExecutionContext } = require('../src/task-execution-context.js');
+export { resolveTaskExecutionContext };
 const {
   buildOmpPrompt,
   getProviderRegistryEntry,
@@ -43,8 +45,6 @@ const {
   partitionPathFor,
   createOmpSessionPartitionDirectory,
 } = require('../src/omp-session-partition');
-const TASK_EXECUTION_CONTEXT_ENV = 'ZEROSHOT_TASK_EXECUTION_CONTEXT';
-const TASK_EXECUTION_CONTEXTS = new Set(['host', 'detached', 'docker', 'benchmark']);
 export {
   isOwnedProcessTreeRunning,
   isProcessRunning,
@@ -401,8 +401,22 @@ function resolveOutputFormat(options) {
 }
 
 function resolveJsonSchema(options, outputFormat) {
-  let jsonSchema = options.jsonSchema || null;
-  if (jsonSchema && outputFormat !== 'json') {
+  let jsonSchema = options.jsonSchema ?? null;
+  if (typeof jsonSchema === 'string') {
+    try {
+      jsonSchema = JSON.parse(jsonSchema);
+    } catch (error) {
+      throw new Error(`--json-schema must be valid JSON: ${error.message}`);
+    }
+  }
+  if (
+    jsonSchema !== null &&
+    typeof jsonSchema !== 'boolean' &&
+    (typeof jsonSchema !== 'object' || Array.isArray(jsonSchema))
+  ) {
+    throw new Error('--json-schema must be a boolean or JSON Schema object.');
+  }
+  if (jsonSchema !== null && outputFormat !== 'json') {
     console.warn('Warning: --json-schema requires --output-format json, ignoring schema');
     jsonSchema = null;
   }
@@ -411,11 +425,13 @@ function resolveJsonSchema(options, outputFormat) {
 
 function buildProviderOptions(options, runtime, modelSelection) {
   const structuredOutputRecovery = options.structuredOutputRecovery === true;
+  const executionContext = resolveTaskExecutionContext();
   return {
     outputFormat: runtime.outputFormat,
     jsonSchema: runtime.jsonSchema,
     cwd: runtime.cwd,
-    executionContext: resolveTaskExecutionContext(),
+    ...codexGitMetadataOption(options, runtime.cwd, executionContext),
+    executionContext,
     autoApprove: !structuredOutputRecovery,
     ...(modelSelection === undefined ? {} : { modelSpec: modelSelection.modelSpec }),
     ...(structuredOutputRecovery ? {} : mcpConfigOption(options)),
@@ -430,15 +446,35 @@ function buildProviderOptions(options, runtime, modelSelection) {
   };
 }
 
-export function resolveTaskExecutionContext(environment = process.env) {
-  const context = environment[TASK_EXECUTION_CONTEXT_ENV];
-  if (context === undefined) return 'detached';
-  if (!TASK_EXECUTION_CONTEXTS.has(context)) {
-    throw new Error(
-      `${TASK_EXECUTION_CONTEXT_ENV} must be one of: ${[...TASK_EXECUTION_CONTEXTS].join(', ')}.`
-    );
+function codexGitMetadataOption(options, cwd, executionContext) {
+  const settings = loadSettings();
+  const providerName = normalizeProviderName(
+    options.provider || settings.defaultProvider || getDefaultProviderId()
+  );
+  if (providerName !== 'codex') return {};
+  if (executionContext === 'docker' || executionContext === 'benchmark') return {};
+  const directories = resolveCodexGitMetadataDirectories(cwd);
+  return directories.length === 0 ? {} : { additionalWritableDirectories: directories };
+}
+
+export function resolveCodexGitMetadataDirectories(cwd, runGit = execFileSync) {
+  try {
+    const raw = runGit('git', ['rev-parse', '--git-common-dir'], {
+      cwd,
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const commonDirectory = resolvePath(cwd, raw.trim());
+    const fromWorkspace = relative(resolvePath(cwd), commonDirectory);
+    const outsideWorkspace =
+      isAbsolute(fromWorkspace) ||
+      fromWorkspace === '..' ||
+      fromWorkspace.startsWith('../') ||
+      fromWorkspace.startsWith('..\\');
+    return outsideWorkspace ? [commonDirectory] : [];
+  } catch {
+    return [];
   }
-  return context;
 }
 
 function claudeSettingsFileOption() {
@@ -655,14 +691,14 @@ function resolveWatcherScript(options, providerName, invoke) {
 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)],
+  const watcher = spawn(
+    process.execPath,
+    [watcherScript, id, cwd, logFile, JSON.stringify(finalArgs), JSON.stringify(watcherConfig)],
     {
       detached: true,
-      // 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',
+      // A prompt-carrying lane needs only a private stdin pipe; detached watchers have no parent
+      // messaging contract, so an IPC channel would add a second, racy wrapper-lifetime owner.
+      stdio: sendsPrompt ? ['pipe', 'ignore', 'ignore'] : 'ignore',
       windowsHide: true,
       env: watcherEnv,
     }
@@ -673,7 +709,6 @@ function spawnWatcher({ watcherScript, id, cwd, logFile, finalArgs, watcherConfi
   if (sendsPrompt) sendWatcherPrompt(watcher.stdin, rpcPrompt);
 
   watcher.unref();
-  watcher.disconnect(); // Close IPC channel so parent can exit
 }
 
 export function buildWatcherEnv(sourceEnv = process.env) {

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

@@ -0,0 +1,31 @@
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const {
+  formatTaskLogMarker,
+  formatTaskLogStderr,
+  formatTaskLogStdout,
+} = require('../src/task-log-line.js');
+
+export function markSdkTaskLog(log, timestamp = Date.now()) {
+  log(formatTaskLogMarker(timestamp));
+}
+
+function normalizedTerminalEvent(terminal) {
+  if (terminal.type === 'result') return terminal.event;
+  return {
+    type: 'result',
+    success: false,
+    error: { ...terminal.frame.error },
+  };
+}
+
+export function logSdkTerminal(log, result, now = Date.now) {
+  for (const frame of result.progress) {
+    log(formatTaskLogStdout(now(), JSON.stringify(frame)));
+  }
+  log(formatTaskLogStdout(now(), JSON.stringify(normalizedTerminalEvent(result.terminal))));
+  for (const line of (result.diagnosticStderr || '').replace(/\r/g, '').split('\n')) {
+    if (line) log(formatTaskLogStderr(now(), line));
+  }
+}

package/task-lib/sdk-watcher.js

@@ -7,6 +7,7 @@
 import { appendFileSync } from 'fs';
 import { getTask, updateTask } from './store.js';
 import { createCommandSpecCleanup } from './command-spec-cleanup.js';
+import { logSdkTerminal, markSdkTaskLog } from './sdk-watcher-output.js';
 import {
   completePendingWatcherCancellation,
   completeWatcherFailure,
@@ -72,16 +73,6 @@ function completionFor(result) {
   };
 }
 
-function logTerminal(result) {
-  for (const frame of result.progress) log(`[${Date.now()}]${JSON.stringify(frame)}\n`);
-  const terminal =
-    result.terminal.type === 'result' ? result.terminal.event : result.terminal.frame;
-  log(`[${Date.now()}]${JSON.stringify(terminal)}\n`);
-  if (result.diagnosticStderr) {
-    log(`[${Date.now()}][SDK-DIAGNOSTIC] ${result.diagnosticStderr}\n`);
-  }
-}
-
 async function terminateOwnedProviderBoundary() {
   if (terminalResult) return terminalResult.cleanupAttestation.clean === true;
   if (!running) return true;
@@ -116,6 +107,8 @@ process.on('unhandledRejection', (reason) => {
   void crashWithError(reason, 'unhandledRejection');
 });
 
+markSdkTaskLog(log);
+
 if (
   await completePendingWatcherCancellation({
     taskId,
@@ -139,7 +132,7 @@ try {
   if (getTask(taskId)?.cancelRequested) running.cancel();
 
   terminalResult = await running.result;
-  logTerminal(terminalResult);
+  logSdkTerminal(log, terminalResult);
   await completeWatcherTask({
     taskId,
     completion: completionFor(terminalResult),

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

@@ -8,6 +8,14 @@ import {
   supportsProviderStructuredOutputRecovery,
 } from './provider-helper-runtime.js';
 import { terminateProcess } from './process-termination.js';
+import { createRequire } from 'module';
+
+const require = createRequire(import.meta.url);
+const {
+  TASK_LOG_STDOUT_PREFIX,
+  formatTaskLogMarker,
+  formatTaskLogStdout,
+} = require('../src/task-log-line.js');
 
 export const COMMAND_CLEANUP_UNINITIALIZED = Symbol('command-cleanup-uninitialized');
 
@@ -69,7 +77,7 @@ function createCodexOutputPassthrough({ log, captureProviderSession }) {
     let offset = 0;
     while (offset < text.length) {
       if (atLineStart) {
-        logged.push(`[${timestamp}]`);
+        logged.push(`[${timestamp}]${TASK_LOG_STDOUT_PREFIX}`);
         atLineStart = false;
       }
       const newline = text.indexOf('\n', offset);
@@ -128,7 +136,7 @@ function createBoundedLinePassthrough({
     }
     if (byteLength > MAX_WATCHER_CONTROL_RECORD_BYTES) {
       if (deferRawUntilOverflow && log) {
-        log(`[${lineTimestamp}]${inspectionParts.join('')}${part}`);
+        log(`[${lineTimestamp}]${linePrefix}${inspectionParts.join('')}${part}`);
         rawOverflowStreaming = true;
       }
       inspectable = false;
@@ -310,8 +318,10 @@ export function completeWatcherFailure({ error, source, ...completionOptions })
  * frames, prompt text, or control payloads.
  */
 export function createRpcWatcherOutputRuntime({ log }) {
+  log(formatTaskLogMarker(Date.now()));
+
   function logEvent(event) {
-    log(`[${Date.now()}]${JSON.stringify(event)}\n`);
+    log(formatTaskLogStdout(Date.now(), JSON.stringify(event)));
   }
 
   function complete(result) {
@@ -350,6 +360,7 @@ export function createWatcherOutputRuntime({
   let finalResultJson = null;
   let streamingModeError = null;
   let fatalError = null;
+  log(formatTaskLogMarker(Date.now()));
   const captureProviderSession = providerSessionCapture?.captureLine || (() => {});
   const codexOutputPassthrough =
     providerName === 'codex' ? createCodexOutputPassthrough({ log, captureProviderSession }) : null;
@@ -358,6 +369,7 @@ export function createWatcherOutputRuntime({
     : createBoundedLinePassthrough({
         log,
         deferRawUntilOverflow: silentJsonMode,
+        linePrefix: TASK_LOG_STDOUT_PREFIX,
         handleLine: (line, timestamp, { oversized }) =>
           handleOutputLine(line, timestamp, {
             alreadyLogged: !silentJsonMode,
@@ -366,19 +378,20 @@ export function createWatcherOutputRuntime({
       });
   const stderrPassthrough = createBoundedLinePassthrough({
     log,
-    // Pi reserves stdout for its JSON protocol and deliberately routes ordinary writes to
-    // stderr. Keep those diagnostics in the task log with explicit provenance so followers can
-    // exclude them from strict JSON validation.
-    linePrefix: providerName === 'pi' ? '[ZEROSHOT][PROVIDER_STDERR] ' : '',
-    handleLine: (line, timestamp) => maybeHandleFatalError(line, timestamp),
+    // Stderr must never be mistaken for provider protocol output. Fatal detection still receives
+    // the raw line through handleLine; only the persisted task-log representation is tagged.
+    linePrefix: '[ZEROSHOT][PROVIDER_STDERR] ',
+    handleLine: (line, timestamp) => maybeHandleFatalError(line, timestamp, true),
   });
 
-  function maybeHandleFatalError(line, timestamp) {
+  function maybeHandleFatalError(line, timestamp, rawPersisted = false) {
     if (fatalError) return false;
     const detected = detectProviderFatalError(providerName, line);
     if (!detected) return false;
     fatalError = detected;
-    if (silentJsonMode) log(`[${timestamp}]${line}\n`);
+    if (silentJsonMode && !rawPersisted) {
+      log(formatTaskLogStdout(timestamp, line));
+    }
     log(`[${timestamp}][ZEROSHOT][FATAL] ${detected}\n`);
     stopProvider(timestamp);
     return true;
@@ -413,12 +426,12 @@ export function createWatcherOutputRuntime({
     if (silentJsonMode && !line.trim()) return;
     // Pi reserves stdout for JSON lifecycle events. Error text inside an assistant message may be
     // followed by an automatic retry, so only Pi stderr can prove a pre-agent startup failure.
-    if (providerName !== 'pi') maybeHandleFatalError(line, timestamp);
+    if (providerName !== 'pi') maybeHandleFatalError(line, timestamp, alreadyLogged);
     if (captureStreamingError(line, timestamp)) return;
     if (silentJsonMode) {
       maybeCaptureStructuredOutput(line);
     } else if (!alreadyLogged) {
-      log(`[${timestamp}]${line}\n`);
+      log(formatTaskLogStdout(timestamp, line));
     }
   }
 
@@ -444,11 +457,10 @@ export function createWatcherOutputRuntime({
       if (silentJsonMode) {
         finalResultJson = recoveredLine;
       } else {
-        log(`[${timestamp}]${recoveredLine}\n`);
+        log(formatTaskLogStdout(timestamp, recoveredLine));
       }
     } else if (streamingModeError.line) {
-      const prefix = silentJsonMode ? '' : `[${streamingModeError.timestamp}]`;
-      log(`${prefix}${streamingModeError.line}\n`);
+      log(formatTaskLogStdout(streamingModeError.timestamp, streamingModeError.line));
     }
     return recovered;
   }
@@ -463,7 +475,9 @@ export function createWatcherOutputRuntime({
     if (stderrBuffer !== null) stderrPassthrough.flush();
     const recovered = attemptRecovery(code, timestamp);
     const sessionIdentityError = providerSessionCapture?.getCompletionError() || null;
-    if (silentJsonMode && finalResultJson) log(`${finalResultJson}\n`);
+    if (silentJsonMode && finalResultJson) {
+      log(formatTaskLogStdout(timestamp, finalResultJson));
+    }
     if (config.outputFormat !== 'json') {
       log(`\n${'='.repeat(50)}\n`);
       log(`Finished: ${new Date().toISOString()}\n`);