@the-open-engine/zeroshot 6.34.1 → 6.34.3

package/cli/index.js

@@ -3295,22 +3295,19 @@ program
         throw new Error(`Cluster ${clusterId} not found (no DB file)`);
       }
 
-      const ledger = new Ledger(dbPath);
-      const messages = ledger.getAll(clusterId);
-      ledger.close();
-
       // JSON export
       if (options.format === 'json') {
-        const data = JSON.stringify({ cluster_id: clusterId, messages }, null, 2);
+        exportClusterJson(dbPath, clusterId, options.output || null);
         if (options.output) {
-          require('fs').writeFileSync(options.output, data, 'utf8');
           console.log(`Exported to ${options.output}`);
-        } else {
-          console.log(data);
         }
         return;
       }
 
+      const ledger = new Ledger(dbPath);
+      const messages = ledger.getAll(clusterId);
+      ledger.close();
+
       // Terminal-style export (for markdown and pdf)
       const terminalOutput = renderMessagesToTerminal(clusterId, messages);
 
@@ -6067,6 +6064,35 @@ async function handleNoArgumentInvocation({
   return true;
 }
 
+function tryExportClusterJsonSnapshot(dbPath, clusterId, outputPath) {
+  const Ledger = require('../src/ledger');
+  const { streamClusterJsonExport } = require('./json-export');
+  const ledger = new Ledger(dbPath, { readonly: true });
+  try {
+    return ledger.withReadSnapshot(() => {
+      if (ledger.needsAgentOutputReconciliation(clusterId)) return false;
+      streamClusterJsonExport({ ledger, clusterId, outputPath });
+      return true;
+    });
+  } finally {
+    ledger.close();
+  }
+}
+
+function exportClusterJson(dbPath, clusterId, outputPath) {
+  const Ledger = require('../src/ledger');
+  const maxReconciliationAttempts = 3;
+  for (let attempt = 0; attempt <= maxReconciliationAttempts; attempt += 1) {
+    if (tryExportClusterJsonSnapshot(dbPath, clusterId, outputPath)) return;
+    if (attempt === maxReconciliationAttempts) break;
+    const reconciliationLedger = new Ledger(dbPath);
+    reconciliationLedger.close();
+  }
+  throw new Error(
+    `Cluster ${clusterId} output changed during ${maxReconciliationAttempts} reconciliation attempts`
+  );
+}
+
 // Main entry point
 async function main() {
   printLegacyDistroNotice();

package/cli/json-export.js

@@ -0,0 +1,77 @@
+const fs = require('fs');
+
+function indentJson(value, spaces) {
+  const prefix = ' '.repeat(spaces);
+  return JSON.stringify(value, null, 2)
+    .split('\n')
+    .map((line) => `${prefix}${line}`)
+    .join('\n');
+}
+
+function writeAll(fd, value) {
+  const bytes = Buffer.from(value);
+  let offset = 0;
+  while (offset < bytes.length) {
+    const written = fs.writeSync(fd, bytes, offset, bytes.length - offset);
+    if (!Number.isInteger(written) || written <= 0) {
+      throw new Error('JSON export destination stopped accepting bytes');
+    }
+    offset += written;
+  }
+}
+
+function createDestination(outputPath, stdout) {
+  if (outputPath) {
+    const fd = fs.openSync(outputPath, 'w');
+    return {
+      close: () => fs.closeSync(fd),
+      write: (value) => writeAll(fd, value),
+    };
+  }
+
+  if (Number.isInteger(stdout.fd)) {
+    return {
+      close() {},
+      write: (value) => writeAll(stdout.fd, value),
+    };
+  }
+
+  return {
+    close() {},
+    write: (value) => stdout.write(value),
+  };
+}
+
+function streamClusterJsonExport({
+  ledger,
+  clusterId,
+  outputPath = null,
+  stdout = process.stdout,
+}) {
+  const destination = createDestination(outputPath, stdout);
+  const iterator = ledger.iterateAll(clusterId);
+  try {
+    destination.write(`{\n  "cluster_id": ${JSON.stringify(clusterId)},\n  "messages": `);
+    let current = iterator.next();
+    if (current.done) {
+      destination.write('[]\n}\n');
+      return;
+    }
+
+    destination.write('[\n');
+    while (!current.done) {
+      destination.write(indentJson(current.value, 4));
+      current = iterator.next();
+      destination.write(current.done ? '\n' : ',\n');
+    }
+    destination.write('  ]\n}\n');
+  } finally {
+    try {
+      if (typeof iterator.return === 'function') iterator.return();
+    } finally {
+      destination.close();
+    }
+  }
+}
+
+module.exports = { streamClusterJsonExport };

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.34.1",
+  "version": "6.34.3",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@the-open-engine/zeroshot",
-      "version": "6.34.1",
+      "version": "6.34.3",
       "hasInstallScript": true,
       "license": "MIT",
       "dependencies": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@the-open-engine/zeroshot",
-  "version": "6.34.1",
+  "version": "6.34.3",
   "description": "Independent executor–verifier orchestration for software changes.",
   "main": "src/orchestrator.js",
   "bin": {

package/src/agent/agent-lifecycle.js

@@ -24,6 +24,7 @@ const { findPlatformMismatchReason } = require('./validation-platform');
 const { calculateRateLimitDelay, isRateLimitError } = require('./rate-limit-backoff');
 const { updateAgentProviderSession } = require('./provider-session');
 const { rebuildProviderSessionAfterCommit } = require('./agent-task-executor');
+const providerFailures = require('./provider-terminal-failure');
 const {
   buildStructuredOutputClusterFailure,
   isStructuredOutputInvalidError,
@@ -660,6 +661,7 @@ async function runTaskAttempt(agent, triggeringMessage) {
     error.code = result.code || result.errorType || null;
     error.taskId = result.taskId || null;
     error.vertexModelError = result.vertexModelError || null;
+    providerFailures.decorateError(error, result.providerFailure);
     throw error;
   }
 
@@ -795,6 +797,16 @@ ${'='.repeat(80)}`);
 
   // Non-validator agents: publish error and stop
   agent.state = 'error';
+  const workerFailure = providerFailures.workerFailure(error);
+  // Synchronous terminal listeners must see the final failure truth before persisting a stop.
+  agent.cluster.failureInfo = providerFailures.buildFinalFailureInfo({
+    agent,
+    error,
+    attempts: failureAttempts,
+    worker: workerFailure,
+    unsupportedCapability,
+    structuredOutputInvalid,
+  });
 
   // Hook failure: fail the whole cluster so it gets stopped + persisted (prevents deadlocked "running" clusters).
   if (error?.hookFailure) {
@@ -872,25 +884,14 @@ ${'='.repeat(80)}`);
     });
   }
 
