agentxchain 2.156.0 → 2.157.0

package/package.json

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

package/src/lib/adapters/local-cli-adapter.js

@@ -44,6 +44,10 @@ import {
   parseRateLimitResetMs,
   resolveClaudeCompatibleNodeBinary,
 } from '../claude-local-auth.js';
+import {
+  createStreamJsonCostParser,
+  buildCostFromStreamJson,
+} from '../stream-json-cost-parser.js';
 
 const DIAGNOSTIC_ENV_KEYS = [
   'PATH',
@@ -147,6 +151,16 @@ export async function dispatchLocalCli(root, state, config, options = {}) {
     };
   }
 
+  // Create stream-json cost parser for Claude runtimes with stream-json output.
+  // Only Claude runtimes emit parseable NDJSON with result events; other runtimes
+  // (Codex, Cursor, Windsurf, OpenCode) have different stdout formats.
+  const tokens = [command, ...args].filter((t) => typeof t === 'string');
+  const usesStreamJson = tokens.includes('--output-format=stream-json')
+    || (tokens.includes('--output-format') && tokens[tokens.indexOf('--output-format') + 1] === 'stream-json');
+  const costParser = isClaudeLocalCliRuntime(runtime) && usesStreamJson
+    ? createStreamJsonCostParser()
+    : null;
+
   // Compute timeout from explicit dispatch deadline, turn deadline, or default (20 minutes).
   const timeoutMs = options.dispatchTimeoutMs != null
     ? options.dispatchTimeoutMs
@@ -425,6 +439,7 @@ export async function dispatchLocalCli(root, state, config, options = {}) {
         stdoutBytes += Buffer.byteLength(text);
         recordFirstOutput('stdout');
         logs.push(text);
+        if (costParser) costParser.push(text);
         if (onStdout) onStdout(text);
       });
     }
