agentxchain 2.155.57 → 2.155.58

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agentxchain",
-  "version": "2.155.57",
+  "version": "2.155.58",
   "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/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: '' };