agentxchain 2.155.38 → 2.155.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.155.38",
+  "version": "2.155.39",
   "description": "CLI for AgentXchain — governed multi-agent software delivery",
   "type": "module",
   "bin": {

package/src/commands/run.js

@@ -673,26 +673,52 @@ export async function executeGovernedRun(context, opts = {}) {
         const reportsDir = join(root, '.agentxchain', 'reports');
         mkdirSync(reportsDir, { recursive: true });
 
-        const exportResult = buildRunExport(root, { maxJsonlEntries: 1000, maxBase64Bytes: 1024 * 1024 });
+        // BUG-88: two-attempt export with fallback to tighter bounds on string-length overflow
+        const defaultExportOpts = { maxJsonlEntries: 1000, maxBase64Bytes: 1024 * 1024, maxExportFiles: 500, maxTextDataBytes: 131072 };
+        const tightExportOpts = { maxJsonlEntries: 500, maxBase64Bytes: 65536, maxExportFiles: 200, maxTextDataBytes: 32768 };
+
+        let exportResult = buildRunExport(root, defaultExportOpts);
         if (exportResult.ok) {
           const runId = result.state.run_id || 'unknown';
           const exportPath = join(reportsDir, `export-${runId}.json`);
+          let exportWriteOk = false;
+          let usedExport = exportResult.export;
 
-          // Write export JSON — compact format to avoid string-length overflow (BUG-84)
+          // Write export JSON — compact format to avoid string-length overflow (BUG-84/88)
           try {
             writeFileSync(exportPath, JSON.stringify(exportResult.export));
+            exportWriteOk = true;
           } catch (exportWriteErr) {
-            log(chalk.dim(`  Governance export write failed: ${exportWriteErr.message}`));
+            // BUG-88: retry with tighter bounds on Invalid string length
+            if (/Invalid string length/i.test(exportWriteErr.message)) {
+              log(chalk.dim(`  Export write exceeded string limit; retrying with tighter bounds...`));
+              const tightResult = buildRunExport(root, tightExportOpts);
+              if (tightResult.ok) {
+                try {
+                  writeFileSync(exportPath, JSON.stringify(tightResult.export));
+                  exportWriteOk = true;
+                  usedExport = tightResult.export;
+                } catch (retryErr) {
+                  log(chalk.dim(`  Governance export write failed (tight bounds): ${retryErr.message}`));
+                }
+              }
+            } else {
+              log(chalk.dim(`  Governance export write failed: ${exportWriteErr.message}`));
+            }
           }
 
-          // Generate markdown report separately so export-write failure doesn't block it
+          // Generate markdown report from whichever export succeeded
           try {
-            const reportResult = buildGovernanceReport(exportResult.export, { input: exportPath });
+            const reportInput = exportWriteOk ? exportPath : '(in-memory)';
+            const reportResult = buildGovernanceReport(usedExport, { input: reportInput });
             const reportPath = join(reportsDir, `report-${runId}.md`);
             writeFileSync(reportPath, formatGovernanceReportMarkdown(reportResult.report));
 
             log('');
             log(chalk.dim(`  Governance report: .agentxchain/reports/report-${runId}.md`));
+            if (!exportWriteOk) {
+              log(chalk.dim(`  Note: report generated from in-memory bounded export (disk write failed).`));
+            }
           } catch (reportErr) {
             log(chalk.dim(`  Governance report failed: ${reportErr.message}`));
           }

package/src/lib/export-verifier.js

@@ -106,27 +106,35 @@ function verifyFileEntry(relPath, entry, errors) {
       return;
     }
     if (isTruncated) {
-      if (entry.format !== 'jsonl') {
-        addError(errors, path, 'truncated file entries must use jsonl format');
-      }
-      if (!Array.isArray(entry.data)) {
-        addError(errors, path, 'truncated JSONL data must be an array');
-      }
-      if (!Number.isInteger(entry.total_entries) || entry.total_entries < 0) {
-        addError(errors, path, 'total_entries must be a non-negative integer when truncated');
-      }
-      if (!Number.isInteger(entry.retained_entries) || entry.retained_entries < 0) {
-        addError(errors, path, 'retained_entries must be a non-negative integer when truncated');
-      }
-      if (Array.isArray(entry.data) && entry.retained_entries !== entry.data.length) {
-        addError(errors, path, 'retained_entries must match truncated data length');
-      }
-      if (
-        Number.isInteger(entry.total_entries)
-        && Number.isInteger(entry.retained_entries)
-        && entry.retained_entries > entry.total_entries
-      ) {
-        addError(errors, path, 'retained_entries must not exceed total_entries');
+      // BUG-88: truncated entries may be JSONL (windowed) or text (size-capped)
+      if (entry.format === 'jsonl') {
+        if (!Array.isArray(entry.data)) {
+          addError(errors, path, 'truncated JSONL data must be an array');
+        }
+        if (!Number.isInteger(entry.total_entries) || entry.total_entries < 0) {
+          addError(errors, path, 'total_entries must be a non-negative integer when truncated');
+        }
+        if (!Number.isInteger(entry.retained_entries) || entry.retained_entries < 0) {
+          addError(errors, path, 'retained_entries must be a non-negative integer when truncated');
+        }
+        if (Array.isArray(entry.data) && entry.retained_entries !== entry.data.length) {
+          addError(errors, path, 'retained_entries must match truncated data length');
+        }
+        if (
+          Number.isInteger(entry.total_entries)
+          && Number.isInteger(entry.retained_entries)
+          && entry.retained_entries > entry.total_entries
+        ) {
+          addError(errors, path, 'retained_entries must not exceed total_entries');
+        }
+      } else if (entry.format === 'text') {
+        if (typeof entry.data !== 'string') {
+          addError(errors, path, 'truncated text data must be a string');
+        }
+      } else if (entry.format === 'json') {
+        // Truncated JSON: data may be partial or null
+      } else {
+        addError(errors, path, `truncated file entries must use jsonl, text, or json format, got: ${entry.format}`);
       }
       return;
     }

package/src/lib/export.js

@@ -182,6 +182,10 @@ function parseFile(root, relPath, opts = {}) {
     totalEntries = parsed.totalEntries;
   } else {
     data = buffer.toString('utf8');
+    if (opts.maxTextDataBytes && typeof data === 'string' && data.length > opts.maxTextDataBytes) {
+      data = data.slice(0, opts.maxTextDataBytes);
+      truncated = true;
+    }
   }
 
   const skipBase64 = truncated || (opts.maxBase64Bytes && buffer.byteLength > opts.maxBase64Bytes);
@@ -464,9 +468,42 @@ export function buildRunExport(startDir = process.cwd(), exportOpts = {}) {
   if (exportOpts.maxBase64Bytes) {
     parseOpts.maxBase64Bytes = exportOpts.maxBase64Bytes;
   }
+  if (exportOpts.maxTextDataBytes) {
+    parseOpts.maxTextDataBytes = exportOpts.maxTextDataBytes;
+  }
+
+  // BUG-88: apply maxExportFiles cap with priority ordering.
+  // Core governance files first, then dispatch/staging, then .planning/ last.
+  let boundedPaths = collectedPaths;
+  let exportFilesTruncated = false;
+  if (exportOpts.maxExportFiles && collectedPaths.length > exportOpts.maxExportFiles) {
+    const corePaths = [];
+    const runtimePaths = [];
+    const planningPaths = [];
+    for (const p of collectedPaths) {
+      if (p.startsWith('.planning/')) {
+        planningPaths.push(p);
+      } else if (p.startsWith('.agentxchain/dispatch/') || p.startsWith('.agentxchain/staging/') || p.startsWith('.agentxchain/transactions/')) {
+        runtimePaths.push(p);
+      } else {
+        corePaths.push(p);
+      }
+    }
+    const budget = exportOpts.maxExportFiles;
+    boundedPaths = corePaths.slice(0, budget);
+    const remaining = budget - boundedPaths.length;
+    if (remaining > 0) {
+      boundedPaths.push(...runtimePaths.slice(0, remaining));
+      const remaining2 = remaining - Math.min(runtimePaths.length, remaining);
+      if (remaining2 > 0) {
+        boundedPaths.push(...planningPaths.slice(0, remaining2));
+      }
+    }
+    exportFilesTruncated = true;
+  }
 
   const files = {};
-  for (const relPath of collectedPaths) {
+  for (const relPath of boundedPaths) {
     files[relPath] = parseFile(root, relPath, parseOpts);
   }
 
@@ -511,6 +548,9 @@ export function buildRunExport(startDir = process.cwd(), exportOpts = {}) {
         dashboard_session: buildDashboardSessionSummary(root),
         delegation_summary: buildDelegationSummary(files),
         repo_decisions: buildRepoDecisionsSummary(root, rawConfig),
+        export_files_truncated: exportFilesTruncated || false,
+        total_collected_files: collectedPaths.length,
+        included_files: Object.keys(files).length,
       },
       workspace: buildRunWorkspaceMetadata(root),
       files,