-  // Save failure info to cluster for resume capability
-  agent.cluster.failureInfo = {
-    ...(error?.terminationExhausted ? agent.cluster.failureInfo : {}),
-    agentId: agent.id,
-    taskId: error?.taskId || agent.currentTaskId,
-    iteration: agent.iteration,
-    error: error.message,
+  providerFailures.publishCriticalFailure({
+    agent,
+    error,
     attempts: failureAttempts,
-    ...(unsupportedCapability
-      ? {
-          code: error.code,
-          permanent: true,
-          provider: error.provider,
-          capability: error.capability,
-        }
-      : {}),
-    ...(structuredOutputInvalid ? { code: error.code, details: error.details ?? null } : {}),
-    timestamp: Date.now(),
-  };
+    worker: workerFailure,
+    unsupportedCapability,
+    structuredOutputInvalid,
+  });
 
   // Publish error to message bus for visibility in logs
   agent._publish({
@@ -900,7 +901,7 @@ ${'='.repeat(80)}`);
       text: `Task execution failed after ${failureAttempts} attempts: ${error.message}`,
       data: {
         error: error.message,
-        stack: error.stack,
+        stack: error?.provider ? undefined : error.stack,
         hookFailure: error?.hookFailure === true,
         restartExhausted: error?.restartExhausted === true,
         terminationExhausted: error?.terminationExhausted === true,
@@ -911,6 +912,10 @@ ${'='.repeat(80)}`);
         iteration: agent.iteration,
         taskId: error?.taskId || agent.currentTaskId,
         attempts: failureAttempts,
+        ...providerFailures.receiptFields(error),
+        ...(error?.provider
+          ? { workerCode: workerFailure.code, workerReason: workerFailure.reason }
+          : {}),
         ...(unsupportedCapability
           ? {
               code: error.code,