agentxchain 2.155.56 → 2.155.58

package/package.json

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

package/src/lib/dispatch-bundle.js

@@ -498,7 +498,7 @@ function renderPrompt(role, roleId, turn, state, config, root) {
   lines.push('- `files_changed`: **REQUIRED** array of **strings** (file paths only). Do NOT use `files_modified` — the field name is `files_changed`. Do NOT use objects like `{path, change_type}` — just the path string (e.g. `["src/cli.js", "tests/smoke.mjs"]`).');
   lines.push('- `proposed_next_role`: **REQUIRED**. Must be in allowed_next_roles for the current phase, or `"human"`.');
   lines.push('- `decisions[].id`: pattern `DEC-NNN` where NNN is digits only (e.g. `DEC-001`, `DEC-002`). Do NOT use `D1`, `D2`, or freeform IDs.');
-  lines.push('- `decisions[].statement`: non-empty string describing the decision. Do NOT use `decision`, `description`, or `summary` as the field name — the field is `statement`.');
+  lines.push('- `decisions[].statement`: non-empty string describing the decision. Do NOT use `decision`, `description`, `summary`, or `title` as the field name — the field is `statement`.');
   lines.push('- `decisions[].rationale`: REQUIRED non-empty string explaining why the decision was made. Do NOT omit this field.');
   lines.push('- `decisions[].category`: one of `implementation`, `architecture`, `scope`, `process`, `quality`, `release`');
   lines.push('- `objections[].id`: pattern `OBJ-NNN` where NNN is digits only (e.g. `OBJ-001`, `OBJ-002`). Do NOT append extra suffixes like `-M31` or use non-numeric characters after `OBJ-`.');
@@ -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

@@ -1285,10 +1285,12 @@ export function normalizeTurnResult(tr, config, context = {}) {
       if (!stmt) {
         const alt = typeof patched.decision === 'string' ? patched.decision.trim()
           : typeof patched.description === 'string' ? patched.description.trim()
-            : typeof patched.summary === 'string' ? patched.summary.trim() : '';
+            : typeof patched.summary === 'string' ? patched.summary.trim()
+              : typeof patched.title === 'string' ? patched.title.trim() : '';
         if (alt) {
           const srcField = typeof patched.decision === 'string' && patched.decision.trim() ? 'decision'
-            : typeof patched.description === 'string' && patched.description.trim() ? 'description' : 'summary';
+            : typeof patched.description === 'string' && patched.description.trim() ? 'description'
+              : typeof patched.summary === 'string' && patched.summary.trim() ? 'summary' : 'title';
           corrections.push(`decisions[${index}].statement: copied from ${srcField}`);
           normalizationEvents.push({
             field: `decisions[${index}].statement`,
@@ -1362,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
@@ -1740,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: '' };