@the-open-engine/zeroshot 6.39.2 → 6.40.0

package/src/agent/agent-task-executor.js

@@ -18,6 +18,7 @@ const { StringDecoder } = require('string_decoder');
 const { getNestedExecutionRegistry, TaskExecutionHandle } = require('./task-execution-handle');
 const os = require('os');
 const { parseProviderChunk, getProvider } = require('../providers');
+const { decodeTaskLogLine } = require('../task-log-line');
 const { getTask, getTaskBySpawnOwnershipToken } = require('../../task-lib/store.js');
 const { OMP_SESSIONLESS_ENV } = require('../../task-lib/omp-storage-root.js');
 const { loadSettings } = require('../../lib/settings.js');
@@ -1268,9 +1269,10 @@ async function waitForTaskReady(agent, taskId, maxRetries = 10, delayMs = 200) {
 
 const MAX_STATUS_FAILURES = 30;
 
-function createLogFollowState() {
+function createLogFollowState(taskId = null) {
   const state = {
     controlPlaneOutput: createControlPlaneOutputState(),
+    taskId,
     logFilePath: null,
     lastSize: 0,
     pollInterval: null,
@@ -1471,28 +1473,26 @@ function lookupLogFilePath(ctPath, taskId) {
 }
 
 function parseTimestampedLine(line) {
-  let timestamp = Date.now();
-  let content = line.replace(/\r$/, '');
-  let timestamped = false;
-
-  const timestampMatch = content.match(/^\[(\d{13})\](.*)$/);
-  if (timestampMatch) {
-    timestamp = parseInt(timestampMatch[1], 10);
-    content = timestampMatch[2];
-    timestamped = true;
-  }
-
-  return { timestamp, content, timestamped };
+  const decoded = decodeTaskLogLine(line);
+  return {
+    timestamp: decoded.timestamp ?? Date.now(),
+    content: decoded.content,
+    timestamped: decoded.timestamped,
+    providerOutput: decoded.providerOutput,
+    providerStdoutFramed: decoded.channel === 'provider_stdout',
+  };
 }
 
-function shouldSkipLogLine(content, providerName, timestamped) {
+function shouldSkipLogLine(
+  content,
+  providerName,
+  timestamped,
+  providerOutput,
+  providerStdoutFramed = false
+) {
+  if (!providerOutput) return true;
+  if (providerStdoutFramed) return false;
   if (providerName === 'pi') {
-    if (
-      content.startsWith('[ZEROSHOT][PROVIDER_STDERR] ') ||
-      content.startsWith('[ZEROSHOT][FATAL] ')
-    ) {
-      return true;
-    }
     if (timestamped) return false;
     return (
       /^={50}$/.test(content) ||
@@ -1504,7 +1504,6 @@ function shouldSkipLogLine(content, providerName, timestamped) {
     content.startsWith('===') ||
     content.startsWith('Finished:') ||
     content.startsWith('Exit code:') ||
-    content.startsWith('[ZEROSHOT][PROVIDER_STDERR] ') ||
     (content.includes('"type":"system"') && content.includes('"subtype":"init"'))
   );
 }
@@ -1522,7 +1521,7 @@ function isValidJsonLine(content) {
   }
 }
 
-function publishAgentOutputRecord(agent, providerName, record) {
+function publishAgentOutputRecord(agent, providerName, taskId, record) {
   agent._publish({
     topic: 'AGENT_OUTPUT',
     receiver: 'broadcast',
@@ -1536,6 +1535,7 @@ function publishAgentOutputRecord(agent, providerName, record) {
         role: agent.role,
         iteration: agent.iteration,
         provider: providerName,
+        ...(taskId ? { taskId } : {}),
       },
     },
   });
@@ -1545,8 +1545,9 @@ function broadcastAgentLine({ agent, providerName, state, line }) {
   const followerState = ensureControlPlaneOutputState(state);
   if (!line.trim()) return;
 
-  const { timestamp, content, timestamped } = parseTimestampedLine(line);
-  if (shouldSkipLogLine(content, providerName, timestamped)) {
+  const { timestamp, content, timestamped, providerOutput, providerStdoutFramed } =
+    parseTimestampedLine(line);
+  if (shouldSkipLogLine(content, providerName, timestamped, providerOutput, providerStdoutFramed)) {
     return;
   }
   const controlPlaneContent = redactTerminalFailureForControlPlane(
@@ -1567,14 +1568,14 @@ function broadcastAgentLine({ agent, providerName, state, line }) {
   }
 
   publishLiveControlPlaneRecord(followerState.controlPlaneOutput, record, (item) =>
-    publishAgentOutputRecord(agent, providerName, item)
+    publishAgentOutputRecord(agent, providerName, followerState.taskId, item)
   );
 }
 
 function flushAgentOutput(agent, providerName, state) {
   const followerState = ensureControlPlaneOutputState(state);
   flushTerminalControlPlaneOutput(followerState.controlPlaneOutput, (record) =>
-    publishAgentOutputRecord(agent, providerName, record)
+    publishAgentOutputRecord(agent, providerName, followerState.taskId, record)
   );
 }
 
@@ -2117,7 +2118,7 @@ function createLogFollower({
   executionHandle = null,
 }) {
   return new Promise((resolve, reject) => {
-    const state = createLogFollowState();
+    const state = createLogFollowState(taskId);
     state.skipStructuredResultCheck = skipStructuredResultCheck;
     state.nested = nested;
     state.logFilePath = lookupLogFilePath(ctPath, taskId);
@@ -3022,17 +3023,6 @@ function buildIsolatedLifecycleHandle({
   };
 }
 
-function parseIsolatedLogLine(line) {
-  const timestampMatch = line.match(/^\[(\d{13}|\d{4}-\d{2}-\d{2}T[^\]]+)\]\s*(.*)$/);
-  const timestamp = timestampMatch
-    ? /^\d{13}$/.test(timestampMatch[1])
-      ? Number.parseInt(timestampMatch[1], 10)
-      : new Date(timestampMatch[1]).getTime()
-    : Date.now();
-  const content = timestampMatch ? timestampMatch[2] : line;
-  return { timestamp, content, timestamped: timestampMatch !== null };
-}
-
 function publishIsolatedOutputRecord(agent, providerName, taskId, record) {
   agent.messageBus.publish({
     cluster_id: agent.cluster.id,
@@ -3052,8 +3042,14 @@ function publishIsolatedOutputRecord(agent, providerName, taskId, record) {
 }
 
 function retainIsolatedLine(state, providerName, line) {
-  const { timestamp, content, timestamped } = parseIsolatedLogLine(line);
-  if (!content.trim() || shouldSkipLogLine(content, providerName, timestamped)) return null;
+  const { timestamp, content, timestamped, providerOutput, providerStdoutFramed } =
+    parseTimestampedLine(line);
+  if (
+    !content.trim() ||
+    shouldSkipLogLine(content, providerName, timestamped, providerOutput, providerStdoutFramed)
+  ) {
+    return null;
+  }
   const controlPlaneContent = redactTerminalFailureForControlPlane(state, providerName, content);
   return appendControlPlaneRecord(state.controlPlaneOutput, {
     content: controlPlaneContent,

package/src/agent/output-extraction-json.js

@@ -1,4 +1,5 @@
 "use strict";
+const task_log_line_1 = require("../task-log-line");
 function isObjectRecord(value) {
     return value !== null && typeof value === 'object' && !Array.isArray(value);
 }
@@ -14,10 +15,6 @@ if (!isProvidersParserBoundary(rawProviders)) {
     throw new TypeError('providers module must expose parseProviderChunk');
 }
 const { parseProviderChunk } = rawProviders;
-function timestampBody(text) {
-    const match = /^\[(\d{13})\](.*)$/.exec(text);
-    return match ? (match[2] || '').trimStart() : null;
-}
 function prefixedJsonBody(text) {
     if (text.startsWith('{') || text.startsWith('['))
         return null;
@@ -33,8 +30,10 @@ function stripTimestamp(line) {
     const normalized = line.trim().replace(/\r$/, '');
     if (!normalized)
         return '';
-    const withoutTimestamp = timestampBody(normalized) ?? normalized;
-    return prefixedJsonBody(withoutTimestamp) ?? withoutTimestamp;
+    const decoded = (0, task_log_line_1.decodeTaskLogLine)(normalized);
+    if (!decoded.providerOutput)
+        return '';
+    return prefixedJsonBody(decoded.content) ?? decoded.content;
 }
 function parseJsonRecordLine(line) {
     const content = stripTimestamp(line);

package/src/agent/output-extraction-json.ts

@@ -1,4 +1,5 @@
 import type { JsonRecord, ProvidersParserBoundary } from './output-extraction-types';
+import { decodeTaskLogLine } from '../task-log-line';
 
 function isObjectRecord(value: unknown): value is JsonRecord {
   return value !== null && typeof value === 'object' && !Array.isArray(value);
@@ -20,11 +21,6 @@ if (!isProvidersParserBoundary(rawProviders)) {
 }
 const { parseProviderChunk } = rawProviders;
 
-function timestampBody(text: string): string | null {
-  const match = /^\[(\d{13})\](.*)$/.exec(text);
-  return match ? (match[2] || '').trimStart() : null;
-}
-
 function prefixedJsonBody(text: string): string | null {
   if (text.startsWith('{') || text.startsWith('[')) return null;
   const separatorIndex = text.indexOf('|');
@@ -38,8 +34,9 @@ function stripTimestamp(line: unknown): string {
   const normalized = line.trim().replace(/\r$/, '');
   if (!normalized) return '';
 
-  const withoutTimestamp = timestampBody(normalized) ?? normalized;
-  return prefixedJsonBody(withoutTimestamp) ?? withoutTimestamp;
+  const decoded = decodeTaskLogLine(normalized);
+  if (!decoded.providerOutput) return '';
+  return prefixedJsonBody(decoded.content) ?? decoded.content;
 }
 
 function parseJsonRecordLine(line: string): JsonRecord | null {

package/src/agent-cli-provider/log-prefix.ts

@@ -1,13 +1,18 @@
+interface TaskLogDecoder {
+  decodeTaskLogLine(line: string): { readonly content: string; readonly providerOutput: boolean };
+}
+
+// The canonical decoder is maintained JavaScript and remains at the same source path after build.
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const taskLogDecoder: TaskLogDecoder = require('../../src/task-log-line');
+const { decodeTaskLogLine } = taskLogDecoder;
+
 export function stripTimestampPrefix(line: string): string {
-  let trimmed = line.trim().replace(/\r$/, '');
+  const decoded = decodeTaskLogLine(line.trim());
+  if (!decoded.providerOutput) return '';
+  let trimmed = decoded.content;
   if (!trimmed) return '';
 
-  const timestampMatch = /^\[(\d{13})\](.*)$/.exec(trimmed);
-  const timestampRemainder = timestampMatch?.[2];
-  if (typeof timestampRemainder === 'string') {
-    trimmed = timestampRemainder.trimStart();
-  }
-
   if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
     const pipeMatch = /^[^|]{1,40}\|\s*(.*)$/.exec(trimmed);
     const afterPipe = pipeMatch?.[1]?.trimStart();

package/src/claude-task-runner.js

@@ -11,6 +11,7 @@ const TaskRunner = require('./task-runner');
 const { loadSettings } = require('../lib/settings');
 const { normalizeProviderName, getDefaultProviderId } = require('../lib/provider-names');
 const { getProvider } = require('./providers');
+const { decodeTaskLogLine } = require('./task-log-line');
 const { prependWorktreeToolBinToEnv } = require('./worktree-tooling-env');
 const { applyDarwinKeychainBoundaryToEnv } = require('./darwin-keychain-boundary');
 const { getTask, getTaskBySpawnOwnershipToken } = require('../task-lib/store.js');
@@ -556,18 +557,17 @@ class ClaudeTaskRunner extends TaskRunner {
       const broadcastLine = (line) => {
         if (!line.trim()) return;
 
-        let content = line;
-        const timestampMatch = line.match(/^\[(\d{13})\](.*)$/);
-        if (timestampMatch) {
-          content = timestampMatch[2];
-        }
+        const decoded = decodeTaskLogLine(line);
+        if (!decoded.providerOutput) return;
+        const content = decoded.content;
 
         // Skip non-JSON patterns
         if (
-          content.startsWith('===') ||
-          content.startsWith('Finished:') ||
-          content.startsWith('Exit code:') ||
-          (content.includes('"type":"system"') && content.includes('"subtype":"init"'))
+          decoded.channel !== 'provider_stdout' &&
+          (content.startsWith('===') ||
+            content.startsWith('Finished:') ||
+            content.startsWith('Exit code:') ||
+            (content.includes('"type":"system"') && content.includes('"subtype":"init"')))
         ) {
           return;
         }

package/src/legacy-lib/stream-json-parser.ts

@@ -16,9 +16,16 @@ interface ProviderFacade {
   listProviders(): string[];
 }
 
+interface TaskLogDecoder {
+  decodeTaskLogLine(line: string): { content: string; providerOutput: boolean };
+}
+
 // The runtime facade is maintained JavaScript; keep its original emitted require path.
 // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
 const { getProvider, listProviders }: ProviderFacade = require('../src/providers');
+// eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+const taskLogDecoder: TaskLogDecoder = require('../src/task-log-line');
+const { decodeTaskLogLine } = taskLogDecoder;
 
 function createProviderParsers(): ProviderParser[] {
   return listProviders().map((name) => getProvider(name));
@@ -26,11 +33,9 @@ function createProviderParsers(): ProviderParser[] {
 
 function stripTimestampPrefix(line: unknown): string {
   if (!line || typeof line !== 'string') return '';
-  let trimmed = line.trim().replace(/\r$/, '');
-  if (!trimmed) return '';
-
-  const tsMatch = /^\[(\d{13})\](.*)$/.exec(trimmed);
-  if (tsMatch) trimmed = (tsMatch[2] || '').trimStart();
+  const decoded = decodeTaskLogLine(line.trim());
+  if (!decoded.providerOutput) return '';
+  const trimmed = decoded.content;
 
   if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
     const pipeMatch = /^[^|]{1,40}\|\s*(.*)$/.exec(trimmed);

package/src/providers/index.js

@@ -6,6 +6,7 @@ const {
 } = require('../../lib/provider-names');
 const { commandExists, getCommandPath } = require('../../lib/provider-detection');
 const helper = require('../../lib/agent-cli-provider');
+const { stripTimestampPrefix } = require('../../lib/agent-cli-provider/log-prefix');
 
 const warned = new Set();
 
@@ -218,25 +219,6 @@ function listProviders() {
   return helper.listProviderAdapters();
 }
 
-function stripTimestampPrefix(line) {
-  if (!line || typeof line !== 'string') return '';
-  let trimmed = line.trim().replace(/\r$/, '');
-  if (!trimmed) return '';
-
-  const tsMatch = trimmed.match(/^\[(\d{13})\](.*)$/);
-  if (tsMatch) trimmed = (tsMatch[2] || '').trimStart();
-
-  if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
-    const pipeMatch = trimmed.match(/^[^|]{1,40}\|\s*(.*)$/);
-    if (pipeMatch) {
-      const afterPipe = (pipeMatch[1] || '').trimStart();
-      if (afterPipe.startsWith('{') || afterPipe.startsWith('[')) return afterPipe;
-    }
-  }
-
-  return trimmed;
-}
-
 function collectEvents(events, event) {
   if (!event) return;
   if (Array.isArray(event)) {

package/src/task-log-line.d.ts

@@ -0,0 +1,20 @@
+export const TASK_LOG_V2_MARKER: '[ZEROSHOT][LOG_FORMAT] channel-framed-v2';
+export const TASK_LOG_STDOUT_PREFIX: '[ZEROSHOT][PROVIDER_STDOUT] ';
+export const TASK_LOG_STDERR_PREFIX: '[ZEROSHOT][PROVIDER_STDERR] ';
+
+export type TaskLogChannel = 'provider_stdout' | 'provider_stderr' | 'control' | 'legacy';
+export type TaskLogFormat = 'stderr-tagged-v1' | 'channel-framed-v2' | null;
+
+export interface DecodedTaskLogLine {
+  readonly channel: TaskLogChannel;
+  readonly content: string;
+  readonly format: TaskLogFormat;
+  readonly providerOutput: boolean;
+  readonly timestamp: number | null;
+  readonly timestamped: boolean;
+}
+
+export function decodeTaskLogLine(line: string): DecodedTaskLogLine;
+export function formatTaskLogMarker(timestamp: number): string;
+export function formatTaskLogStderr(timestamp: number, content: string): string;
+export function formatTaskLogStdout(timestamp: number, content: string): string;

package/src/task-log-line.js

@@ -0,0 +1,80 @@
+'use strict';
+
+const TASK_LOG_V2_MARKER = '[ZEROSHOT][LOG_FORMAT] channel-framed-v2';
+const TASK_LOG_STDOUT_PREFIX = '[ZEROSHOT][PROVIDER_STDOUT] ';
+const TASK_LOG_STDERR_PREFIX = '[ZEROSHOT][PROVIDER_STDERR] ';
+const TASK_LOG_V1_MARKER = '[ZEROSHOT][LOG_FORMAT] stderr-tagged-v1';
+const CONTROL_LINE =
+  /^\[(?:ATTACH|CLEANUP|CRASH|DETACH|ERROR|OMP-OWNERSHIP|SDK-DIAGNOSTIC|SYSTEM)\](?:\s|$)/;
+
+function timestampParts(line) {
+  const normalized = line.replace(/\r$/, '');
+  const match = /^\[(\d{13}|\d{4}-\d{2}-\d{2}T[^\]]+)\](.*)$/.exec(normalized);
+  if (!match) return { content: normalized, timestamp: null };
+  const rawTimestamp = match[1];
+  const epochTimestamp = /^\d{13}$/.test(rawTimestamp);
+  const timestamp = epochTimestamp
+    ? Number.parseInt(rawTimestamp, 10)
+    : new Date(rawTimestamp).getTime();
+  return {
+    content: match[2].trimStart(),
+    timestamp: Number.isFinite(timestamp) ? timestamp : null,
+  };
+}
+
+function decodeTaskLogLine(line) {
+  const { content, timestamp } = timestampParts(line);
+  const common = { timestamp, timestamped: timestamp !== null };
+  if (content.startsWith(TASK_LOG_STDOUT_PREFIX)) {
+    return {
+      ...common,
+      channel: 'provider_stdout',
+      content: content.slice(TASK_LOG_STDOUT_PREFIX.length),
+      format: null,
+      providerOutput: true,
+    };
+  }
+  if (content.startsWith(TASK_LOG_STDERR_PREFIX)) {
+    return {
+      ...common,
+      channel: 'provider_stderr',
+      content: content.slice(TASK_LOG_STDERR_PREFIX.length),
+      format: null,
+      providerOutput: false,
+    };
+  }
+  let format = null;
+  if (content === TASK_LOG_V2_MARKER) format = 'channel-framed-v2';
+  else if (content === TASK_LOG_V1_MARKER) format = 'stderr-tagged-v1';
+  const control =
+    format !== null || content.startsWith('[ZEROSHOT][FATAL] ') || CONTROL_LINE.test(content);
+  return {
+    ...common,
+    channel: control ? 'control' : 'legacy',
+    content,
+    format,
+    providerOutput: !control,
+  };
+}
+
+function formatTaskLogMarker(timestamp) {
+  return `[${timestamp}]${TASK_LOG_V2_MARKER}\n`;
+}
+
+function formatTaskLogStdout(timestamp, content) {
+  return `[${timestamp}]${TASK_LOG_STDOUT_PREFIX}${content}\n`;
+}
+
+function formatTaskLogStderr(timestamp, content) {
+  return `[${timestamp}]${TASK_LOG_STDERR_PREFIX}${content}\n`;
+}
+
+module.exports = {
+  TASK_LOG_STDERR_PREFIX,
+  TASK_LOG_STDOUT_PREFIX,
+  TASK_LOG_V2_MARKER,
+  decodeTaskLogLine,
+  formatTaskLogMarker,
+  formatTaskLogStderr,
+  formatTaskLogStdout,
+};

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/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),