@the-open-engine/zeroshot 6.39.2 → 6.41.0

package/scripts/node-release-commits.js

@@ -0,0 +1,82 @@
+'use strict';
+
+const childProcess = require('node:child_process');
+const fs = require('node:fs');
+const { classifyPaths } = require('../.github/ci-path-classifier');
+
+const COMMIT_HASH = /^[0-9a-f]{7,64}$/i;
+const RELEASE_NEUTRAL_PATHS = new Set(['.dockerignore', 'AGENTS.md', 'README.md']);
+const RELEASE_NEUTRAL_PREFIXES = ['.github/'];
+
+function isReleaseNeutralPath(pathname) {
+  if (RELEASE_NEUTRAL_PATHS.has(pathname)) return true;
+  for (const prefix of RELEASE_NEUTRAL_PREFIXES) {
+    if (pathname.startsWith(prefix)) return true;
+  }
+  return false;
+}
+
+function hasNodeReleasePath(paths) {
+  const productPaths = paths.filter((pathname) => !isReleaseNeutralPath(pathname));
+  return productPaths.length > 0 && classifyPaths(productPaths).node;
+}
+
+function changedPathsForCommit(hash, options = {}) {
+  if (!COMMIT_HASH.test(String(hash))) {
+    throw new Error(`invalid commit hash for Node release classification: ${hash}`);
+  }
+  const runGit = options.runGit || childProcess.execFileSync;
+  const output = runGit(
+    'git',
+    ['diff-tree', '--root', '--no-commit-id', '--name-only', '-r', '-z', hash],
+    { cwd: options.cwd || process.cwd(), encoding: 'utf8' }
+  );
+  return String(output).split('\0').filter(Boolean);
+}
+
+function filterNodeCommits(commits, options = {}) {
+  const pathsForCommit = options.pathsForCommit || ((hash) => changedPathsForCommit(hash, options));
+  return commits.filter((commit) => {
+    // Missing identity cannot be classified safely, so retain the commit.
+    if (!commit.hash) return true;
+    const nodeRelevant = hasNodeReleasePath(pathsForCommit(commit.hash));
+    if (!nodeRelevant && options.logger) {
+      options.logger.log('Ignoring non-Node commit in Node release: %s', commit.hash);
+    }
+    return nodeRelevant;
+  });
+}
+
+function hasNodeReleaseCommit(commits, options = {}) {
+  return filterNodeCommits(commits, options).length > 0;
+}
+
+function nodeReleaseContext(context, options = {}) {
+  return {
+    ...context,
+    commits: filterNodeCommits(context.commits || [], {
+      cwd: context.cwd,
+      logger: context.logger,
+      pathsForCommit: options.pathsForCommit,
+    }),
+  };
+}
+
+function commitHashesFromStdin() {
+  return fs.readFileSync(0, 'utf8').split(/\s+/).filter(Boolean);
+}
+
+function main() {
+  const commits = commitHashesFromStdin().map((hash) => ({ hash }));
+  process.stdout.write(`node=${hasNodeReleaseCommit(commits)}\n`);
+}
+
+module.exports = {
+  changedPathsForCommit,
+  filterNodeCommits,
+  hasNodeReleaseCommit,
+  hasNodeReleasePath,
+  nodeReleaseContext,
+};
+
+if (require.main === module) main();

package/scripts/release-dry-run.js

@@ -23,7 +23,7 @@ function pluginName(plugin) {
 
 function validationPlugins(releaseConfig) {
   const allowed = new Set([
-    '@semantic-release/commit-analyzer',
+    './scripts/node-release-analyzer.js',
     './scripts/semantic-release-notes.js',
   ]);
   return releaseConfig.plugins.filter((plugin) => allowed.has(pluginName(plugin)));

package/scripts/release-preflight.js

@@ -7,7 +7,7 @@ const { REQUIRED_OMP_SDK_SOURCES, validateOmpSdkReleaseAssets } = require('./omp
 
 const RELEASE_ORDER = ['patch', 'minor', 'major'];
 const REQUIRED_PLUGINS = [
-  '@semantic-release/commit-analyzer',
+  './scripts/node-release-analyzer.js',
   './scripts/semantic-release-notes.js',
   '@semantic-release/npm',
   '@semantic-release/github',
@@ -110,12 +110,12 @@ function validateReleaseConfig(packageJson) {
   }
 
   const analyzerPlugin = releaseConfig.plugins.find(
-    (plugin) => normalizePlugin(plugin) === '@semantic-release/commit-analyzer'
+    (plugin) => normalizePlugin(plugin) === './scripts/node-release-analyzer.js'
   );
   const analyzerOptions = Array.isArray(analyzerPlugin) ? analyzerPlugin[1] || {} : {};
   if (Array.isArray(analyzerOptions.releaseRules) && analyzerOptions.releaseRules.length > 0) {
     throw new Error(
-      '@semantic-release/commit-analyzer must use the standard conventional release rules'
+      './scripts/node-release-analyzer.js must use the standard conventional release rules'
     );
   }
 

package/scripts/semantic-release-notes.js

@@ -1,5 +1,6 @@
 const fs = require('fs');
 const path = require('path');
+const { nodeReleaseContext } = require('./node-release-commits');
 
 function curatedNotesPath(cwd, version) {
   return path.join(cwd, 'docs', 'releases', `v${version}.md`);
@@ -21,13 +22,18 @@ async function conventionalNotes(pluginConfig, context) {
   return generator.generateNotes(pluginConfig.conventional || {}, context);
 }
 
-async function generateNotesWithFallback(pluginConfig, context, fallback = conventionalNotes) {
+async function generateNotesWithFallback(
+  pluginConfig,
+  context,
+  fallback = conventionalNotes,
+  options = {}
+) {
   const version = context.nextRelease?.version;
   if (!version) throw new Error('nextRelease.version is required to generate release notes');
 
   const curated = readCuratedNotes(context.cwd || process.cwd(), version);
   if (curated) return curated;
-  const generated = await fallback(pluginConfig, context);
+  const generated = await fallback(pluginConfig, nodeReleaseContext(context, options));
   return generated;
 }
 

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/cluster/connection-types.ts

@@ -1,12 +1,12 @@
 import type { FrameRecord } from './frames.js';
 import type { BoundedQueue } from './queue.js';
-import type { ClusterMethod } from './generated/protocol.js';
+import type { ClusterMethod, SubscriptionMethod } from './generated/protocol.js';
 
 export interface CallOptions {
   readonly signal?: AbortSignal;
   readonly requestTimeoutMs?: number;
 }
-export type SubscriptionKind = 'watch' | 'logs' | 'agent/attach';
+export type SubscriptionKind = SubscriptionMethod;
 export type SubscriptionRegistration = {
   readonly id: string;
   readonly kind: SubscriptionKind;