agentxchain 2.155.30 → 2.155.32

package/package.json

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

package/src/lib/governed-state.js

@@ -4701,29 +4701,51 @@ function _acceptGovernedTurnLocked(root, config, opts) {
 
       const gateSemanticMode = config.gate_semantic_coverage_mode || 'strict';
       if (uncoveredFiles.length > 0 && gateSemanticMode === 'strict') {
-        const coverageError = `Gate "${exitGateId}" is failing on ${uncoveredFiles.join(', ')}. Your turn did not modify ${uncoveredFiles.length === 1 ? 'that file' : 'those files'}. Either edit the file(s) to satisfy the gate, or remove the phase transition request.`;
-        transitionToFailedAcceptance(root, state, currentTurn, coverageError, {
-          error_code: 'gate_semantic_coverage',
-          stage: 'gate_semantic_coverage',
-          extra: {
-            gate_id: exitGateId,
-            uncovered_files: uncoveredFiles,
-            declared_files: [...declaredFiles],
-            gate_reasons: preGateResult.reasons,
-          },
-        });
-        return {
-          ok: false,
-          error: coverageError,
-          validation: {
-            ...validation,
-            ok: false,
+        // BUG-81: In planning phase only, auto-strip the phase transition request
+        // instead of permanently blocking.  PM's partial planning work is preserved;
+        // the phase stays in "planning" and the continuous loop re-dispatches PM to
+        // complete gate artifacts.  In implementation+ phases, gate failures still
+        // reject — dev/qa claiming readiness without updating gate files is a real error.
+        if (turnResult.phase_transition_request && state.phase === 'planning') {
+          emitRunEvent(root, 'gate_transition_request_auto_stripped', {
+            run_id: state.run_id,
+            phase: state.phase,
+            status: state.status,
+            turn: { turn_id: currentTurn.turn_id, role_id: currentTurn.assigned_role },
+            payload: {
+              gate_id: exitGateId,
+              uncovered_files: uncoveredFiles,
+              declared_files: [...declaredFiles],
+              rationale: 'Turn did not modify gate-required files; phase transition stripped to preserve partial planning work',
+            },
+          });
+          delete turnResult.phase_transition_request;
+          // Fall through — continue with acceptance without the phase transition
+        } else {
+          const coverageError = `Gate "${exitGateId}" is failing on ${uncoveredFiles.join(', ')}. Your turn did not modify ${uncoveredFiles.length === 1 ? 'that file' : 'those files'}. Either edit the file(s) to satisfy the gate, or remove the phase transition request.`;
+          transitionToFailedAcceptance(root, state, currentTurn, coverageError, {
+            error_code: 'gate_semantic_coverage',
             stage: 'gate_semantic_coverage',
-            error_class: 'gate_coverage_error',
-            errors: uncoveredFiles.map(f => `Gate "${exitGateId}" is failing on "${f}". Your turn did not modify that file.`),
-            warnings: [],
-          },
-        };
+            extra: {
+              gate_id: exitGateId,
+              uncovered_files: uncoveredFiles,
+              declared_files: [...declaredFiles],
+              gate_reasons: preGateResult.reasons,
+            },
+          });
+          return {
+            ok: false,
+            error: coverageError,
+            validation: {
+              ...validation,
+              ok: false,
+              stage: 'gate_semantic_coverage',
+              error_class: 'gate_coverage_error',
+              errors: uncoveredFiles.map(f => `Gate "${exitGateId}" is failing on "${f}". Your turn did not modify that file.`),
+              warnings: [],
+            },
+          };
+        }
       }
     }
   }
@@ -6967,6 +6989,12 @@ function evaluateIntentCoverage(turnResult, intakeContext, { state = null, confi
       continue;
     }
 
+    const roadmapCoverage = evaluateRoadmapDerivedConditionalCoverage(item, turnResult, intakeContext, state);
+    if (roadmapCoverage === true) {
+      addressed.push(item);
+      continue;
+    }
+
     // Check 1: Structural — intent_response field with explicit status
     const structuralEntry = responseMap.get(normalizedItem);
     if (structuralEntry && ['addressed', 'deferred', 'rejected'].includes(structuralEntry.status)) {
@@ -7050,6 +7078,68 @@ function evaluateIdleExpansionConditionalCoverage(item, turnResult, intakeContex
   return null;
 }
 
+// ── Roadmap-derived intent conditional coverage (BUG-80) ────────────────────
+//
+// Roadmap-derived intents (charter starts with "[roadmap]") include literal
+// implementation text as acceptance items.  PM turns in planning phase produce
+// charter/scoping artifacts, not implementation code, so the generic 50%
+// keyword-overlap check fails.  This function provides phase-aware evaluation:
+//  - "Evidence source:" items are metadata provenance → always addressed
+//  - "Unchecked roadmap item completed:" in planning phase → milestone-mention check
+//  - In implementation+ phases → falls through to normal semantic matching
+
+function evaluateRoadmapDerivedConditionalCoverage(item, turnResult, intakeContext, state) {
+  const charter = intakeContext?.charter || '';
+  if (!charter.startsWith('[roadmap]')) {
+    return null;
+  }
+
+  const normalizedItem = typeof item === 'string' ? item.toLowerCase().trim() : '';
+
+  // "Evidence source:" items are provenance metadata, not deliverables.
+  // No turn of any role can "address" a file path reference.
+  if (normalizedItem.startsWith('evidence source:')) {
+    return true;
+  }
+
+  // "Unchecked roadmap item completed:" contains literal implementation text.
+  // In planning phase, PM scopes the milestone — check for milestone mention
+  // rather than requiring implementation-keyword overlap.
+  // In implementation/qa/launch phases, fall through to normal semantic matching
+  // so dev turns are still evaluated against actual implementation keywords.
+  if (normalizedItem.startsWith('unchecked roadmap item completed:')) {
+    const currentPhase = state?.phase || '';
+    if (currentPhase !== 'planning') {
+      return null;
+    }
+
+    // Extract milestone section identifier from charter: "[roadmap] M28: ..."
+    const sectionMatch = charter.match(/\[roadmap\]\s*(M\d+)/i);
+    if (!sectionMatch) {
+      return null;
+    }
+
+    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();
+
+    // If the turn mentions the milestone section ID, the item is addressed
+    return corpus.includes(milestoneId);
+  }
+
+  return null;
+}
+
 export {
   STATE_PATH,
   HISTORY_PATH,