agentxchain 2.155.57 → 2.155.59

package/package.json

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

package/src/lib/dispatch-bundle.js

@@ -506,6 +506,7 @@ function renderPrompt(role, roleId, turn, state, config, root) {
   lines.push('- `verification.status`: **REQUIRED**. One of `pass`, `fail`, `skipped`. Always include this field in the `verification` object.');
   lines.push('- `verification.status: "pass"` is valid only when every `verification.machine_evidence[].exit_code` is `0`, unless a negative-case command explicitly sets `expected_exit_code` to the same non-zero value.');
   lines.push('- Expected-failure checks should be wrapped in a verifier that exits `0` when the failure occurs as expected. If you must record a raw non-zero negative-case command on a passing turn, set `verification.machine_evidence[].expected_exit_code` to the expected non-zero code and explain it in `evidence_summary`.');
+  lines.push('- `verification.machine_evidence[]` is only for executable command records with both `command` and `exit_code`. Put typed marker checks, file-grep observations, bucket summaries, and acceptance-contract summaries in `verification.evidence_summary`, not in `machine_evidence`.');
   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`: **REQUIRED**. One of `workspace`, `patch`, `commit`, `review`.');
   lines.push('- If you make zero repo file edits, set `artifact.type` to `"review"` and `files_changed` to `[]`.');

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

@@ -1364,6 +1364,63 @@ export function normalizeTurnResult(tr, config, context = {}) {
     normalized.verification = { ...normalized.verification, status: inferredStatus };
   }
 
+  // ── BUG-104: typed marker evidence belongs in evidence_summary ───────
+  // machine_evidence is reserved for executable command records. Some model
+  // turns emit useful structured observations in that array (for example
+  // file_marker_grep objects) without command/exit_code fields. Preserve that
+  // information as summary evidence instead of fabricating shell commands.
+  if (
+    normalized.verification
+    && typeof normalized.verification === 'object'
+    && !Array.isArray(normalized.verification)
+    && Array.isArray(normalized.verification.machine_evidence)
+  ) {
+    const keptMachineEvidence = [];
+    const structuredEvidenceSummaries = [];
+    normalized.verification.machine_evidence.forEach((entry, index) => {
+      if (
+        entry
+        && typeof entry === 'object'
+        && !Array.isArray(entry)
+        && typeof entry.command === 'string'
+        && entry.command.trim()
+        && Number.isInteger(entry.exit_code)
+      ) {
+        keptMachineEvidence.push(entry);
+        return;
+      }
+
+      const summary = summarizeStructuredMachineEvidence(entry);
+      if (!summary) {
+        keptMachineEvidence.push(entry);
+        return;
+      }
+
+      structuredEvidenceSummaries.push(summary);
+      corrections.push(`verification.machine_evidence[${index}]: moved structured ${summary.type} evidence into evidence_summary`);
+      normalizationEvents.push({
+        field: `verification.machine_evidence[${index}]`,
+        original_value: entry,
+        normalized_value: summary.text,
+        rationale: 'structured_machine_evidence_moved_to_evidence_summary',
+      });
+    });
+
+    if (structuredEvidenceSummaries.length > 0) {
+      const existingSummary = typeof normalized.verification.evidence_summary === 'string'
+        ? normalized.verification.evidence_summary.trim()
+        : '';
+      const appendedSummary = structuredEvidenceSummaries.map((summary) => summary.text).join('; ');
+      normalized.verification = {
+        ...normalized.verification,
+        machine_evidence: keptMachineEvidence,
+        evidence_summary: existingSummary
+          ? `${existingSummary}\nStructured evidence: ${appendedSummary}`
+          : `Structured evidence: ${appendedSummary}`,
+      };
+    }
+  }
+
   // ── BUG-90: normalize missing artifact.type ─────────────────────────
   if (
     normalized.artifact
@@ -1742,6 +1799,42 @@ export function normalizeTurnResult(tr, config, context = {}) {
   return { normalized, corrections, normalizationEvents };
 }
 
+function summarizeStructuredMachineEvidence(entry) {
+  if (!entry || typeof entry !== 'object' || Array.isArray(entry)) {
+    return null;
+  }
+  if (typeof entry.type !== 'string' || entry.type.trim().length === 0) {
+    return null;
+  }
+
+  const type = entry.type.trim();
+  const parts = [`type=${type}`];
+  for (const key of ['path', 'marker', 'section', 'result']) {
+    if (typeof entry[key] === 'string' && entry[key].trim()) {
+      parts.push(`${key}=${truncateEvidenceValue(entry[key].trim())}`);
+    }
+  }
+  if (Array.isArray(entry.contract) && entry.contract.length > 0) {
+    parts.push(`contract=${truncateEvidenceValue(entry.contract.join(' | '))}`);
+  }
+  if (
+    entry.buckets_observed
+    && typeof entry.buckets_observed === 'object'
+    && !Array.isArray(entry.buckets_observed)
+  ) {
+    parts.push(`buckets_observed=${truncateEvidenceValue(JSON.stringify(entry.buckets_observed))}`);
+  }
+
+  return {
+    type,
+    text: `[${parts.join(', ')}]`,
+  };
+}
+
+function truncateEvidenceValue(value, max = 220) {
+  return value.length > max ? `${value.slice(0, max - 3)}...` : value;
+}
+
 function normalizeIdleExpansionMutualExclusionSentinel(result) {
   if (!result || typeof result !== 'object' || Array.isArray(result)) {
     return { changed: false, value: result, correction: '' };