agentxchain 2.155.58 → 2.155.60

package/package.json

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

package/src/lib/governed-state.js

@@ -7039,14 +7039,7 @@ function evaluateIntentCoverage(turnResult, intakeContext, { state = null, confi
   }
 
   // Build a searchable corpus from the turn result for semantic fallback
-  const corpus = [
-    turnResult.summary || '',
-    ...(turnResult.decisions || []).map(d => `${d.statement || ''} ${d.rationale || ''}`),
-    ...(turnResult.objections || []).map(o => o.statement || ''),
-    ...(turnResult.files_changed || []),
-    ...(turnResult.artifacts_created || []),
-    ...(Array.isArray(turnResult.intent_response) ? turnResult.intent_response.map(r => `${r.item || ''} ${r.detail || ''}`) : []),
-  ].join('\n').toLowerCase();
+  const corpus = buildIntentCoverageCorpus(turnResult);
 
   for (const item of acceptanceItems) {
     const normalizedItem = item.toLowerCase().trim();
@@ -7085,7 +7078,7 @@ function evaluateIntentCoverage(turnResult, intakeContext, { state = null, confi
     }
 
     // Check 2: Semantic fallback — significant keyword overlap
-    const words = normalizedItem.split(/\s+/).filter(w => w.length > 3);
+    const words = tokenizeIntentCoverageText(normalizedItem).filter(w => w.length > 3);
     if (words.length === 0) {
       addressed.push(item);
       continue;
@@ -7204,16 +7197,7 @@ function evaluateRoadmapDerivedConditionalCoverage(item, turnResult, intakeConte
     const milestoneId = sectionMatch[1].toLowerCase();
 
     // Build a searchable corpus from the turn result
-    const corpus = [
-      turnResult.summary || '',
-      ...(turnResult.decisions || []).map(d => `${d.statement || ''} ${d.rationale || ''}`),
-      ...(turnResult.objections || []).map(o => o.statement || ''),
-      ...(turnResult.files_changed || []),
-      ...(turnResult.artifacts_created || []),
-      ...(Array.isArray(turnResult.intent_response)
-        ? turnResult.intent_response.map(r => `${r.item || ''} ${r.detail || ''}`)
-        : []),
-    ].join('\n').toLowerCase();
+    const corpus = buildIntentCoverageCorpus(turnResult);
 
     // If the turn mentions the milestone section ID, the item is addressed
     return corpus.includes(milestoneId);
@@ -7244,16 +7228,7 @@ function evaluateRoadmapReplenishmentConditionalCoverage(item, turnResult, intak
     return null;
   }
 
-  const corpus = [
-    turnResult.summary || '',
-    ...(turnResult.decisions || []).map(d => `${d.statement || ''} ${d.rationale || ''}`),
-    ...(turnResult.objections || []).map(o => o.statement || ''),
-    ...(turnResult.files_changed || []),
-    ...(turnResult.artifacts_created || []),
-    ...(Array.isArray(turnResult.intent_response)
-      ? turnResult.intent_response.map(r => `${r.item || ''} ${r.detail || ''}`)
-      : []),
-  ].join('\n').toLowerCase();
+  const corpus = buildIntentCoverageCorpus(turnResult);
 
   if (!corpus.includes('vision.md')) {
     return false;
@@ -7275,6 +7250,40 @@ function evaluateRoadmapReplenishmentConditionalCoverage(item, turnResult, intak
   return sectionNames.some((section) => corpus.includes(section));
 }
 
+function buildIntentCoverageCorpus(turnResult) {
+  const verification = turnResult?.verification && typeof turnResult.verification === 'object'
+    ? turnResult.verification
+    : {};
+  const machineEvidenceText = Array.isArray(verification.machine_evidence)
+    ? verification.machine_evidence.map((entry) => {
+      if (!entry || typeof entry !== 'object' || Array.isArray(entry)) return '';
+      return Object.values(entry).map((value) => {
+        if (typeof value === 'string') return value;
+        if (Array.isArray(value)) return value.join(' ');
+        if (value && typeof value === 'object') return JSON.stringify(value);
+        return '';
+      }).join(' ');
+    })
+    : [];
+
+  return [
+    turnResult.summary || '',
+    ...(turnResult.decisions || []).map(d => `${d.statement || ''} ${d.rationale || ''}`),
+    ...(turnResult.objections || []).map(o => o.statement || ''),
+    ...(turnResult.files_changed || []),
+    ...(turnResult.artifacts_created || []),
+    verification.evidence_summary || '',
+    ...machineEvidenceText,
+    ...(Array.isArray(turnResult.intent_response) ? turnResult.intent_response.map(r => `${r.item || ''} ${r.detail || ''}`) : []),
+  ].join('\n').toLowerCase();
+}
+
+function tokenizeIntentCoverageText(value) {
+  return String(value || '')
+    .toLowerCase()
+    .match(/[a-z0-9]+/g) || [];
+}
+
 export {
   STATE_PATH,
   HISTORY_PATH,

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

@@ -1421,6 +1421,47 @@ export function normalizeTurnResult(tr, config, context = {}) {
     }
   }
 
+  // ── BUG-106: auto-declare expected_exit_code when verification.status is "pass" ──
+  // When verification.status is "pass" but some machine_evidence commands have
+  // non-zero exit codes without expected_exit_code, the agent clearly intended
+  // those failures (e.g. testing error handling). Auto-set expected_exit_code to
+  // match exit_code so the Stage D validator passes. This is safe because the
+  // agent explicitly declared the overall verification as passing.
+  if (
+    normalized.verification
+    && typeof normalized.verification === 'object'
+    && !Array.isArray(normalized.verification)
+    && normalized.verification.status === 'pass'
+    && Array.isArray(normalized.verification.machine_evidence)
+  ) {
+    const patchedEvidence = [];
+    let anyPatched = false;
+    normalized.verification.machine_evidence.forEach((entry, index) => {
+      if (
+        entry
+        && typeof entry === 'object'
+        && typeof entry.exit_code === 'number'
+        && entry.exit_code !== 0
+        && !Number.isInteger(entry.expected_exit_code)
+      ) {
+        patchedEvidence.push({ ...entry, expected_exit_code: entry.exit_code });
+        anyPatched = true;
+        corrections.push(`verification.machine_evidence[${index}].expected_exit_code: set to ${entry.exit_code} (verification.status is "pass")`);
+        normalizationEvents.push({
+          field: `verification.machine_evidence[${index}].expected_exit_code`,
+          original_value: null,
+          normalized_value: entry.exit_code,
+          rationale: 'verification_pass_expected_exit_code_inferred',
+        });
+      } else {
+        patchedEvidence.push(entry);
+      }
+    });
+    if (anyPatched) {
+      normalized.verification = { ...normalized.verification, machine_evidence: patchedEvidence };
+    }
+  }
+
   // ── BUG-90: normalize missing artifact.type ─────────────────────────
   if (
     normalized.artifact