agentxchain 2.155.37 → 2.155.39

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.155.37",
+  "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/dispatch-bundle.js

@@ -499,6 +499,7 @@ function renderPrompt(role, roleId, turn, state, config, root) {
   lines.push('- `verification.status`: one of `pass`, `fail`, `skipped`');
   lines.push('- `verification.status: "pass"` is valid only when every `verification.machine_evidence[].exit_code` is `0`');
   lines.push('- Expected-failure checks must be wrapped in a verifier that exits `0` when the failure occurs as expected; do not list raw non-zero negative-case commands on a passing turn');
+  lines.push('- If verification commands produce side-effect files (e.g., `.tusq/plan.json`, `coverage/`, `.cache/`), declare each in `verification.produced_files` with `disposition: "ignore"` (temporary output to clean up) or `disposition: "artifact"` (output to checkpoint as a turn deliverable). Undeclared dirty files with declared verification will be auto-cleaned but declaring them is preferred.');
   lines.push('- `artifact.type`: one of `workspace`, `patch`, `commit`, `review`');
   lines.push('- If you make zero repo file edits, set `artifact.type` to `"review"` and `files_changed` to `[]`.');
   lines.push('- Only set `artifact.type` to `"workspace"` when you actually modified repo files and listed every changed path in `files_changed`.');

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,

package/src/lib/governed-state.js

@@ -4531,39 +4531,97 @@ function _acceptGovernedTurnLocked(root, config, opts) {
       && verification.machine_evidence.some((e) => e && typeof e === 'object' && typeof e.command === 'string' && e.command.trim().length > 0);
     const verificationWasDeclared = declaredVerificationCommands || declaredMachineEvidence;
 
-    let failureReason = dirtyParity.reason;
-    let failureErrorCode = 'artifact_dirty_tree_mismatch';
-    if (verificationWasDeclared) {
-      failureErrorCode = 'undeclared_verification_outputs';
-      const undeclared = Array.isArray(dirtyParity.unexpected_dirty_files)
-        ? dirtyParity.unexpected_dirty_files
-        : [];
-      const listForMessage = undeclared.slice(0, 5).join(', ')
-        + (undeclared.length > 5 ? '...' : '');
-      failureReason = `Verification was declared (commands or machine_evidence), but these files are dirty and not classified: ${listForMessage}. Classify each under verification.produced_files with disposition "ignore" (the file should be cleaned up after replay) or "artifact" (the file should be checkpointed as part of the turn), OR add it to files_changed if it is a core turn mutation. Acceptance cannot proceed until the declared contract matches the working tree.`;
+    // ── BUG-87: Auto-normalize undeclared verification outputs ──────────
+    // When verification was declared and unexpected dirty files exist,
+    // attempt to clean them up as ignored verification outputs before
+    // hard-erroring. This covers tool-generated side-effect files (e.g.,
+    // .tusq/plan.json, coverage/) that the agent failed to declare in
+    // verification.produced_files. cleanupIgnoredVerificationFiles already
+    // respects the dispatch baseline: only files NOT dirty at dispatch
+    // time are cleaned; pre-existing dirty files are left untouched.
+    if (verificationWasDeclared && Array.isArray(dirtyParity.unexpected_dirty_files) && dirtyParity.unexpected_dirty_files.length > 0) {
+      const autoClassifyAttempt = cleanupIgnoredVerificationFiles({
+        root,
+        baseline,
+        ignoredFiles: dirtyParity.unexpected_dirty_files,
+      });
+      if (autoClassifyAttempt.ok) {
+        // Re-check dirty parity after cleanup
+        const recheckParity = detectDirtyFilesOutsideAllowed(
+          root,
+          writeAuthority,
+          [
+            ...(turnResult.files_changed || []),
+            ...concurrentAllowedDirtyFiles,
+            ...uncheckpointedPriorFiles,
+          ],
+        );
+        if (recheckParity.clean) {
+          const autoClassifiedFiles = dirtyParity.unexpected_dirty_files;
+          // Auto-normalization succeeded — emit audit event and continue
+          emitRunEvent(root, 'verification_output_auto_normalized', {
+            run_id: state.run_id,
+            phase: state.phase,
+            status: state.status,
+            turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+            intent_id: currentTurn.intake_context?.intent_id || null,
+            payload: {
+              auto_classified_files: autoClassifiedFiles,
+              restored_files: autoClassifyAttempt.restored_files || [],
+              disposition: 'ignore',
+              rationale: 'undeclared_verification_output_auto_normalized',
+            },
+          });
+          // Remove auto-classified files from the observation so
+          // compareDeclaredVsObserved does not re-flag them as undeclared.
+          const autoSet = new Set(autoClassifiedFiles);
+          if (Array.isArray(observation.files_changed)) {
+            observation.files_changed = observation.files_changed.filter(
+              (f) => !autoSet.has(f),
+            );
+          }
+          // Fall through to the rest of acceptance (skip the error block)
+          dirtyParity.clean = true;
+        }
+      }
     }
+    // ── End BUG-87 ──────────────────────────────────────────────────────
+
+    if (!dirtyParity.clean) {
+      let failureReason = dirtyParity.reason;
+      let failureErrorCode = 'artifact_dirty_tree_mismatch';
+      if (verificationWasDeclared) {
+        failureErrorCode = 'undeclared_verification_outputs';
+        const undeclared = Array.isArray(dirtyParity.unexpected_dirty_files)
+          ? dirtyParity.unexpected_dirty_files
+          : [];
+        const listForMessage = undeclared.slice(0, 5).join(', ')
+          + (undeclared.length > 5 ? '...' : '');
+        failureReason = `Verification was declared (commands or machine_evidence), but these files are dirty and not classified: ${listForMessage}. Classify each under verification.produced_files with disposition "ignore" (the file should be cleaned up after replay) or "artifact" (the file should be checkpointed as part of the turn), OR add it to files_changed if it is a core turn mutation. Acceptance cannot proceed until the declared contract matches the working tree.`;
+      }
 
-    transitionToFailedAcceptance(root, state, currentTurn, failureReason, {
-      error_code: failureErrorCode,
-      stage: 'artifact_observation',
-      extra: {
-        unexpected_dirty_files: dirtyParity.unexpected_dirty_files,
-        dirty_files: dirtyParity.dirty_files,
-      },
-    });
-    return {
-      ok: false,
-      error: failureReason,
-      error_code: failureErrorCode,
-      validation: {
-        ...validation,
-        ok: false,
+      transitionToFailedAcceptance(root, state, currentTurn, failureReason, {
+        error_code: failureErrorCode,
         stage: 'artifact_observation',
-        error_class: 'artifact_error',
-        errors: [failureReason],
-        warnings: validation.warnings,
-      },
-    };
+        extra: {
+          unexpected_dirty_files: dirtyParity.unexpected_dirty_files,
+          dirty_files: dirtyParity.dirty_files,
+        },
+      });
+      return {
+        ok: false,
+        error: failureReason,
+        error_code: failureErrorCode,
+        validation: {
+          ...validation,
+          ok: false,
+          stage: 'artifact_observation',
+          error_class: 'artifact_error',
+          errors: [failureReason],
+          warnings: validation.warnings,
+        },
+      };
+    }
   }
 
   const diffComparison = compareDeclaredVsObserved(