agentxchain 2.155.32 → 2.155.34

package/package.json

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

package/src/lib/continuous-run.js

@@ -63,6 +63,19 @@ function getRoadmapReplenishmentTriageHints(root) {
   };
 }
 
+function formatVisionSectionScope(sections, { limit = 5 } = {}) {
+  const names = Array.isArray(sections)
+    ? sections.map((section) => String(section || '').trim()).filter(Boolean)
+    : [];
+  if (names.length === 0) {
+    return 'remaining VISION.md scope';
+  }
+  if (names.length <= limit) {
+    return names.join(', ');
+  }
+  return `${names.slice(0, limit).join(', ')} (+${names.length - limit} more)`;
+}
+
 // ---------------------------------------------------------------------------
 // Session state
 // ---------------------------------------------------------------------------
@@ -734,7 +747,8 @@ export function seedFromVision(root, visionPath, options = {}) {
   // generic vision candidates can bypass PM roadmap replenishment.
   const exhaustion = detectRoadmapExhaustedVisionOpen(root, visionPath);
   if (exhaustion.open) {
-    const sectionNames = exhaustion.unplanned_sections.join(', ');
+    const sectionNames = formatVisionSectionScope(exhaustion.unplanned_sections);
+    const fullSectionNames = exhaustion.unplanned_sections.join(', ');
     const replenishmentEvent = recordEvent(root, {
       source: 'vision_scan',
       category: 'roadmap_exhausted_vision_open',
@@ -745,7 +759,7 @@ export function seedFromVision(root, visionPath, options = {}) {
         derived: true,
       },
       evidence: [
-        { type: 'text', value: `All ${exhaustion.total_milestones} roadmap milestones checked. VISION sections not yet planned: ${sectionNames}` },
+        { type: 'text', value: `All ${exhaustion.total_milestones} roadmap milestones checked. VISION sections not yet planned: ${fullSectionNames}` },
       ],
     });
 
@@ -767,10 +781,10 @@ export function seedFromVision(root, visionPath, options = {}) {
       template: 'generic',
       ...(replenishmentHints.preferred_role ? { preferred_role: replenishmentHints.preferred_role } : {}),
       ...(replenishmentHints.phase_scope ? { phase_scope: replenishmentHints.phase_scope } : {}),
-      charter: `[roadmap-replenishment] Derive next bounded roadmap increment from VISION.md. Unplanned scope: ${sectionNames}. Current roadmap checked through ${exhaustion.latest_milestone}. Read .planning/VISION.md and .planning/ROADMAP.md to select the next testable milestone. Produce concrete unchecked M${exhaustion.total_milestones + 1} items. Do not re-verify previous completed milestones.`,
+      charter: `[roadmap-replenishment] Derive next bounded roadmap increment from VISION.md. Candidate pool: ${sectionNames}. Current roadmap checked through ${exhaustion.latest_milestone}. Read .planning/VISION.md and .planning/ROADMAP.md to select one next testable milestone. Produce concrete unchecked M${exhaustion.total_milestones + 1} items. Do not re-verify previous completed milestones.`,
       acceptance_contract: [
         `New unchecked milestone items added to .planning/ROADMAP.md`,
-        `Milestone scope derived from VISION.md sections: ${sectionNames}`,
+        `Milestone cites at least one concrete VISION.md source section from the unplanned backlog`,
         `Milestone is bounded, testable, and does not duplicate existing checked milestones`,
       ],
     });
@@ -795,7 +809,7 @@ export function seedFromVision(root, visionPath, options = {}) {
       idle: false,
       intentId: replenishmentIntentId,
       section: 'Roadmap replenishment',
-      goal: `Derive next increment from: ${sectionNames}`,
+      goal: `Derive next increment from unplanned VISION scope: ${sectionNames}`,
       source: 'roadmap_replenishment',
     };
   }

package/src/lib/governed-state.js

@@ -6995,6 +6995,12 @@ function evaluateIntentCoverage(turnResult, intakeContext, { state = null, confi
       continue;
     }
 
+    const roadmapReplenishmentCoverage = evaluateRoadmapReplenishmentConditionalCoverage(item, turnResult, intakeContext);
+    if (roadmapReplenishmentCoverage === 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)) {
@@ -7140,6 +7146,59 @@ function evaluateRoadmapDerivedConditionalCoverage(item, turnResult, intakeConte
   return null;
 }
 
+// ── Roadmap-replenishment conditional coverage (BUG-85) ───────────────────
+//
+// BUG-77's replenishment path originally generated one acceptance item
+// containing every unplanned VISION heading. A valid PM turn only binds one
+// next milestone, so requiring semantic coverage of the whole backlog is
+// overbroad. Accept both the new scoped item and the legacy broad item when
+// the result cites VISION.md and at least one concrete listed section.
+
+function evaluateRoadmapReplenishmentConditionalCoverage(item, turnResult, intakeContext) {
+  const charter = intakeContext?.charter || '';
+  if (!charter.startsWith('[roadmap-replenishment]')) {
+    return null;
+  }
+
+  const normalizedItem = typeof item === 'string' ? item.toLowerCase().trim() : '';
+  const isScopedTraceabilityItem =
+    normalizedItem.startsWith('milestone cites at least one concrete vision.md source section')
+    || normalizedItem.startsWith('milestone scope derived from vision.md sections:');
+  if (!isScopedTraceabilityItem) {
+    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();
+
+  if (!corpus.includes('vision.md')) {
+    return false;
+  }
+
+  if (normalizedItem.startsWith('milestone cites at least one concrete vision.md source section')) {
+    return true;
+  }
+
+  const sectionList = String(item).split(':').slice(1).join(':');
+  const sectionNames = sectionList
+    .split(',')
+    .map((section) => section.trim().toLowerCase())
+    .filter((section) => section.length >= 4);
+  if (sectionNames.length === 0) {
+    return true;
+  }
+
+  return sectionNames.some((section) => corpus.includes(section));
+}
+
 export {
   STATE_PATH,
   HISTORY_PATH,

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

@@ -1274,6 +1274,34 @@ export function normalizeTurnResult(tr, config, context = {}) {
       );
       normalized.proposed_next_role = fallback;
     }
+  } else if (
+    // BUG-82: When BUG-81's gate auto-strip keeps the session in an earlier
+    // phase (e.g. planning), authoritative roles dispatched in that phase may
+    // propose a next role valid for the phase they *expected* (e.g. "qa" for
+    // implementation) but illegal for the actual phase.  Auto-normalize to a
+    // routing-legal role instead of hard-erroring.
+    isKnownPhase &&
+    !isReviewOnly &&
+    normalized.status === 'completed' &&
+    typeof normalized.proposed_next_role === 'string' &&
+    normalized.proposed_next_role !== 'human' &&
+    !/^<[^>]+>$/.test(normalized.proposed_next_role) && // skip template placeholders — let schema validation catch them
+    allowedNextRoles.length > 0 &&
+    !allowedNextRoles.includes(normalized.proposed_next_role)
+  ) {
+    const fallback = pickAllowedRoleFallback();
+    if (fallback) {
+      corrections.push(
+        `proposed_next_role: corrected "${normalized.proposed_next_role}" to allowed role "${fallback}" (routing-illegal for phase "${currentPhase}")`
+      );
+      normalizationEvents.push({
+        field: 'proposed_next_role',
+        original_value: normalized.proposed_next_role,
+        normalized_value: fallback,
+        rationale: `routing_illegal_for_phase_${currentPhase}`,
+      });
+      normalized.proposed_next_role = fallback;
+    }
   }
 
   return { normalized, corrections, normalizationEvents };