@@ -558,6 +573,28 @@ export async function dispatchLocalCli(root, state, config, options = {}) {
       appendDiagnostic(logs, 'process_exit', exitDiagnostic);
 
       if (hasResult) {
+        // Enrich cost from stream-json if available (best-effort, never blocks settle)
+        if (costParser) {
+          try {
+            const parsedCost = costParser.getResult();
+            if (parsedCost) {
+              const stagingPath = join(root, getTurnStagingResultPath(turn.turn_id));
+              const raw = readFileSync(stagingPath, 'utf8');
+              const turnResult = JSON.parse(raw);
+              turnResult.cost = buildCostFromStreamJson(parsedCost, config);
+              writeFileSync(stagingPath, JSON.stringify(turnResult, null, 2) + '\n');
+              appendDiagnostic(logs, 'stream_json_cost_enriched', {
+                input_tokens: parsedCost.input_tokens,
+                output_tokens: parsedCost.output_tokens,
+                cost_usd: parsedCost.cost_usd,
+                model: parsedCost.model,
+                computed_usd: turnResult.cost.usd,
+              });
+            }
+          } catch {
+            // Cost enrichment is best-effort — if it fails, agent-reported cost is preserved
+          }
+        }
         settle({ ok: true, exitCode, timedOut: false, aborted: false, logs, firstOutputAt });
       } else if (isClaudeLocalCliRuntime(runtime) && hasClaudeAuthFailureOutput(logs)) {
         const recovery = 'Refresh Claude credentials before resuming: export a valid ANTHROPIC_API_KEY or CLAUDE_CODE_OAUTH_TOKEN, then run agentxchain step --resume.';

package/src/lib/ci-reporter.js

@@ -1,5 +1,22 @@
 import { appendFileSync } from 'node:fs';
 
+/**
+ * Normalize gate_summary to [gateName, statusString] entries.
+ * Handles both array format ([{ gate_id, status }]) from the real report pipeline
+ * and object format ({ gateName: statusString }) from legacy/synthetic fixtures.
+ */
+function normalizeGateEntries(gates) {
+  if (Array.isArray(gates)) {
+    return gates
+      .filter(g => typeof g?.gate_id === 'string' && typeof g?.status === 'string')
+      .map(g => [g.gate_id, g.status]);
+  }
+  if (gates && typeof gates === 'object') {
+    return Object.entries(gates).filter(([, v]) => typeof v === 'string');
+  }
+  return [];
+}
+
 /**
  * Detect CI environment from process.env.
  * @returns {{ provider: string, run_url: string|null, run_id: string|null, ref: string|null, sha: string|null } | null}
@@ -55,16 +72,12 @@ export function formatGitHubAnnotations(report) {
   }
 
   // Gate annotations
-  const gates = report.subject?.run?.gate_summary;
-  if (gates && typeof gates === 'object') {
-    for (const [gateName, gateStatus] of Object.entries(gates)) {
-      if (typeof gateStatus !== 'string') continue;
-      const normalizedStatus = gateStatus.toLowerCase();
-      if (normalizedStatus === 'satisfied' || normalizedStatus === 'pass' || normalizedStatus === 'passed') {
-        lines.push(`::notice title=Gate ${gateName}::satisfied`);
-      } else {
-        lines.push(`::warning title=Gate ${gateName}::${gateStatus}`);
-      }
+  for (const [gateName, gateStatus] of normalizeGateEntries(report.subject?.run?.gate_summary)) {
+    const normalizedStatus = gateStatus.toLowerCase();
+    if (normalizedStatus === 'satisfied' || normalizedStatus === 'pass' || normalizedStatus === 'passed') {
+      lines.push(`::notice title=Gate ${gateName}::satisfied`);
+    } else {
+      lines.push(`::warning title=Gate ${gateName}::${gateStatus}`);
     }
   }
 
@@ -113,7 +126,6 @@ export function writeGitHubOutputVars(report, outputPath) {
  */
 export function formatJUnitXml(report) {
   const run = report.subject?.run || {};
-  const gates = run.gate_summary || {};
   const turns = run.turns || [];
 
   // Escape XML special characters
@@ -124,7 +136,7 @@ export function formatJUnitXml(report) {
     .replace(/"/g, '"');
 
   // Build gate test cases
-  const gateEntries = Object.entries(gates).filter(([, v]) => typeof v === 'string');
+  const gateEntries = normalizeGateEntries(run.gate_summary);
   const gateFailures = gateEntries.filter(([, status]) => {
     const s = status.toLowerCase();
     return s !== 'satisfied' && s !== 'pass' && s !== 'passed';

package/src/lib/continuous-run.js

@@ -1141,10 +1141,27 @@ export function maybeAutoReconcileOperatorCommits(context, session, contOpts, lo
   }
 
   const errorClass = result.error_class || 'reconcile_refused';
+  // RB-14: `reconcile-state --accept-operator-head` runs the SAME safety check, so it
+  // cannot clear an unsafe-edit refusal — recommending it for governance_state_modified
+  // or critical_artifact_deleted is a dead end. Give the recovery that actually applies.
+  const offendingCommit = result.offending_commit || result.commit || null;
+  const offendingPath = result.offending_path || result.path || null;
+  let recoveryAction;
+  let recoveryDetailTail;
+  if (errorClass === 'governance_state_modified') {
+    recoveryAction = offendingCommit ? `git revert ${offendingCommit.slice(0, 12)}` : 'git revert <offending-commit>';
+    recoveryDetailTail = `${offendingPath || 'A commit'} edits governed state under .agentxchain/ directly, which the anti-tamper guard never auto-accepts (reconcile-state --accept-operator-head enforces the same check). Revert it (${recoveryAction}) to restore the governed lineage, or restart from an explicit prior checkpoint.`;
+  } else if (errorClass === 'critical_artifact_deleted') {
+    recoveryAction = (offendingCommit && offendingPath) ? `git checkout ${offendingCommit.slice(0, 12)}^ -- ${offendingPath}` : 'git checkout <commit>^ -- <deleted-path>';
+    recoveryDetailTail = `Critical governed evidence ${offendingPath || ''} was deleted; restore it (${recoveryAction}), then resume.`;
+  } else {
+    recoveryAction = 'agentxchain reconcile-state --accept-operator-head';
+    recoveryDetailTail = `Run: ${recoveryAction} once the unsafe changes are resolved, or revert them.`;
+  }
   const detailLines = [
     `Operator-commit auto-reconcile refused (${errorClass}).`,
     result.error || 'Unsafe operator commits detected; manual recovery required.',
-    'Run: agentxchain reconcile-state --accept-operator-head once the unsafe changes are resolved, or revert them.',
+    recoveryDetailTail,
   ];
   const detail = detailLines.join(' ');
 
@@ -1164,7 +1181,7 @@ export function maybeAutoReconcileOperatorCommits(context, session, contOpts, lo
           ...((state.blocked_reason || {}).recovery || {}),
           typed_reason: 'operator_commit_reconcile_refused',
           owner: 'human',
-          recovery_action: 'agentxchain reconcile-state --accept-operator-head',
+          recovery_action: recoveryAction,
           turn_retained: false,
           detail,
         },
@@ -1196,7 +1213,7 @@ export function maybeAutoReconcileOperatorCommits(context, session, contOpts, lo
     status: 'blocked',
     action: 'operator_commit_reconcile_refused',
     run_id: session.current_run_id,
-    recovery_action: 'agentxchain reconcile-state --accept-operator-head',
+    recovery_action: recoveryAction,
     blocked_category: 'operator_commit_reconcile_refused',
     error_class: errorClass,
   };
@@ -2579,10 +2596,47 @@ export async function executeContinuousRun(context, contOpts, executeGovernedRun
   process.on('SIGINT', sigHandler);
 
   try {
+    // RB-13: circuit-breaker for the recover-and-continue path. A deterministic,
+    // recurring failure (e.g. an unclean baseline) must escalate, not busy-loop
+    // forever — without this, the same start error spun 582 times in seconds.
+    // Track consecutive identical recoveries; halt and escalate after a cap, and
+    // back off between attempts so even allowed retries can't tight-loop.
+    let consecutiveRecoveries = 0;
+    let lastRecoveryReason = null;
+    const maxConsecutiveRecoveries = Math.max(1, contOpts.maxConsecutiveRecoveries ?? 3);
+
     while (!stopping) {
       const step = await advanceContinuousRunOnce(context, session, contOpts, executeGovernedRun, log);
 
       if (step.status === 'failed' && isGovernedRunStillActiveForSession(root, context.config, session)) {
+        const recoveryReason = step.stop_reason || step.action || 'unknown';
+        if (recoveryReason === lastRecoveryReason) {
+          consecutiveRecoveries += 1;
+        } else {
+          consecutiveRecoveries = 1;
+          lastRecoveryReason = recoveryReason;
+        }
+
+        if (consecutiveRecoveries >= maxConsecutiveRecoveries) {
+          // Circuit open: the same recoverable failure keeps recurring without
+          // progress. Escalate to a human instead of spinning the loop.
+          session.status = 'blocked';
+          writeContinuousSession(root, session);
+          emitRunEvent(root, 'continuous_recovery_circuit_open', {
+            run_id: session.current_run_id || null,
+            phase: null,
+            status: 'blocked',
+            payload: {
+              session_id: session.session_id,
+              failed_action: step.action || null,
+              failed_reason: recoveryReason,
+              consecutive_recoveries: consecutiveRecoveries,
+            },
+          });
+          log(`Continuous loop halted (circuit-breaker): the same recoverable failure recurred ${consecutiveRecoveries} times with no progress — escalating to a human instead of spinning. Reason: ${recoveryReason}`);
+          return { exitCode: 1, session };
+        }
+
         session.status = 'running';
         writeContinuousSession(root, session);
         emitRunEvent(root, 'session_failed_recovered_active_run', {
@@ -2593,12 +2647,20 @@ export async function executeContinuousRun(context, contOpts, executeGovernedRun
             session_id: session.session_id,
             failed_action: step.action || null,
             failed_reason: step.stop_reason || null,
+            consecutive_recoveries: consecutiveRecoveries,
           },
         });
-        log('Session failure recovered - governed run still active, continuing.');
+        log(`Session failure recovered - governed run still active, continuing (recovery ${consecutiveRecoveries}/${maxConsecutiveRecoveries}).`);
+        // Backoff before retrying so a recurring failure cannot busy-loop.
+        const recoveryBackoffMs = Math.max(1000, (contOpts.cooldownSeconds ?? 5) * 1000);
+        await new Promise((resolve) => setTimeout(resolve, recoveryBackoffMs));
         continue;
       }
 
+      // A non-recovery step means the loop made forward progress — reset the breaker.
+      consecutiveRecoveries = 0;
+      lastRecoveryReason = null;
+
       // Terminal states
       if (step.status === 'completed' || step.status === 'idle_exit' || step.status === 'failed' || step.status === 'blocked' || step.status === 'stopped' || step.status === 'vision_exhausted' || step.status === 'vision_expansion_exhausted' || step.status === 'session_budget') {
         const terminalMessage = describeContinuousTerminalStep(step, contOpts);

package/src/lib/stream-json-cost-parser.js

@@ -0,0 +1,169 @@
+/**
+ * Stream-JSON cost parser — extracts usage/cost metadata from Claude Code's
+ * stream-json NDJSON stdout output.
+ *
+ * Claude Code with `--output-format stream-json --verbose` emits newline-
+ * delimited JSON events.  The final `result` event contains a `usage` object
+ * with `input_tokens`, `output_tokens`, and optionally cache token counts,
+ * plus a top-level `cost_usd` and `model` field.
+ *
+ * This parser accumulates stdout chunks, splits by newline, parses each
+ * complete line as JSON, and stores the last `result` event's cost data.
+ *
+ * Resilience guarantees:
+ *   - Partial JSON lines are buffered until the next newline arrives.
+ *   - Non-JSON lines are silently skipped (no throw, no error log).
+ *   - Multiple `result` events: last one wins.
+ *   - Missing `usage` in a `result` event: getResult() returns null.
+ */
+
+// Claude-specific bundled cost rates (USD per million tokens).
+// Duplicated from api-proxy-adapter.js for this module's use only — DEC-004
+// defers extraction to a shared module.
+const CLAUDE_COST_RATES = {
+  'claude-sonnet-4-6': { input_per_1m: 3.00, output_per_1m: 15.00 },
+  'claude-opus-4-6': { input_per_1m: 5.00, output_per_1m: 25.00 },
+  'claude-haiku-4-5-20251001': { input_per_1m: 1.00, output_per_1m: 5.00 },
+};
+
+/**
+ * Resolve cost rates for a model. Checks operator-supplied overrides first,
+ * then falls back to the bundled Claude rates.
+ *
+ * @param {string} model
+ * @param {object} [config]
+ * @returns {{ input_per_1m: number, output_per_1m: number } | null}
+ */
+export function getClaudeCostRates(model, config) {
+  const operatorRates = config?.budget?.cost_rates;
+  if (operatorRates && typeof operatorRates === 'object' && operatorRates[model]) {
+    const r = operatorRates[model];
+    if (Number.isFinite(r.input_per_1m) && Number.isFinite(r.output_per_1m)) {
+      return r;
+    }
+  }
+  return CLAUDE_COST_RATES[model] || null;
+}
+
+/**
+ * @typedef {Object} StreamJsonCostResult
+ * @property {number} input_tokens
+ * @property {number} output_tokens
+ * @property {number|null} cost_usd - Claude Code's self-reported cost (if present)
+ * @property {string|null} model - Model identifier for rate lookup
+ * @property {number|null} cache_creation_input_tokens
+ * @property {number|null} cache_read_input_tokens
+ */
+
+/**
+ * Create a stateful parser that accumulates stream-json chunks and extracts
+ * the final result event containing usage metadata.
+ *
+ * @returns {{ push(chunk: string): void, getResult(): StreamJsonCostResult | null }}
+ */
+export function createStreamJsonCostParser() {
+  let buffer = '';
+  /** @type {StreamJsonCostResult | null} */
+  let lastResult = null;
+
+  return {
+    /**
+     * Feed a stdout chunk into the parser.
+     * @param {string} chunk
+     */
+    push(chunk) {
+      buffer += chunk;
+      const lines = buffer.split('\n');
+      // Last element is either empty (line ended with \n) or a partial line
+      buffer = lines.pop() || '';
+
+      for (const line of lines) {
+        const trimmed = line.trim();
+        if (!trimmed) continue;
+
+        let parsed;
+        try {
+          parsed = JSON.parse(trimmed);
+        } catch {
+          // Non-JSON line (tool output, diagnostic text) — skip silently
+          continue;
+        }
+
+        if (
+          parsed &&
+          typeof parsed === 'object' &&
+          parsed.type === 'result' &&
+          parsed.usage &&
+          typeof parsed.usage === 'object' &&
+          Number.isFinite(parsed.usage.input_tokens) &&
+          Number.isFinite(parsed.usage.output_tokens)
+        ) {
+          lastResult = {
+            input_tokens: parsed.usage.input_tokens,
+            output_tokens: parsed.usage.output_tokens,
+            cost_usd: typeof parsed.cost_usd === 'number' && Number.isFinite(parsed.cost_usd)
+              ? parsed.cost_usd
+              : null,
+            model: typeof parsed.model === 'string' ? parsed.model : null,
+            cache_creation_input_tokens: Number.isFinite(parsed.usage.cache_creation_input_tokens)
+              ? parsed.usage.cache_creation_input_tokens
+              : null,
+            cache_read_input_tokens: Number.isFinite(parsed.usage.cache_read_input_tokens)
+              ? parsed.usage.cache_read_input_tokens
+              : null,
+          };
+        }
+      }
+    },
+
+    /**
+     * Return the extracted cost data, or null if no valid result event was found.
+     * @returns {StreamJsonCostResult | null}
+     */
+    getResult() {
+      return lastResult;
+    },
+  };
+}
+
+/**
+ * Build a cost object from parsed stream-json data for turn-result enrichment.
+ *
+ * @param {StreamJsonCostResult} parsedCost
+ * @param {object} [config] - normalized config (for operator cost_rates overrides)
+ * @returns {{ input_tokens: number, output_tokens: number, usd: number, source: string, model?: string, cache_creation_input_tokens?: number, cache_read_input_tokens?: number }}
+ */
+export function buildCostFromStreamJson(parsedCost, config) {
+  const cost = {
+    input_tokens: parsedCost.input_tokens,
+    output_tokens: parsedCost.output_tokens,
+    source: 'stream_json',
+  };
+
+  // Prefer Claude Code's own cost_usd when available
+  if (typeof parsedCost.cost_usd === 'number' && Number.isFinite(parsedCost.cost_usd)) {
+    cost.usd = Math.round(parsedCost.cost_usd * 1000) / 1000;
+  } else if (parsedCost.model) {
+    const rates = getClaudeCostRates(parsedCost.model, config);
+    if (rates) {
+      cost.usd = Math.round(
+        ((parsedCost.input_tokens / 1_000_000) * rates.input_per_1m +
+         (parsedCost.output_tokens / 1_000_000) * rates.output_per_1m) * 1000
+      ) / 1000;
+    } else {
+      cost.usd = 0;
+    }
+  } else {
+    cost.usd = 0;
+  }
+
+  if (parsedCost.model) cost.model = parsedCost.model;
+  if (parsedCost.cache_creation_input_tokens != null) {
+    cost.cache_creation_input_tokens = parsedCost.cache_creation_input_tokens;
+  }
+  if (parsedCost.cache_read_input_tokens != null) {
+    cost.cache_read_input_tokens = parsedCost.cache_read_input_tokens;
+  }
+
+  return cost;
+}

package/src/lib/turn-result-validator.js

@@ -737,6 +737,16 @@ function validateArtifact(tr, config, state = null) {
         `Role "${tr.role}" completed an implementation turn without product code changes in files_changed. ` +
         'Implementation-phase completion requires at least one non-planning, non-review repo path; planning artifacts alone are not sufficient.'
       );
+    } else if (productFiles.every(f => isTestPath(f))) {
+      // Work-substance signal: an implementation turn that changed ONLY test files produced
+      // no implementation source. That is legitimate for acceptance/verification objectives,
+      // but thin for an "implement X" objective — surface it for QA/operator review instead
+      // of silently accepting (this test-only pattern slipped through QA during dogfooding).
+      warnings.push(
+        `Role "${tr.role}" completed an implementation turn that changed only test files ` +
+        `(${productFiles.join(', ')}) with no implementation source. This is valid for acceptance or ` +
+        'verification work; if the objective was to implement behavior, review whether the turn is test-only before accepting.'
+      );
     }
   }
 
@@ -792,6 +802,16 @@ function isProductChangePath(filePath) {
     && !filePath.startsWith('.agentxchain/staging/');
 }
 
+// A test/spec file path — used to flag implementation turns that produced only tests
+// (no implementation source) so test-only work is reviewed rather than silently accepted.
+function isTestPath(filePath) {
+  if (typeof filePath !== 'string') {
+    return false;
+  }
+  return /(^|\/)(tests?|__tests__|spec)\//.test(filePath)
+    || /\.(test|spec)\.[cm]?[jt]sx?$/.test(filePath);
+}
+
 function hasCheckpointableProducedFiles(tr) {
   return Array.isArray(tr.verification?.produced_files)
     && tr.verification.produced_files.some((entry) => (