pan-wizard 3.33.0 → 3.35.0

package/pan-wizard-core/bin/lib/roadmap.cjs

@@ -4,9 +4,9 @@
 
 const fs = require('fs');
 const path = require('path');
-const { PHASES_DIR, ROADMAP_FILE, REQUIREMENTS_FILE, isPlanFile, isSummaryFile, isContextFile, isResearchFile, PHASE_HEADER_RE, getPlanId, getSummaryId } = require('./constants.cjs');
-const { planningPath, phasesPath, filterPlanFiles, filterSummaryFiles, classifyPhaseStatus } = require('./utils.cjs');
-const { escapeRegex, normalizePhaseName, output, error, findPhaseInternal } = require('./core.cjs');
+const { PHASES_DIR, ROADMAP_FILE, REQUIREMENTS_FILE, ROADMAP_SLICE_SUFFIX, isPlanFile, isSummaryFile, isContextFile, isResearchFile, PHASE_HEADER_RE, getPlanId, getSummaryId } = require('./constants.cjs');
+const { planningPath, planningRel, phasesPath, filterPlanFiles, filterSummaryFiles, classifyPhaseStatus } = require('./utils.cjs');
+const { escapeRegex, normalizePhaseName, output, error, findPhaseInternal, safeReadFile, toLf, dominantEol, withEol } = require('./core.cjs');
 
 /**
  * Extract a single phase section from roadmap.md including goal and success criteria.
@@ -21,8 +21,8 @@ function cmdRoadmapGetPhase(cwd, phaseNum, raw) {
   try {
     const content = fs.readFileSync(roadmapPath, 'utf-8');
 
-    // Escape special regex chars in phase number, handle decimal
-    const escapedPhase = escapeRegex(phaseNum);
+    // Padded or not: `init` hands workflows "05", roadmaps write "Phase 5:".
+    const escapedPhase = phaseNumRe(phaseNum);
 
     // Match "## Phase X:", "### Phase X:", or "#### Phase X:" with optional name
     const phasePattern = new RegExp(
@@ -65,7 +65,12 @@ function cmdRoadmapGetPhase(cwd, phaseNum, raw) {
       ? headerIndex + nextHeaderMatch.index
       : content.length;
 
-    const section = content.slice(headerIndex, sectionEnd).trim();
+    let section = content.slice(headerIndex, sectionEnd).trim();
+
+    // A phase moved out by `roadmap compact` leaves a stub here; its success
+    // criteria and the rest of its section are in roadmap-history.md.
+    const compacted = require('./roadmap-compact.cjs').compactedPhaseSection(cwd, phaseNum, section);
+    if (compacted && compacted.section) section = compacted.section;
 
     // Extract goal if present
     const goalMatch = section.match(/(?:\*\*Goal:\*\*|\*\*Goal\*\*:)\s*([^\n]+)/i);
@@ -85,6 +90,7 @@ function cmdRoadmapGetPhase(cwd, phaseNum, raw) {
         goal,
         success_criteria,
         section,
+        ...(compacted ? { compacted: true, history_path: compacted.history_path, history_found: compacted.history_found } : {}),
       },
       raw,
       section
@@ -346,7 +352,7 @@ const isSeparator = (line) => /^\s*\|(?:\s*:?-{3,}:?\s*\|)+\s*$/.test(line);
 function updateProgressTableRow(content, phaseNum, values) {
   const eol = content.includes('\r\n') ? '\r\n' : '\n';
   const lines = content.split(/\r?\n/);
-  const phaseRe = new RegExp(`^(?:phase\\s+)?${escapeRegex(String(phaseNum))}\\.?(?=\\s|:|$)`, 'i');
+  const phaseRe = new RegExp(`^(?:phase\\s+)?${phaseNumRe(phaseNum)}\\.?(?=\\s|:|$)`, 'i');
   let reason = null;
   for (let i = 0; i + 1 < lines.length; i++) {
     if (!isTableLine(lines[i]) || !isSeparator(lines[i + 1])) continue;
@@ -377,7 +383,7 @@ function updateProgressTableRow(content, phaseNum, values) {
 /** Rewrite `**Plans:**` inside the phase's own section only. Pure. */
 function updatePhasePlansLine(content, phaseNum, text) {
   const lines = content.split(/(?<=\n)/);
-  const headRe = new RegExp(`^(#{2,4})\\s*Phase\\s+${escapeRegex(String(phaseNum))}(?=[\\s:.]|$)`, 'i');
+  const headRe = new RegExp(`^(#{2,4})\\s*Phase\\s+${phaseNumRe(phaseNum)}(?=[\\s:.]|$)`, 'i');
   const start = lines.findIndex((l) => headRe.test(l));
   if (start < 0) return { content, updated: false };
   const level = lines[start].match(headRe)[1].length;
@@ -426,7 +432,9 @@ function cmdRoadmapUpdatePlanProgress(cwd, phaseNum, raw) {
     output({ updated: false, reason: 'roadmap.md not found', error: 'roadmap_not_found', plan_count: planCount, summary_count: summaryCount }, raw, 'no roadmap');
     return;
   }
-  const phaseEscaped = escapeRegex(phaseNum);
+  // Padded or not: the executor passes init's "05" for a `Phase 5` roadmap, and
+  // every lookup below used to miss it while the result still said `updated: true`.
+  const phaseEscaped = phaseNumRe(phaseNum);
 
   // Progress table row: the Plans, Status and Completed cells, found by header.
   const table = updateProgressTableRow(roadmapContent, phaseNum, {
@@ -530,14 +538,240 @@ function syncRequirementCheckboxes(cwd, requirementIds) {
   return { updated: checked > 0, checked, total: requirementIds.length };
 }
 
+// ─── Phase slice (memory optimisation O2) ────────────────────────────────────
+//
+// What work on ONE phase needs from roadmap.md and requirements.md: a one-line
+// index of every phase, this phase's section, the goals of the phases it depends
+// on, and the requirement lines it names. The planner, the plan checker, the
+// researcher, the executors (through the plan's <context>) and the verifier read
+// this instead of the whole files. Measured on the field installs (2026-10-04):
+// 89–98% smaller; a 54-phase project went from ~146k tokens to ~3k, and those
+// whole files had been re-read on every turn of every spawn that listed them.
+
+/** Phase numbers compare without zero padding: "03" and "3" are one phase. */
+const unpadPhase = (n) => String(n).trim().replace(/^0+(?=\d)/, '');
+
+/** A phase number as a regex source matching it padded or not ("05" finds `Phase 5:` and `Phase 05:`). */
+const phaseNumRe = (n) => `0*${escapeRegex(unpadPhase(n))}`;
+
+/**
+ * Requirement ids on a phase section's `**Requirements**:` line. Taken by shape,
+ * not by splitting on commas: field roadmaps write prose there ("none of its own;
+ * pulled forward from Phase 45 (`CI-01`)…", "seeding (replace …), TEST-01 (…)").
+ * An id is a `CAT-01`-style token anywhere on the line, or a comma-separated item
+ * that is a single token carrying a digit (`R1`, `REQ001`).
+ */
+function phaseRequirementIds(section) {
+  const m = String(section || '').match(/^\*\*Requirements\*\*:[^\S\n]*([^\n]*)$/m)
+    || String(section || '').match(/^\*\*Requirements:\*\*[^\S\n]*([^\n]*)$/m);
+  if (!m) return [];
+  const line = m[1].replace(/[[\]`]/g, ' ');
+  const shaped = line.match(/\b[A-Z][A-Z0-9]*(?:-[A-Z][A-Z0-9]*)*-\d+[A-Za-z]?\b/g) || [];
+  const tokens = line.split(',').map(s => s.trim()).filter(s => /^[A-Za-z][A-Za-z0-9._-]*\d[A-Za-z0-9._-]*$/.test(s));
+  return [...new Set([...shaped, ...tokens])];
+}
+
+/** Phase numbers on a section's `**Depends on**:` line ("Phase 2, Phase 2.1" → ['2', '2.1']). */
+function phaseDependencies(section) {
+  const m = String(section || '').match(/(?:\*\*Depends on:\*\*|\*\*Depends on\*\*:)\s*([^\n]+)/i);
+  if (!m) return [];
+  return [...new Set([...m[1].matchAll(/\bPhase\s+(\d+[A-Z]?(?:\.\d+)*)/gi)].map(x => unpadPhase(x[1])))];
+}
+
+/** A phase's section in roadmap.md content, or null. Mirrors getRoadmapPhaseInternal. */
+function roadmapPhaseSection(content, phaseNum) {
+  const escaped = escapeRegex(unpadPhase(phaseNum));
+  const header = content.match(new RegExp(`#{2,4}\\s*Phase\\s+0*${escaped}:\\s*([^\\n]+)`, 'i'));
+  if (!header) return null;
+  const rest = content.slice(header.index);
+  const next = rest.match(/\n#{2,4}\s+Phase\s+\d/i);
+  const section = content.slice(header.index, next ? header.index + next.index : content.length).trim();
+  return { name: header[1].trim(), section };
+}
+
+/**
+ * The requirement ids roadmap.md names for one phase: from its own `### Phase N:`
+ * section, else from a `**Requirements:**` line under its checklist entry, before
+ * the next "Phase <n>" (the layout older roadmaps use). `phase complete` and
+ * `validate health --repair` read them here: their own search took the first
+ * Requirements line after the first "Phase N" anywhere, which on the template's
+ * layout (checklist above the sections) was phase 1's, and matched "05" to nothing.
+ */
+function roadmapRequirementIds(content, phaseNum) {
+  const text = String(content || '');
+  const sec = roadmapPhaseSection(text, phaseNum);
+  if (sec) return phaseRequirementIds(sec.section);
+  const start = text.search(new RegExp(`Phase\\s+${phaseNumRe(phaseNum)}(?![\\d.])`, 'i'));
+  if (start < 0) return [];
+  const rest = text.slice(start);
+  const next = rest.slice(1).search(/Phase\s+\d/i);
+  const span = next < 0 ? rest : rest.slice(0, next + 1);
+  return phaseRequirementIds(span.replace(/^[ \t]+(?=\*\*Requirements)/gm, ''));
+}
+
+/** Lines of requirements.md that name one of `ids`, each with its indented continuation. */
+function requirementLines(requirements, ids) {
+  const lines = String(requirements || '').split('\n');
+  const pick = new Set();
+  const found = new Set();
+  const patterns = ids.map(id => ({ id, re: new RegExp(`(^|[^A-Za-z0-9_-])${escapeRegex(id)}(?![A-Za-z0-9_-])`) }));
+  lines.forEach((line, i) => {
+    const hits = patterns.filter(p => p.re.test(line));
+    if (!hits.length) return;
+    for (const h of hits) found.add(h.id);
+    pick.add(i);
+    // A list item keeps its detail: the lines after it indented deeper than it.
+    if (/^\s*[-*]\s/.test(line)) {
+      const indent = line.length - line.trimStart().length;
+      for (let j = i + 1; j < lines.length; j++) {
+        const l = lines[j];
+        if (!l.trim() || l.length - l.trimStart().length <= indent) break;
+        pick.add(j);
+      }
+    }
+  });
+  // A picked table row keeps its table's header and separator, so it still reads as a table.
+  for (const i of [...pick]) {
+    if (!/^\s*\|/.test(lines[i])) continue;
+    let top = i;
+    while (top > 0 && /^\s*\|/.test(lines[top - 1])) top--;
+    if (top < i) pick.add(top);
+    if (top + 1 < i && /^\s*\|[\s:|-]+\|\s*$/.test(lines[top + 1])) pick.add(top + 1);
+  }
+  return { lines: [...pick].sort((a, b) => a - b).map(i => lines[i]), missing: ids.filter(id => !found.has(id)) };
+}
+
+/**
+ * Pure: the slice of `roadmap` and `requirements` for one phase.
+ * `history` (roadmap-history.md text, or a function returning it) is consulted only
+ * when the phase's section is a `roadmap compact` stub, to put its full section back.
+ * @param {{roadmap: string, requirements: string|null, phase: string, planningRel?: string,
+ *   history?: string|null|(() => string|null)}} args
+ * @returns {{found: boolean, phase_number: string, phase_name?: string, content?: string,
+ *   requirement_ids?: string[], missing_requirement_ids?: string[], depends_on?: string[],
+ *   tokens?: number, whole_tokens?: number}}
+ */
+function buildRoadmapSlice({ roadmap, requirements, phase, planningRel = '.planning', history = null }) {
+  const rm = toLf(roadmap);
+  const req = requirements == null ? null : toLf(requirements);
+  const target = roadmapPhaseSection(rm, phase);
+  if (!target) return { found: false, phase_number: String(phase) };
+  const { isCompactedSection, archivedPhaseSection } = require('./roadmap-compact.cjs');
+  if (isCompactedSection(target.section)) {
+    const full = archivedPhaseSection(typeof history === 'function' ? history() : history, phase);
+    if (full) target.section = full;
+  }
+
+  const num = unpadPhase(phase);
+  const phases = enumerateRoadmapPhases(rm);
+  // Any one-character box: roadmaps mark work in flight `[~]` or `[-]` as well as `[ ]` / `[x]`.
+  const checklist = rm.split('\n').filter(l => /^\s*-\s*\[[^\]]\]\s*\*\*Phase\s+\d/i.test(l)).map(l => l.trim());
+  const thisLine = new RegExp(`\\*\\*Phase\\s+0*${escapeRegex(num)}\\s*:`, 'i');
+  const index = (checklist.length ? checklist : phases.map(p => `- Phase ${p.number}: ${p.name}`))
+    .map(l => (thisLine.test(l) || new RegExp(`^- Phase 0*${escapeRegex(num)}:`).test(l) ? `${l}  ← this phase` : l));
+
+  const deps = phaseDependencies(target.section);
+  const depLines = deps.map(d => {
+    const p = phases.find(x => unpadPhase(x.number) === d);
+    return p ? `- **Phase ${p.number}: ${p.name}** — ${p.goal || 'no goal line in roadmap.md'}` : `- **Phase ${d}** — not found in roadmap.md`;
+  });
+
+  const ids = phaseRequirementIds(target.section);
+  let reqBody;
+  let missing = [];
+  if (req == null) reqBody = `_There is no \`${planningRel}/requirements.md\`._`;
+  else if (!ids.length) reqBody = '_The roadmap names no requirement ids for this phase._';
+  else {
+    const r = requirementLines(req, ids);
+    missing = r.missing;
+    reqBody = (r.lines.length ? r.lines.join('\n') : '') + (missing.length ? `${r.lines.length ? '\n\n' : ''}_Not found in requirements.md: ${missing.join(', ')}._` : '');
+  }
+
+  const content = [
+    `# Roadmap slice — Phase ${num}: ${target.name}`,
+    '',
+    `Generated by \`pan-tools roadmap slice ${num}\` from \`${planningRel}/roadmap.md\` and \`${planningRel}/requirements.md\`. It holds what work on this phase needs from those files; read the whole files only for something it leaves out.`,
+    '',
+    '## Every phase',
+    '',
+    ...index,
+    '',
+    '## This phase',
+    '',
+    target.section,
+    '',
+    '## Phases it depends on',
+    '',
+    ...(depLines.length ? depLines : ['_None._']),
+    '',
+    '## Its requirements',
+    '',
+    reqBody,
+    '',
+  ].join('\n');
+
+  return {
+    found: true,
+    phase_number: num,
+    phase_name: target.name,
+    requirement_ids: ids,
+    missing_requirement_ids: missing,
+    depends_on: deps,
+    content,
+    tokens: Math.ceil(content.length / 4),
+    whole_tokens: Math.ceil((rm.length + (req || '').length) / 4),
+  };
+}
+
+/**
+ * `roadmap slice <phase> [--write]` — the phase's slice; `--write` puts it at
+ * `<phase dir>/<NN>-roadmap-slice.md` (the path the plan template's <context> names)
+ * and prints the path and sizes.
+ */
+function cmdRoadmapSlice(cwd, phase, opts, raw) {
+  const roadmap = safeReadFile(path.join(planningPath(cwd), ROADMAP_FILE));
+  if (roadmap == null) { output({ found: false, error: 'roadmap.md not found' }, raw, ''); return; }
+  const requirements = safeReadFile(path.join(planningPath(cwd), REQUIREMENTS_FILE));
+  const history = () => safeReadFile(path.join(planningPath(cwd), require('./roadmap-compact.cjs').ROADMAP_HISTORY_FILE));
+  const slice = buildRoadmapSlice({ roadmap, requirements, phase, planningRel: planningRel(), history });
+  if (!slice.found) { output(slice, raw, ''); return; }
+  const summary = {
+    found: true, phase_number: slice.phase_number, phase_name: slice.phase_name,
+    requirement_ids: slice.requirement_ids, missing_requirement_ids: slice.missing_requirement_ids,
+    depends_on: slice.depends_on, tokens: slice.tokens, whole_tokens: slice.whole_tokens,
+    smaller_pct: slice.whole_tokens ? Math.round(100 * (1 - slice.tokens / slice.whole_tokens)) : 0,
+  };
+  if (!opts || !opts.write) { output({ ...summary, content: slice.content }, raw, slice.content); return; }
+
+  const dir = findPhaseInternal(cwd, phase);
+  if (!dir || !dir.directory) {
+    output({ ...summary, written: false, reason: 'no phase directory yet — create it first, or read the whole files' }, raw, '');
+    return;
+  }
+  const rel = `${dir.directory}/${normalizePhaseName(phase)}${ROADMAP_SLICE_SUFFIX}`;
+  const abs = path.join(cwd, rel);
+  // Same bytes in the file's own line ending, and no write when nothing changed,
+  // so regenerating at each workflow start leaves git alone.
+  const existing = safeReadFile(abs);
+  const next = withEol(slice.content, existing == null ? '\n' : dominantEol(existing));
+  if (existing !== next) fs.writeFileSync(abs, next, 'utf-8');
+  output({ ...summary, written: true, changed: existing !== next, path: rel }, raw, rel);
+}
+
 module.exports = {
   cmdRoadmapGetPhase,
   cmdRoadmapAnalyze,
   cmdRoadmapUpdatePlanProgress,
+  cmdRoadmapSlice,
   syncRequirementCheckboxes,
   // Exported for testability
   enumerateRoadmapPhases,
   enrichPhaseWithDiskStatus,
   extractMilestones,
   computeRoadmapStats,
+  buildRoadmapSlice,
+  roadmapRequirementIds,
+  phaseRequirementIds,
+  phaseDependencies,
+  ROADMAP_SLICE_SUFFIX,
 };

package/pan-wizard-core/bin/lib/runner.cjs

@@ -38,7 +38,8 @@ const { getExperimentManifest, PAN_EXPERIMENTS_ROOT_DEFAULT } = require('./exper
  * shell: 'win32' — they default to direct spawn, which suits test mocks like
  * `node -e '...'` that are resolvable directly. P-102 fix (v3.7.1).
  *
- * GitHub Copilot CLI has no documented headless prompt mode, so it's null.
+ * GitHub Copilot CLI is null: no adapter is written yet, although `copilot -p`
+ * runs a prompt headless (the PAN Harness drives it that way).
  */
 // P-1302 fix (v3.7.2): autonomous claude/gemini runs default to non-interactive
 // permissions. Without these flags, the CLI prompts for tool approval, which

package/pan-wizard-core/bin/lib/state-compact.cjs

@@ -26,7 +26,7 @@
 
 const fs = require('fs');
 const path = require('path');
-const { output, error } = require('./core.cjs');
+const { output, error, dominantEol, withEol } = require('./core.cjs');
 const {
   STATE_FILE,
   STATE_HISTORY_FILE,
@@ -210,9 +210,13 @@ function planStateCompaction(cwd, opts = {}) {
   // Build the post-compaction text for real rather than estimating it. An
   // estimate that ignores pointer overhead can claim a saving on a file where
   // the pointers cost more than the sections they replace — a dry-run that
-  // overstates its own benefit is worse than no dry-run.
+  // overstates its own benefit is worse than no dry-run. The rebuild comes back
+  // LF and writeStateMd restores the file's own ending on disk, so measure it in
+  // that ending too: on a CRLF file the LF rebuild otherwise "saved" a byte per
+  // line, and a compaction that archived nothing still reported tokens saved.
   const stamp = new Date(now).toISOString().slice(0, 10);
-  let bytesAfter = rebuildState(content, new Set(archivable.map(v => v.title)), stamp).length;
+  const eol = dominantEol(content);
+  let bytesAfter = withEol(rebuildState(content, new Set(archivable.map(v => v.title)), stamp), eol).length;
 
   // The point of compaction is a smaller re-read on every agent call. On a file
   // whose history sections are tiny, the pointers left behind cost more than the
@@ -291,14 +295,15 @@ function compactState(cwd, opts = {}) {
   const { writeStateMd } = require('./state.cjs');
   writeStateMd(statePath, next, cwd);
 
+  const onDisk = withEol(next, dominantEol(content));
   return {
     ...plan,
     applied: true,
     dry_run: false,
     archived: plan.archivable.map(v => v.title),
-    bytes_after: next.length,
-    tokens_after: Math.ceil(next.length / CHARS_PER_TOKEN),
-    tokens_saved_per_call: Math.max(0, Math.ceil((plan.bytes_before - next.length) / CHARS_PER_TOKEN)),
+    bytes_after: onDisk.length,
+    tokens_after: Math.ceil(onDisk.length / CHARS_PER_TOKEN),
+    tokens_saved_per_call: Math.max(0, Math.ceil((plan.bytes_before - onDisk.length) / CHARS_PER_TOKEN)),
   };
 }
 

package/pan-wizard-core/bin/lib/state.cjs

@@ -294,22 +294,22 @@ function cmdStateRecordMetric(cwd, options, raw) {
     return;
   }
 
-  // Find Performance Metrics section and its table
-  const metricsPattern = /(##\s*Performance Metrics[\s\S]*?\n\|[^\n]+\n\|[-|\s]+\n)([\s\S]*?)(?=\n##|\n$|$)/i;
+  // The Performance Metrics section's first table: its rows only, then an optional
+  // "None yet" line. Taking the rest of the section as the table body put every row
+  // below the template's "Recent Trend" and footer lines, outside the table. The
+  // separator is matched on one line: `[-|\s]+` ran on into a `| - | - |` row.
+  const metricsPattern = /(##\s*Performance Metrics[\s\S]*?\n\|[^\n]+\n\|[-|: \t]+\r?\n)((?:\|[^\n]*(?:\n|$))*)((?:[^\S\n]*None yet\.?[^\S\n]*(?:\n|$))?)/i;
   const metricsMatch = content.match(metricsPattern);
 
   if (metricsMatch) {
-    let tableBody = metricsMatch[2].trimEnd();
     const cell = escapeTableCell;
     const newRow = `| Phase ${cell(phase)} P${cell(plan)} | ${cell(duration)} | ${cell(tasks || '-')} tasks | ${cell(files || '-')} files |`;
+    // A template placeholder row (`| - | - | - | - |`, `| None yet | | | |`) gives way.
+    const isPlaceholder = (row) => /None yet/i.test(row) || row.split('|').slice(1, -1).every((c) => /^\s*-?\s*$/.test(c));
+    const rows = metricsMatch[2].split('\n').map((r) => r.replace(/\r$/, '')).filter((r) => r.trim() && !isPlaceholder(r));
+    rows.push(newRow);
 
-    if (tableBody.trim() === '' || tableBody.includes('None yet')) {
-      tableBody = newRow;
-    } else {
-      tableBody = tableBody + '\n' + newRow;
-    }
-
-    content = content.replace(metricsPattern, (_match, header) => `${header}${tableBody}\n`);
+    content = content.replace(metricsPattern, (_match, header) => `${header}${rows.join('\n')}\n`);
     writeStateMd(statePath, content, cwd);
     output({ recorded: true, phase, plan, duration }, raw, 'true');
   } else {
@@ -432,7 +432,8 @@ function cmdStateAddBlocker(cwd, text, raw) {
 
   if (match) {
     let sectionBody = match[2];
-    sectionBody = sectionBody.replace(/None\.?\s*\n?/gi, '').replace(/None yet\.?\s*\n?/gi, '');
+    // "None yet" first: stripping "None" first left a stray "yet." on the template.
+    sectionBody = sectionBody.replace(/None yet\.?\s*\n?/gi, '').replace(/None\.?\s*\n?/gi, '');
     sectionBody = sectionBody.trimEnd() + '\n' + entry + '\n';
     content = content.replace(sectionPattern, (_match, header) => `${header}${sectionBody}`);
     writeStateMd(statePath, content, cwd);
@@ -538,14 +539,23 @@ function cmdStateRecordSession(cwd, options, raw) {
 // --- Snapshot Parsers --------------------------------------------------------
 
 /**
- * Parse the Decisions Made table from state.md content.
- * Extracts rows from a markdown table under the "## Decisions Made" heading,
- * splitting each row into phase, summary, and rationale cells.
+ * Parse the decisions from state.md content: the `- [Phase N]: summary — rationale`
+ * bullets `state add-decision` appends under `### Decisions` (the template's
+ * heading), or else an older "## Decisions Made" table. Reading only the table
+ * left `decisions` empty on every state.md PAN itself writes.
  * @param {string} content - Full state.md content
  * @returns {Array<{phase: string, summary: string, rationale: string}>}
  */
 function parseDecisionsFromState(content) {
   const decisions = [];
+  const section = content.match(/###?\s*(?:Decisions|Decisions Made|Accumulated.*Decisions)\s*\n([\s\S]*?)(?=\n###?|\n##[^#]|$)/i);
+  for (const line of section ? section[1].split('\n') : []) {
+    const m = line.match(/^-\s+\[Phase\s+([^\]]*)\]:\s*(.+?)\s*$/i);
+    if (!m) continue;
+    const [summary, ...rest] = m[2].split(' — ');
+    decisions.push({ phase: m[1].trim(), summary: summary.trim(), rationale: rest.join(' — ').trim() });
+  }
+  if (decisions.length > 0) return decisions;
   // Match the decisions table body after header row and separator row
   const decisionsMatch = content.match(/##\s*Decisions Made[\s\S]*?\n\|[^\n]+\n\|[-|\s]+\n([\s\S]*?)(?=\n##|\n$|$)/i);
   if (decisionsMatch) {
@@ -567,14 +577,15 @@ function parseDecisionsFromState(content) {
 
 /**
  * Parse the Blockers section from state.md content.
- * Extracts bullet-point items (lines starting with "- ") from under
- * the "## Blockers" heading.
+ * Extracts bullet-point items (lines starting with "- ") from under the heading
+ * `state add-blocker` writes to: `### Blockers/Concerns` in the template, or
+ * `Blockers` / `Concerns`. Matching only "## Blockers" left the list empty.
  * @param {string} content - Full state.md content
  * @returns {string[]} Array of blocker text strings
  */
 function parseBlockersFromState(content) {
   const blockers = [];
-  const blockersMatch = content.match(/##\s*Blockers\s*\n([\s\S]*?)(?=\n##|$)/i);
+  const blockersMatch = content.match(/###?\s*(?:Blockers|Blockers\/Concerns|Concerns)\s*\n([\s\S]*?)(?=\n###?|\n##[^#]|$)/i);
   if (blockersMatch) {
     const blockersSection = blockersMatch[1];
     const items = blockersSection.match(/^-\s+(.+)$/gm) || [];
@@ -585,6 +596,18 @@ function parseBlockersFromState(content) {
   return blockers;
 }
 
+/**
+ * The blockers that are still open: the section's bullets minus a "None" placeholder.
+ * `preflight` and `dashboard` read a `## Blockers` heading of their own, which the
+ * state template never writes (it writes `### Blockers/Concerns`, where
+ * `state add-blocker` puts its bullets), so both reported no blockers with one open.
+ * @param {string} content - Full state.md content
+ * @returns {string[]}
+ */
+function activeBlockersFromState(content) {
+  return parseBlockersFromState(content).filter((b) => b && !/^none(\s+yet)?\.?$/i.test(b));
+}
+
 /**
  * Parse the Session section from state.md content.
  * Extracts **Last Date:**, **Stopped At:**, and **Resume File:** bold-field
@@ -1029,17 +1052,8 @@ function cmdDashboard(cwd, raw) {
     lastActivity = stateExtractField(stateContent, 'Last Activity');
     lastActivityDesc = stateExtractField(stateContent, 'Last Activity Description');
 
-    // Parse blockers
-    const blockersMatch = stateContent.match(/##\s*Blockers\s*\n([\s\S]*?)(?=\n##|$)/i);
-    if (blockersMatch) {
-      const items = blockersMatch[1].match(/^-\s+(.+)$/gm) || [];
-      for (const item of items) {
-        const text = item.replace(/^-\s+/, '').trim();
-        if (text && !/^none$/i.test(text)) {
-          activeBlockers.push(text);
-        }
-      }
-    }
+    // Parse blockers (the template's `### Blockers/Concerns`, or a legacy `## Blockers`)
+    activeBlockers.push(...activeBlockersFromState(stateContent));
     blockerCount = activeBlockers.length;
   }
 
@@ -1111,6 +1125,7 @@ function cmdDashboard(cwd, raw) {
 
 module.exports = {
   readStateSafe: safeReadFile,
+  activeBlockersFromState,
   stateExtractField,
   stateReplaceField,
   writeStateMd,

package/pan-wizard-core/bin/lib/template.cjs

@@ -5,7 +5,7 @@
 const fs = require('fs');
 const path = require('path');
 const {
-  PHASES_DIR, PLAN_SUFFIX, SUMMARY_SUFFIX, VERIFICATION_SUFFIX,
+  PHASES_DIR, PLAN_SUFFIX, SUMMARY_SUFFIX, VERIFICATION_SUFFIX, ROADMAP_SLICE_SUFFIX,
   SIMPLE_TASK_THRESHOLD, SIMPLE_FILE_THRESHOLD, COMPLEX_TASK_THRESHOLD, COMPLEX_FILE_THRESHOLD,
 } = require('./constants.cjs');
 const { planningPath, phasesPath } = require('./utils.cjs');
@@ -86,7 +86,7 @@ function cmdTemplateSelect(cwd, planPath, raw) {
  * @param {string} phaseName - Human-readable phase name
  * @param {string} phaseSlug - Phase slug for directory naming
  * @param {string} phaseNum - Raw phase number from options
- * @param {Object} options - Additional options (type, wave, fields)
+ * @param {Object} options - Additional options (type, wave, fields, slicePath)
  * @returns {{frontmatter: Object, body: string, fileName: string}}
  */
 function generatePlanTemplate(phaseId, planId, phaseName, phaseSlug, phaseNum, options) {
@@ -94,6 +94,10 @@ function generatePlanTemplate(phaseId, planId, phaseName, phaseSlug, phaseNum, o
   const wave = parseInt(options.wave, 10) || 1;
   const fields = options.fields || {};
   const padded = phaseId.split('-')[0]; // e.g., "01" from "01-setup-auth"
+  // The <context> names the phase's roadmap slice, as templates/phase-prompt.md
+  // does (O2): `@.planning/roadmap.md` handed every executor the whole roadmap.
+  // cmdTemplateFill passes the phase's real directory.
+  const slicePath = options.slicePath || `.planning/phases/${phaseId}/${padded}${ROADMAP_SLICE_SUFFIX}`;
 
   const frontmatter = {
     phase: phaseId,
@@ -121,7 +125,7 @@ function generatePlanTemplate(phaseId, planId, phaseName, phaseSlug, phaseNum, o
     '',
     '## Context',
     '@.planning/project.md',
-    '@.planning/roadmap.md',
+    `@${slicePath}`,
     '@.planning/state.md',
     '',
     '## Tasks',
@@ -286,7 +290,10 @@ function cmdTemplateFill(cwd, templateType, options, raw) {
       generated = generateSummaryTemplate(phaseId, planNum, phaseName, options.phase, fields);
       break;
     case 'plan':
-      generated = generatePlanTemplate(phaseId, planNum, phaseName, phaseSlug, options.phase, options);
+      generated = generatePlanTemplate(phaseId, planNum, phaseName, phaseSlug, options.phase, {
+        ...options,
+        slicePath: toPosix(path.join(phaseInfo.directory, `${padded}${ROADMAP_SLICE_SUFFIX}`)),
+      });
       break;
     case 'verification':
       generated = generateVerificationTemplate(phaseId, phaseName, options.phase, fields);