agentxchain 2.155.26 → 2.155.28

package/package.json

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

package/src/commands/status.js

@@ -23,6 +23,7 @@ import { findCurrentHumanEscalation } from '../lib/human-escalations.js';
 import { getDashboardPid, getDashboardSession } from './dashboard.js';
 import { readPreemptionMarker, validatePreemptionMarker, findPendingApprovedIntents } from '../lib/intake.js';
 import { readContinuousSession } from '../lib/continuous-run.js';
+import { deriveRoadmapCandidates, detectRoadmapExhaustedVisionOpen, resolveVisionPath } from '../lib/vision-reader.js';
 import { readAllDispatchProgress } from '../lib/dispatch-progress.js';
 import { readCoordinatorWarnings } from '../lib/coordinator-warnings.js';
 import { reconcileStaleTurns } from '../lib/stale-turn-watchdog.js';
@@ -155,6 +156,7 @@ function renderGovernedStatus(context, opts) {
   const preemptionMarker = validatePreemptionMarker(root);
   const pendingIntents = findPendingApprovedIntents(root, { run_id: stateRunId || null });
   const continuousSession = readContinuousSession(root);
+  appendRoadmapOpenWorkNextAction(root, state, continuousSession, nextActions);
   const gateActionAttempt = state?.pending_phase_transition
     ? summarizeLatestGateActionAttempt(root, 'phase_transition', state.pending_phase_transition.gate)
     : state?.pending_run_completion
@@ -698,6 +700,41 @@ function renderGovernedStatus(context, opts) {
   console.log('');
 }
 
+function appendRoadmapOpenWorkNextAction(root, state, continuousSession, nextActions) {
+  const status = state?.status || null;
+  const activeTurns = getActiveTurnCount(state);
+  const hasPendingGate = Boolean(state?.pending_phase_transition || state?.pending_run_completion);
+  const sessionTerminal = ['completed', 'idle_exit', 'vision_exhausted', 'vision_expansion_exhausted'].includes(continuousSession?.status);
+  const runTerminal = status === 'completed' || status === 'idle' || status === null;
+
+  if (activeTurns > 0 || hasPendingGate || (!runTerminal && !sessionTerminal)) {
+    return;
+  }
+
+  const roadmap = deriveRoadmapCandidates(root);
+  if (roadmap.ok && roadmap.candidates.length > 0) {
+    const candidate = roadmap.candidates[0];
+    const command = 'agentxchain run --continuous --vision .planning/VISION.md';
+    const reason = `Unchecked roadmap work remains (${candidate.section} line ${candidate.line}): ${candidate.goal}`;
+    if (!nextActions.some((action) => action.command === command && action.reason === reason)) {
+      nextActions.push({ command, reason, type: 'roadmap_open_work_detected' });
+    }
+    return;
+  }
+
+  // BUG-77: When roadmap has no unchecked work, check if roadmap is exhausted
+  // but VISION still has unplanned scope requiring PM roadmap-replenishment.
+  const visionPath = resolveVisionPath(root, continuousSession?.vision_path || '.planning/VISION.md');
+  const exhaustion = detectRoadmapExhaustedVisionOpen(root, visionPath);
+  if (exhaustion.open) {
+    const command = 'agentxchain run --continuous --vision .planning/VISION.md';
+    const reason = `Roadmap exhausted (${exhaustion.total_milestones} milestones checked through ${exhaustion.latest_milestone}). VISION.md has unplanned scope: ${exhaustion.unplanned_sections.join(', ')}`;
+    if (!nextActions.some((action) => action.type === 'roadmap_exhausted_vision_open')) {
+      nextActions.push({ command, reason, type: 'roadmap_exhausted_vision_open' });
+    }
+  }
+}
+
 function renderConnectorHealthStatus(connectorHealth) {
   const connectors = Array.isArray(connectorHealth?.connectors)
     ? connectorHealth.connectors

package/src/lib/continuous-run.js

@@ -15,6 +15,8 @@ import { randomUUID } from 'node:crypto';
 import {
   resolveVisionPath,
   deriveVisionCandidates,
+  deriveRoadmapCandidates,
+  detectRoadmapExhaustedVisionOpen,
   captureVisionHeadingsSnapshot,
   computeVisionContentSha,
   buildSourceManifest,
@@ -29,7 +31,7 @@ import {
   resolveIntent,
   buildVisionIdleExpansionSignal,
 } from './intake.js';
-import { loadProjectState } from './config.js';
+import { loadProjectContext, loadProjectState } from './config.js';
 import { safeWriteJson } from './safe-write.js';
 import { emitRunEvent } from './run-events.js';
 import { reissueTurn } from './governed-state.js';
@@ -52,6 +54,15 @@ import {
 
 const CONTINUOUS_SESSION_PATH = '.agentxchain/continuous-session.json';
 
+function getRoadmapReplenishmentTriageHints(root) {
+  const context = loadProjectContext(root);
+  const config = context?.config || null;
+  return {
+    preferred_role: config?.roles?.pm ? 'pm' : null,
+    phase_scope: config?.routing?.planning ? 'planning' : null,
+  };
+}
+
 // ---------------------------------------------------------------------------
 // Session state
 // ---------------------------------------------------------------------------
@@ -644,12 +655,142 @@ function reconcileContinuousStartupState(context, session, contOpts, log) {
  * @returns {{ ok: boolean, intentId?: string, section?: string, goal?: string, error?: string, idle?: boolean }}
  */
 export function seedFromVision(root, visionPath, options = {}) {
+  const roadmapResult = deriveRoadmapCandidates(root);
+  if (!roadmapResult.ok) {
+    return { ok: false, error: roadmapResult.error };
+  }
+
+  if (roadmapResult.candidates.length > 0) {
+    const candidate = roadmapResult.candidates[0];
+    const eventResult = recordEvent(root, {
+      source: 'vision_scan',
+      category: 'roadmap_open_work_detected',
+      signal: {
+        description: `${candidate.section}: ${candidate.goal}`,
+        roadmap_milestone: candidate.section,
+        roadmap_path: candidate.roadmap_path,
+        roadmap_line: candidate.line,
+        derived: true,
+      },
+      evidence: [
+        { type: 'file', value: `${candidate.roadmap_path}:${candidate.line}` },
+        { type: 'text', value: `Unchecked roadmap work: ${candidate.section} — ${candidate.goal}` },
+      ],
+    });
+
+    if (!eventResult.ok) {
+      if (eventResult.deduplicated) {
+        return { ok: true, idle: true };
+      }
+      return { ok: false, error: `intake record failed: ${eventResult.error}` };
+    }
+
+    if (eventResult.deduplicated) {
+      return { ok: true, idle: true };
+    }
+
+    const intentId = eventResult.intent.intent_id;
+    const triageResult = triageIntent(root, intentId, {
+      priority: candidate.priority,
+      template: 'generic',
+      charter: `[roadmap] ${candidate.section}: ${candidate.goal}`,
+      acceptance_contract: [
+        `Roadmap milestone addressed: ${candidate.section}`,
+        `Unchecked roadmap item completed: ${candidate.goal}`,
+        `Evidence source: ${candidate.roadmap_path}:${candidate.line}`,
+      ],
+    });
+
+    if (!triageResult.ok) {
+      return { ok: false, error: `triage failed: ${triageResult.error}` };
+    }
+
+    const triageApproval = options.triageApproval || 'auto';
+    if (triageApproval === 'auto') {
+      const approveResult = approveIntent(root, intentId, {
+        approver: 'continuous_loop',
+        reason: 'roadmap-open-work auto-approval',
+      });
+      if (!approveResult.ok) {
+        return { ok: false, error: `approve failed: ${approveResult.error}` };
+      }
+    }
+
+    return {
+      ok: true,
+      idle: false,
+      intentId,
+      section: candidate.section,
+      goal: candidate.goal,
+      source: candidate.source,
+      roadmap_path: candidate.roadmap_path,
+      roadmap_line: candidate.line,
+    };
+  }
+
   const result = deriveVisionCandidates(root, visionPath);
   if (!result.ok) {
     return { ok: false, error: result.error };
   }
 
   if (result.candidates.length === 0) {
+    // BUG-77: Before declaring idle, check if roadmap is exhausted but VISION
+    // has unplanned scope. If so, seed a PM roadmap-replenishment intent to
+    // derive the next bounded milestone instead of idle-exiting.
+    const exhaustion = detectRoadmapExhaustedVisionOpen(root, visionPath);
+    if (exhaustion.open) {
+      const sectionNames = exhaustion.unplanned_sections.join(', ');
+      const replenishmentEvent = recordEvent(root, {
+        source: 'vision_scan',
+        category: 'roadmap_exhausted_vision_open',
+        signal: {
+          description: `Roadmap exhausted (${exhaustion.total_milestones} milestones checked through ${exhaustion.latest_milestone}). VISION.md has unplanned scope: ${sectionNames}`,
+          unplanned_sections: exhaustion.unplanned_sections,
+          latest_milestone: exhaustion.latest_milestone,
+          derived: true,
+        },
+        evidence: [
+          { type: 'text', value: `All ${exhaustion.total_milestones} roadmap milestones checked. VISION sections not yet planned: ${sectionNames}` },
+        ],
+      });
+
+      if (replenishmentEvent.ok && !replenishmentEvent.deduplicated) {
+        const replenishmentIntentId = replenishmentEvent.intent.intent_id;
+        const replenishmentHints = getRoadmapReplenishmentTriageHints(root);
+        const triageResult = triageIntent(root, replenishmentIntentId, {
+          priority: 'p1',
+          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.`,
+          acceptance_contract: [
+            `New unchecked milestone items added to .planning/ROADMAP.md`,
+            `Milestone scope derived from VISION.md sections: ${sectionNames}`,
+            `Milestone is bounded, testable, and does not duplicate existing checked milestones`,
+          ],
+        });
+
+        if (triageResult.ok) {
+          const triageApproval = options.triageApproval || 'auto';
+          if (triageApproval === 'auto') {
+            approveIntent(root, replenishmentIntentId, {
+              approver: 'continuous_loop',
+              reason: 'roadmap-replenishment auto-approval (BUG-77)',
+            });
+          }
+
+          return {
+            ok: true,
+            idle: false,
+            intentId: replenishmentIntentId,
+            section: 'Roadmap replenishment',
+            goal: `Derive next increment from: ${sectionNames}`,
+            source: 'roadmap_replenishment',
+          };
+        }
+      }
+      // If deduplicated or triage failed, fall through to idle
+    }
     return { ok: true, idle: true };
   }
 
@@ -714,6 +855,7 @@ export function seedFromVision(root, visionPath, options = {}) {
     intentId,
     section: candidate.section,
     goal: candidate.goal,
+    source: 'vision_scan',
   };
 }
 
@@ -1443,6 +1585,7 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
     : findNextDispatchableIntent(root, { run_id: session.current_run_id });
   let targetIntentId = null;
   let visionObjective = null;
+  let seededSource = null;
 
   if (queued.ok) {
     targetIntentId = queued.intentId;
@@ -1478,13 +1621,24 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
 
     targetIntentId = seeded.intentId;
     visionObjective = `${seeded.section}: ${seeded.goal}`;
+    seededSource = seeded.source || 'vision_scan';
     session.idle_cycles = 0;
-    log(`Vision-derived: ${visionObjective}`);
+    if (seeded.source === 'roadmap_open_work') {
+      log(`Roadmap-derived: ${visionObjective}`);
+    } else if (seeded.source === 'roadmap_replenishment') {
+      log(`Roadmap-replenishment (roadmap exhausted, vision open): ${visionObjective}`);
+    } else {
+      log(`Vision-derived: ${visionObjective}`);
+    }
   }
 
   // Prepare intent through intake lifecycle
   const provenance = buildContinuousProvenance(targetIntentId, {
-    trigger: visionObjective ? 'vision_scan' : 'intake',
+    trigger: visionObjective
+      ? (seededSource === 'roadmap_open_work' ? 'roadmap_open_work'
+        : seededSource === 'roadmap_replenishment' ? 'roadmap_replenishment'
+        : 'vision_scan')
+      : 'intake',
     triggerReason: visionObjective || readIntent(root, targetIntentId)?.charter || null,
   });
   const preparedIntent = prepareIntentForDispatch(root, targetIntentId, {
@@ -1519,7 +1673,9 @@ export async function advanceContinuousRunOnce(context, session, contOpts, execu
         next_objective: nextObjective,
         next_intent_id: targetIntentId,
         runs_completed: session.runs_completed || 0,
-        trigger: visionObjective ? 'vision_scan' : 'intake',
+        trigger: visionObjective
+          ? (seededSource === 'roadmap_open_work' ? 'roadmap_open_work' : 'vision_scan')
+          : 'intake',
       },
     });
   }

package/src/lib/vision-reader.js

@@ -217,6 +217,68 @@ export function deriveVisionCandidates(root, visionPath) {
   return { ok: true, candidates };
 }
 
+/**
+ * Derive concrete candidates from unchecked roadmap milestones.
+ *
+ * This is intentionally narrower than VISION.md derivation: a roadmap item is
+ * already PM-shaped product scope, so continuous mode must treat it as work
+ * before falling back to broad vision inference.
+ *
+ * @param {string} root - Project root
+ * @param {string} [roadmapPath] - Project-relative roadmap path
+ * @returns {{ ok: boolean, candidates: Array<{ section: string, goal: string, priority: string, source: string, roadmap_path: string, line: number }>, error?: string }}
+ */
+export function deriveRoadmapCandidates(root, roadmapPath = '.planning/ROADMAP.md') {
+  const absPath = isAbsolute(roadmapPath) ? roadmapPath : pathResolve(root, roadmapPath);
+  if (!existsSync(absPath)) {
+    return { ok: true, candidates: [] };
+  }
+
+  let content;
+  try {
+    content = readFileSync(absPath, 'utf8');
+  } catch (err) {
+    return { ok: false, candidates: [], error: `Cannot read ROADMAP.md: ${err.message}` };
+  }
+
+  const activeSignals = loadActiveIntentSignals(root);
+  const completedSignals = loadCompletedIntentSignals(root);
+  const allSignals = [...activeSignals, ...completedSignals];
+
+  const candidates = [];
+  let currentMilestone = null;
+  const lines = content.split('\n');
+
+  for (let i = 0; i < lines.length; i += 1) {
+    const line = lines[i];
+    const headingMatch = line.match(/^#{2,6}\s+(M\d+\b.*)$/i);
+    if (headingMatch) {
+      currentMilestone = headingMatch[1].trim();
+      continue;
+    }
+
+    const uncheckedMatch = line.match(/^\s*[-*]\s+\[\s\]\s+(.+?)\s*$/);
+    if (!uncheckedMatch || !currentMilestone) continue;
+
+    const goal = uncheckedMatch[1].trim();
+    const combinedGoal = `${currentMilestone}: ${goal}`;
+    if (isGoalAddressed(combinedGoal, allSignals) || isGoalAddressed(goal, allSignals)) {
+      continue;
+    }
+
+    candidates.push({
+      section: currentMilestone,
+      goal,
+      priority: 'p1',
+      source: 'roadmap_open_work',
+      roadmap_path: roadmapPath,
+      line: i + 1,
+    });
+  }
+
+  return { ok: true, candidates };
+}
+
 // ---------------------------------------------------------------------------
 // Vision snapshot capture (BUG-60 Slice 3)
 // ---------------------------------------------------------------------------
@@ -380,6 +442,128 @@ function truncatePreview(content, capBytes) {
   return head + marker + tail;
 }
 
+/**
+ * Detect whether the roadmap is exhausted but VISION.md still has unplanned scope.
+ *
+ * BUG-77: When all ROADMAP.md milestones are checked and no M<n+1> exists,
+ * but VISION.md has sections with goals that are NOT mapped to any roadmap
+ * milestone, continuous mode should dispatch PM to derive the next bounded
+ * roadmap increment — not declare idle_exit or vision_exhausted.
+ *
+ * @param {string} root - Project root
+ * @param {string} visionPath - Absolute path to VISION.md
+ * @param {string} [roadmapPath] - Project-relative roadmap path
+ * @returns {{ open: boolean, reason: string, unplanned_sections?: string[], mapped_sections?: string[], total_milestones?: number, latest_milestone?: string, evidence_map?: Array<{ milestone: string, status: string }> }}
+ */
+export function detectRoadmapExhaustedVisionOpen(root, visionPath, roadmapPath = '.planning/ROADMAP.md') {
+  const absRoadmap = isAbsolute(roadmapPath) ? roadmapPath : pathResolve(root, roadmapPath);
+  const absVision = isAbsolute(visionPath) ? visionPath : pathResolve(root, visionPath);
+
+  // If no roadmap, cannot be "exhausted"
+  if (!existsSync(absRoadmap)) {
+    return { open: false, reason: 'no_roadmap' };
+  }
+
+  let roadmapContent;
+  try {
+    roadmapContent = readFileSync(absRoadmap, 'utf8');
+  } catch {
+    return { open: false, reason: 'roadmap_unreadable' };
+  }
+
+  // Parse milestone headings and check for unchecked items
+  const milestoneHeadings = [];
+  let currentMilestone = null;
+  let hasUnchecked = false;
+
+  for (const line of roadmapContent.split('\n')) {
+    const hm = line.match(/^#{2,6}\s+(M\d+\b.*)$/i);
+    if (hm) {
+      currentMilestone = hm[1].trim();
+      milestoneHeadings.push(currentMilestone);
+      continue;
+    }
+    if (currentMilestone && /^\s*[-*]\s+\[\s\]/.test(line)) {
+      hasUnchecked = true;
+    }
+  }
+
+  // Not exhausted if unchecked work exists (BUG-76 handles this)
+  if (hasUnchecked) {
+    return { open: false, reason: 'has_unchecked' };
+  }
+  // No milestones at all — not a milestone-based roadmap
+  if (milestoneHeadings.length === 0) {
+    return { open: false, reason: 'no_milestones' };
+  }
+
+  // Roadmap IS exhausted (all milestones checked, none unchecked). Check VISION.
+  if (!existsSync(absVision)) {
+    return {
+      open: false,
+      reason: 'no_vision',
+      evidence_map: milestoneHeadings.map(m => ({ milestone: m, status: 'completed' })),
+    };
+  }
+
+  let visionContent;
+  try {
+    visionContent = readFileSync(absVision, 'utf8');
+  } catch {
+    return { open: false, reason: 'vision_unreadable' };
+  }
+
+  const { sections } = parseVisionDocument(visionContent);
+  const sectionsWithGoals = sections.filter(s => s.goals.length > 0);
+
+  if (sectionsWithGoals.length === 0) {
+    return {
+      open: false,
+      reason: 'vision_no_actionable_scope',
+      evidence_map: milestoneHeadings.map(m => ({ milestone: m, status: 'completed' })),
+    };
+  }
+
+  // Check which VISION sections are NOT mapped to any roadmap milestone heading
+  const unplanned = [];
+  const mapped = [];
+
+  for (const section of sectionsWithGoals) {
+    const sectionWords = extractSignificantWords(section.heading);
+    const isMapped = milestoneHeadings.some(m => {
+      const milestoneWords = extractSignificantWords(m);
+      if (sectionWords.length === 0 || milestoneWords.length === 0) return false;
+      const overlap = sectionWords.filter(w =>
+        milestoneWords.some(mw => mw.includes(w) || w.includes(mw)),
+      ).length;
+      return overlap / sectionWords.length >= 0.4;
+    });
+    if (isMapped) {
+      mapped.push(section.heading);
+    } else {
+      unplanned.push(section.heading);
+    }
+  }
+
+  if (unplanned.length > 0) {
+    return {
+      open: true,
+      reason: 'roadmap_exhausted_vision_open',
+      unplanned_sections: unplanned,
+      mapped_sections: mapped,
+      total_milestones: milestoneHeadings.length,
+      latest_milestone: milestoneHeadings[milestoneHeadings.length - 1],
+    };
+  }
+
+  return {
+    open: false,
+    reason: 'vision_fully_mapped',
+    evidence_map: milestoneHeadings.map(m => ({ milestone: m, status: 'completed' })),
+    mapped_sections: mapped,
+  };
+}
+
 /**
  * Resolve a vision path relative to the project root.
  *