agentxchain 2.155.43 → 2.155.45

package/package.json

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

package/src/lib/dispatch-bundle.js

@@ -490,17 +490,19 @@ function renderPrompt(role, roleId, turn, state, config, root) {
   lines.push('');
   lines.push('- `schema_version`: always `"1.0"`');
   lines.push('- `run_id`, `turn_id`, `role`, `runtime_id`: must match the values above exactly');
-  lines.push('- `status`: one of `completed`, `blocked`, `needs_human`, `failed`');
+  lines.push('- `status`: one of `completed`, `blocked`, `needs_human`, `failed`. Do NOT use `complete`, `success`, `done`, or any other synonym — use the exact enum value `completed`.');
   lines.push('- `summary`: concise description of what you did this turn');
-  lines.push('- `decisions[].id`: pattern `DEC-NNN` (increment from previous turn)');
+  lines.push('- `files_changed`: array of **strings** (file paths only). Do NOT use objects like `{path, change_type}` — just the path string (e.g. `["src/cli.js", "tests/smoke.mjs"]`).');
+  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` or `description` as the field name — the field is `statement`.');
   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-`.');
   lines.push('- `objections[].severity`: one of `low`, `medium`, `high`, `blocking`');
-  lines.push('- `verification.status`: one of `pass`, `fail`, `skipped`');
+  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`');
   lines.push('- Expected-failure checks must be wrapped in a verifier that exits `0` when the failure occurs as expected; do not list raw non-zero negative-case commands on a passing turn');
   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`: one of `workspace`, `patch`, `commit`, `review`');
+  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 `[]`.');
   lines.push('- Only set `artifact.type` to `"workspace"` when you actually modified repo files and listed every changed path in `files_changed`.');
   lines.push('- Every `objections[]` item must include a non-empty `statement`; do not use `summary` or `detail` as a substitute.');

package/src/lib/governed-state.js

@@ -38,6 +38,7 @@ import {
   deriveAcceptedRef,
   checkCleanBaseline,
   detectDirtyFilesOutsideAllowed,
+  getBaselineUnchangedFiles,
   isOperationalPath,
   isBaselineExemptPath,
   normalizeCheckpointableFiles,
@@ -4504,6 +4505,22 @@ function _acceptGovernedTurnLocked(root, config, opts) {
     }
   }
 
+  // BUG-91: Files that were dirty at dispatch baseline and have NOT been
+  // modified during the turn (same SHA marker) should not block acceptance.
+  // These are inherited workspace state — the turn did not create them.
+  // Example: dogfood evidence files (.planning/dogfood-100-turn-evidence/)
+  // that remain dirty across turns but are not turn-attributed mutations.
+  const baselineUnchangedDirtyFiles = getBaselineUnchangedFiles(root, baseline);
+  if (baselineUnchangedDirtyFiles.length > 0) {
+    emitRunEvent(root, 'baseline_dirty_unchanged_excluded', {
+      run_id: state.run_id,
+      turn_id: currentTurn.turn_id,
+      phase: state.phase,
+      excluded_files: baselineUnchangedDirtyFiles,
+      rationale: 'Files were dirty at dispatch baseline with matching SHA markers at acceptance time — inherited workspace state, not turn-attributed mutations.',
+    });
+  }
+
   const dirtyParity = detectDirtyFilesOutsideAllowed(
     root,
     writeAuthority,
@@ -4511,6 +4528,7 @@ function _acceptGovernedTurnLocked(root, config, opts) {
       ...(turnResult.files_changed || []),
       ...concurrentAllowedDirtyFiles,
       ...uncheckpointedPriorFiles,
+      ...baselineUnchangedDirtyFiles,
     ],
   );
   if (!dirtyParity.clean) {

package/src/lib/repo-observer.js

@@ -835,6 +835,26 @@ export function captureDirtyWorkspaceSnapshot(root) {
   return snapshot;
 }
 
+/**
+ * Return file paths that were dirty at dispatch baseline and have NOT changed
+ * since (same SHA marker). These files are inherited workspace state — the
+ * turn did not create or modify them — and should not block acceptance.
+ * BUG-91: prevents false-positive dirty-parity failures on pre-existing dirt.
+ */
+export function getBaselineUnchangedFiles(root, baseline) {
+  const snapshot = baseline?.dirty_snapshot;
+  if (!snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot)) {
+    return [];
+  }
+  const unchanged = [];
+  for (const [filePath, baselineSha] of Object.entries(snapshot)) {
+    if (baselineSha === getWorkspaceFileMarker(root, filePath)) {
+      unchanged.push(filePath);
+    }
+  }
+  return unchanged;
+}
+
 function filterBaselineDirtyFiles(root, changedFiles, baseline) {
   const snapshot = baseline?.dirty_snapshot;
   if (!snapshot || typeof snapshot !== 'object' || Array.isArray(snapshot)) {

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

@@ -1018,6 +1018,138 @@ export function normalizeTurnResult(tr, config, context = {}) {
   const hasExplicitNoEditLifecycleSignal = normalized.run_completion_request === true
     || (typeof normalized.phase_transition_request === 'string' && normalized.phase_transition_request.trim().length > 0);
 
+  // ── BUG-90: normalize status synonyms ────────────────────────────────
+  const STATUS_SYNONYMS = { complete: 'completed', success: 'completed', done: 'completed', error: 'failed', failure: 'failed' };
+  if (typeof normalized.status === 'string' && !VALID_STATUSES.includes(normalized.status)) {
+    const mapped = STATUS_SYNONYMS[normalized.status.toLowerCase()];
+    if (mapped) {
+      corrections.push(`status: rewritten "${normalized.status}" → "${mapped}"`);
+      normalizationEvents.push({
+        field: 'status',
+        original_value: normalized.status,
+        normalized_value: mapped,
+        rationale: 'status_synonym_rewritten',
+      });
+      normalized.status = mapped;
+    }
+  }
+
+  // ── BUG-90: normalize files_changed objects to path strings ──────────
+  if (Array.isArray(normalized.files_changed)) {
+    let filesCoerced = false;
+    normalized.files_changed = normalized.files_changed.map((item, i) => {
+      if (typeof item === 'string') return item;
+      if (item !== null && typeof item === 'object' && typeof item.path === 'string') {
+        filesCoerced = true;
+        return item.path;
+      }
+      return item; // let validator catch
+    });
+    if (filesCoerced) {
+      corrections.push('files_changed: coerced object entries to path strings');
+      normalizationEvents.push({
+        field: 'files_changed',
+        original_value: '(object entries)',
+        normalized_value: '(path strings)',
+        rationale: 'files_changed_object_to_string',
+      });
+    }
+  }
+
+  // ── BUG-90: normalize decisions ─────────────────────────────────────
+  if (Array.isArray(normalized.decisions)) {
+    normalized.decisions = normalized.decisions.map((dec, index) => {
+      if (dec === null || typeof dec !== 'object' || Array.isArray(dec)) return dec;
+      let patched = dec;
+
+      // Normalize id: "D1" / "D2" / arbitrary → "DEC-001" / "DEC-002"
+      const validDecIdPattern = /^DEC-\d+$/;
+      const currentDecId = typeof patched.id === 'string' ? patched.id : '';
+      if (!validDecIdPattern.test(currentDecId)) {
+        const normalizedDecId = `DEC-${String(index + 1).padStart(3, '0')}`;
+        corrections.push(`decisions[${index}].id: rewritten "${currentDecId || '(missing)'}" → ${normalizedDecId}`);
+        normalizationEvents.push({
+          field: `decisions[${index}].id`,
+          original_value: patched.id ?? null,
+          normalized_value: normalizedDecId,
+          rationale: 'invalid_decision_id_rewritten',
+        });
+        patched = { ...patched, id: normalizedDecId };
+      }
+
+      // Normalize missing statement from decision/description field
+      const stmt = typeof patched.statement === 'string' ? patched.statement.trim() : '';
+      if (!stmt) {
+        const alt = typeof patched.decision === 'string' ? patched.decision.trim()
+          : typeof patched.description === 'string' ? patched.description.trim() : '';
+        if (alt) {
+          const srcField = typeof patched.decision === 'string' && patched.decision.trim() ? 'decision' : 'description';
+          corrections.push(`decisions[${index}].statement: copied from ${srcField}`);
+          normalizationEvents.push({
+            field: `decisions[${index}].statement`,
+            original_value: patched.statement ?? null,
+            normalized_value: alt,
+            rationale: `copied_from_${srcField}`,
+          });
+          patched = { ...patched, statement: alt };
+        }
+      }
+
+      // Default missing category to 'implementation'
+      if (!patched.category || !VALID_CATEGORIES.includes(patched.category)) {
+        const defaultCat = 'implementation';
+        corrections.push(`decisions[${index}].category: defaulted to "${defaultCat}"`);
+        normalizationEvents.push({
+          field: `decisions[${index}].category`,
+          original_value: patched.category ?? null,
+          normalized_value: defaultCat,
+          rationale: 'missing_category_defaulted',
+        });
+        patched = { ...patched, category: defaultCat };
+      }
+
+      return patched;
+    });
+  }
+
+  // ── BUG-90: normalize missing verification.status ───────────────────
+  if (
+    normalized.verification
+    && typeof normalized.verification === 'object'
+    && !Array.isArray(normalized.verification)
+    && !('status' in normalized.verification)
+  ) {
+    const exitCode = normalized.verification.exit_code;
+    const inferredStatus = exitCode === 0 ? 'pass' : typeof exitCode === 'number' ? 'fail' : 'skipped';
+    corrections.push(`verification.status: inferred "${inferredStatus}" from exit_code=${exitCode}`);
+    normalizationEvents.push({
+      field: 'verification.status',
+      original_value: null,
+      normalized_value: inferredStatus,
+      rationale: 'verification_status_inferred_from_exit_code',
+    });
+    normalized.verification = { ...normalized.verification, status: inferredStatus };
+  }
+
+  // ── BUG-90: normalize missing artifact.type ─────────────────────────
+  if (
+    normalized.artifact
+    && typeof normalized.artifact === 'object'
+    && !Array.isArray(normalized.artifact)
+    && !('type' in normalized.artifact)
+  ) {
+    const hasFiles = Array.isArray(normalized.files_changed) && normalized.files_changed.length > 0;
+    const inferredType = hasFiles ? 'workspace' : 'review';
+    corrections.push(`artifact.type: inferred "${inferredType}" from files_changed`);
+    normalizationEvents.push({
+      field: 'artifact.type',
+      original_value: null,
+      normalized_value: inferredType,
+      rationale: 'artifact_type_inferred_from_files_changed',
+    });
+    normalized.artifact = { ...normalized.artifact, type: inferredType };
+  }
+
   // ── Rule 0a: empty workspace artifact → no-edit review normalization ──
   if (
     normalized.artifact