gsd-pi 2.8.0 → 2.8.2

package/src/resources/extensions/gsd/auto.ts

@@ -48,14 +48,14 @@ import {
   validateCompleteBoundary,
   formatValidationIssues,
 } from "./observability-validator.js";
-import { ensureGitignore } from "./gitignore.js";
+import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
 import { runGSDDoctor, rebuildState } from "./doctor.js";
 import { snapshotSkills, clearSkillSnapshot } from "./skill-discovery.js";
 import {
   initMetrics, resetMetrics, snapshotUnitMetrics, getLedger,
   getProjectTotals, formatCost, formatTokenCount,
 } from "./metrics.js";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import { readdirSync, readFileSync, existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { execSync, execFileSync } from "node:child_process";
 import {
@@ -68,6 +68,7 @@ import {
   mergeSliceToMain,
 } from "./worktree.ts";
 import { GitServiceImpl } from "./git-service.ts";
+import { getPriorSliceCompletionBlocker } from "./dispatch-guard.ts";
 import type { GitPreferences } from "./git-service.ts";
 import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
 import { makeUI, GLYPH, INDENT } from "../shared/ui.js";
@@ -380,6 +381,7 @@ export async function startAuto(
 
   // Ensure .gitignore has baseline patterns
   ensureGitignore(base);
+  untrackRuntimeFiles(base);
 
   // Bootstrap .gsd/ if it doesn't exist
   const gsdDir = join(base, ".gsd");
@@ -1254,7 +1256,14 @@ async function dispatchNextUnit(
     }
   }
 
-  await emitObservabilityWarnings(ctx, unitType, unitId);
+  const priorSliceBlocker = getPriorSliceCompletionBlocker(basePath, getMainBranch(basePath), unitType, unitId);
+  if (priorSliceBlocker) {
+    await stopAuto(ctx, pi);
+    ctx.ui.notify(priorSliceBlocker, "error");
+    return;
+  }
+
+  const observabilityIssues = await collectObservabilityWarnings(ctx, unitType, unitId);
 
   // Idempotency: skip units already completed in a prior session.
   const idempotencyKey = `${unitType}/${unitId}`;
@@ -1394,6 +1403,13 @@ async function dispatchNextUnit(
     }
   }
 
+  // Inject observability repair instructions so the agent fixes gaps before
+  // proceeding with the unit (see #174).
+  const repairBlock = buildObservabilityRepairBlock(observabilityIssues);
+  if (repairBlock) {
+    finalPrompt = `${finalPrompt}${repairBlock}`;
+  }
+
   // Switch model if preferences specify one for this unit type
   // Try primary model, then fallbacks in order if setting fails
   const modelConfig = resolveModelWithFallbacksForUnit(unitType);
@@ -1681,13 +1697,11 @@ async function buildResearchMilestonePrompt(mid: string, midTitle: string, base:
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
   const outputRelPath = relMilestoneFile(base, mid, "RESEARCH");
-  const outputAbsPath = resolveMilestoneFile(base, mid, "RESEARCH") ?? join(base, outputRelPath);
   return loadPrompt("research-milestone", {
     milestoneId: mid, milestoneTitle: midTitle,
     milestonePath: relMilestonePath(base, mid),
     contextPath: contextRel,
     outputPath: outputRelPath,
-    outputAbsPath,
     inlinedContext,
     ...buildSkillDiscoveryVars(),
   });
@@ -1715,7 +1729,6 @@ async function buildPlanMilestonePrompt(mid: string, midTitle: string, base: str
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
   const outputRelPath = relMilestoneFile(base, mid, "ROADMAP");
-  const outputAbsPath = resolveMilestoneFile(base, mid, "ROADMAP") ?? join(base, outputRelPath);
   const secretsOutputPath = relMilestoneFile(base, mid, "SECRETS");
   return loadPrompt("plan-milestone", {
     milestoneId: mid, milestoneTitle: midTitle,
@@ -1723,7 +1736,6 @@ async function buildPlanMilestonePrompt(mid: string, midTitle: string, base: str
     contextPath: contextRel,
     researchPath: researchRel,
     outputPath: outputRelPath,
-    outputAbsPath,
     secretsOutputPath,
     inlinedContext,
   });
@@ -1755,7 +1767,6 @@ async function buildResearchSlicePrompt(
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
   const outputRelPath = relSliceFile(base, mid, sid, "RESEARCH");
-  const outputAbsPath = resolveSliceFile(base, mid, sid, "RESEARCH") ?? join(base, outputRelPath);
   return loadPrompt("research-slice", {
     milestoneId: mid, sliceId: sid, sliceTitle: sTitle,
     slicePath: relSlicePath(base, mid, sid),
@@ -1763,7 +1774,6 @@ async function buildResearchSlicePrompt(
     contextPath: contextRel,
     milestoneResearchPath: milestoneResearchRel,
     outputPath: outputRelPath,
-    outputAbsPath,
     inlinedContext,
     dependencySummaries: depContent,
     ...buildSkillDiscoveryVars(),
@@ -1792,16 +1802,12 @@ async function buildPlanSlicePrompt(
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
   const outputRelPath = relSliceFile(base, mid, sid, "PLAN");
-  const outputAbsPath = resolveSliceFile(base, mid, sid, "PLAN") ?? join(base, outputRelPath);
-  const sliceAbsPath = resolveSlicePath(base, mid, sid) ?? join(base, relSlicePath(base, mid, sid));
   return loadPrompt("plan-slice", {
     milestoneId: mid, sliceId: sid, sliceTitle: sTitle,
     slicePath: relSlicePath(base, mid, sid),
-    sliceAbsPath,
     roadmapPath: roadmapRel,
     researchPath: researchRel,
     outputPath: outputRelPath,
-    outputAbsPath,
     inlinedContext,
     dependencySummaries: depContent,
   });
@@ -1852,8 +1858,7 @@ async function buildExecuteTaskPrompt(
 
   const carryForwardSection = await buildCarryForwardSection(priorSummaries, base);
 
-  const sliceDirAbs = resolveSlicePath(base, mid, sid) ?? join(base, relSlicePath(base, mid, sid));
-  const taskSummaryAbsPath = join(sliceDirAbs, "tasks", `${tid}-SUMMARY.md`);
+  const taskSummaryPath = `${relSlicePath(base, mid, sid)}/tasks/${tid}-SUMMARY.md`;
 
   return loadPrompt("execute-task", {
     milestoneId: mid, sliceId: sid, sliceTitle: sTitle, taskId: tid, taskTitle: tTitle,
@@ -1865,7 +1870,7 @@ async function buildExecuteTaskPrompt(
     carryForwardSection,
     resumeSection,
     priorTaskLines: priorLines,
-    taskSummaryAbsPath,
+    taskSummaryPath,
   });
 }
 
@@ -1901,17 +1906,17 @@ async function buildCompleteSlicePrompt(
 
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
-  const sliceDirAbs = resolveSlicePath(base, mid, sid) ?? join(base, relSlicePath(base, mid, sid));
-  const sliceSummaryAbsPath = join(sliceDirAbs, `${sid}-SUMMARY.md`);
-  const sliceUatAbsPath = join(sliceDirAbs, `${sid}-UAT.md`);
+  const sliceRel = relSlicePath(base, mid, sid);
+  const sliceSummaryPath = `${sliceRel}/${sid}-SUMMARY.md`;
+  const sliceUatPath = `${sliceRel}/${sid}-UAT.md`;
 
   return loadPrompt("complete-slice", {
     milestoneId: mid, sliceId: sid, sliceTitle: sTitle,
-    slicePath: relSlicePath(base, mid, sid),
+    slicePath: sliceRel,
     roadmapPath: roadmapRel,
     inlinedContext,
-    sliceSummaryAbsPath,
-    sliceUatAbsPath,
+    sliceSummaryPath,
+    sliceUatPath,
   });
 }
 
@@ -1950,15 +1955,14 @@ async function buildCompleteMilestonePrompt(
 
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
-  const milestoneDirAbs = resolveMilestonePath(base, mid) ?? join(base, relMilestonePath(base, mid));
-  const milestoneSummaryAbsPath = join(milestoneDirAbs, `${mid}-SUMMARY.md`);
+  const milestoneSummaryPath = `${relMilestonePath(base, mid)}/${mid}-SUMMARY.md`;
 
   return loadPrompt("complete-milestone", {
     milestoneId: mid,
     milestoneTitle: midTitle,
     roadmapPath: roadmapRel,
     inlinedContext,
-    milestoneSummaryAbsPath,
+    milestoneSummaryPath,
   });
 }
 
@@ -2001,8 +2005,7 @@ async function buildReplanSlicePrompt(
 
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
-  const sliceDirAbs = resolveSlicePath(base, mid, sid) ?? join(base, relSlicePath(base, mid, sid));
-  const replanAbsPath = join(sliceDirAbs, `${sid}-REPLAN.md`);
+  const replanPath = `${relSlicePath(base, mid, sid)}/${sid}-REPLAN.md`;
 
   return loadPrompt("replan-slice", {
     milestoneId: mid,
@@ -2012,7 +2015,7 @@ async function buildReplanSlicePrompt(
     planPath: slicePlanRel,
     blockerTaskId,
     inlinedContext,
-    replanAbsPath,
+    replanPath,
   });
 }
 
@@ -2130,8 +2133,6 @@ async function buildRunUatPrompt(
 
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
-  const sliceDirAbs = resolveSlicePath(base, mid, sliceId) ?? join(base, relSlicePath(base, mid, sliceId));
-  const uatResultAbsPath = join(sliceDirAbs, `${sliceId}-UAT-RESULT.md`);
   const uatResultPath = relSliceFile(base, mid, sliceId, "UAT-RESULT");
   const uatType = extractUatType(uatContent) ?? "human-experience";
 
@@ -2139,7 +2140,6 @@ async function buildRunUatPrompt(
     milestoneId: mid,
     sliceId,
     uatPath,
-    uatResultAbsPath,
     uatResultPath,
     uatType,
     inlinedContext,
@@ -2166,9 +2166,7 @@ async function buildReassessRoadmapPrompt(
 
   const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
 
-  const assessmentRel = relSliceFile(base, mid, completedSliceId, "ASSESSMENT");
-  const sliceDirAbs = resolveSlicePath(base, mid, completedSliceId) ?? join(base, relSlicePath(base, mid, completedSliceId));
-  const assessmentAbsPath = join(sliceDirAbs, `${completedSliceId}-ASSESSMENT.md`);
+  const assessmentPath = relSliceFile(base, mid, completedSliceId, "ASSESSMENT");
 
   return loadPrompt("reassess-roadmap", {
     milestoneId: mid,
@@ -2176,8 +2174,7 @@ async function buildReassessRoadmapPrompt(
     completedSliceId,
     roadmapPath: roadmapRel,
     completedSliceSummaryPath: summaryRel,
-    assessmentPath: assessmentRel,
-    assessmentAbsPath,
+    assessmentPath,
     inlinedContext,
   });
 }
@@ -2357,17 +2354,17 @@ function ensurePreconditions(
 
 // ─── Diagnostics ──────────────────────────────────────────────────────────────
 
-async function emitObservabilityWarnings(
+async function collectObservabilityWarnings(
   ctx: ExtensionContext,
   unitType: string,
   unitId: string,
-): Promise<void> {
+): Promise<import("./observability-validator.ts").ValidationIssue[]> {
   const parts = unitId.split("/");
   const mid = parts[0];
   const sid = parts[1];
   const tid = parts[2];
 
-  if (!mid || !sid) return;
+  if (!mid || !sid) return [];
 
   let issues = [] as Awaited<ReturnType<typeof validatePlanBoundary>>;
 
@@ -2379,12 +2376,38 @@ async function emitObservabilityWarnings(
     issues = await validateCompleteBoundary(basePath, mid, sid);
   }
 
-  if (issues.length === 0) return;
+  if (issues.length > 0) {
+    ctx.ui.notify(
+      `Observability check (${unitType}) found ${issues.length} warning${issues.length === 1 ? "" : "s"}:\n${formatValidationIssues(issues)}`,
+      "warning",
+    );
+  }
 
-  ctx.ui.notify(
-    `Observability check (${unitType}) found ${issues.length} warning${issues.length === 1 ? "" : "s"}:\n${formatValidationIssues(issues)}`,
-    "warning",
-  );
+  return issues;
+}
+
+function buildObservabilityRepairBlock(issues: import("./observability-validator.ts").ValidationIssue[]): string {
+  if (issues.length === 0) return "";
+  const items = issues.map(issue => {
+    const fileName = issue.file.split("/").pop() || issue.file;
+    let line = `- **${fileName}**: ${issue.message}`;
+    if (issue.suggestion) line += ` → ${issue.suggestion}`;
+    return line;
+  });
+  return [
+    "",
+    "---",
+    "",
+    "## Pre-flight: Observability gaps to fix FIRST",
+    "",
+    "The following issues were detected in plan/summary files for this unit.",
+    "**Read each flagged file, apply the fix described, then proceed with the unit.**",
+    "",
+    ...items,
+    "",
+    "---",
+    "",
+  ].join("\n");
 }
 
 async function recoverTimedOutUnit(
@@ -2736,14 +2759,34 @@ export function resolveExpectedArtifactPath(unitType: string, unitId: string, ba
 }
 
 /**
- * Check whether the expected artifact for a unit exists on disk.
- * Returns true if the artifact file exists, or if the unit type has no
+ * Check whether the expected artifact(s) for a unit exist on disk.
+ * Returns true if all required artifacts exist, or if the unit type has no
  * single verifiable artifact (e.g., replan-slice).
+ *
+ * complete-slice requires both SUMMARY and UAT files — verifying only
+ * the summary allowed the unit to be marked complete when the LLM
+ * skipped writing the UAT file (see #176).
  */
 function verifyExpectedArtifact(unitType: string, unitId: string, base: string): boolean {
   const absPath = resolveExpectedArtifactPath(unitType, unitId, base);
   if (!absPath) return true;
-  return existsSync(absPath);
+  if (!existsSync(absPath)) return false;
+
+  // complete-slice must also produce a UAT file
+  if (unitType === "complete-slice") {
+    const parts = unitId.split("/");
+    const mid = parts[0];
+    const sid = parts[1];
+    if (mid && sid) {
+      const dir = resolveSlicePath(base, mid, sid);
+      if (dir) {
+        const uatPath = join(dir, buildSliceFileName(sid, "UAT"));
+        if (!existsSync(uatPath)) return false;
+      }
+    }
+  }
+
+  return true;
 }
 
 /**
@@ -2753,7 +2796,7 @@ function verifyExpectedArtifact(unitType: string, unitId: string, base: string):
 export function writeBlockerPlaceholder(unitType: string, unitId: string, base: string, reason: string): string | null {
   const absPath = resolveExpectedArtifactPath(unitType, unitId, base);
   if (!absPath) return null;
-  const dir = absPath.substring(0, absPath.lastIndexOf("/"));
+  const dir = dirname(absPath);
   if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
   const content = [
     `# BLOCKER — auto-mode recovery failed`,
@@ -2787,7 +2830,7 @@ function diagnoseExpectedArtifact(unitType: string, unitId: string, base: string
       return `Task ${tid} marked [x] in ${relSliceFile(base, mid!, sid!, "PLAN")} + summary written`;
     }
     case "complete-slice":
-      return `Slice ${sid} marked [x] in ${relMilestoneFile(base, mid!, "ROADMAP")} + summary written`;
+      return `Slice ${sid} marked [x] in ${relMilestoneFile(base, mid!, "ROADMAP")} + summary + UAT written`;
     case "replan-slice":
       return `${relSliceFile(base, mid!, sid!, "REPLAN")} + updated ${relSliceFile(base, mid!, sid!, "PLAN")}`;
     case "reassess-roadmap":

package/src/resources/extensions/gsd/dispatch-guard.ts

@@ -0,0 +1,65 @@
+import { execSync } from "node:child_process";
+import { relMilestoneFile } from "./paths.js";
+import { parseRoadmapSlices } from "./roadmap-slices.ts";
+
+const SLICE_DISPATCH_TYPES = new Set([
+  "research-slice",
+  "plan-slice",
+  "replan-slice",
+  "execute-task",
+  "complete-slice",
+]);
+
+function readTrackedFileFromBranch(base: string, branch: string, relPath: string): string | null {
+  try {
+    return execSync(`git show ${branch}:${relPath}`, {
+      cwd: base,
+      stdio: ["ignore", "pipe", "pipe"],
+      encoding: "utf-8",
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+function milestoneIdFromNumber(num: number): string {
+  return `M${String(num).padStart(3, "0")}`;
+}
+
+export function getPriorSliceCompletionBlocker(base: string, mainBranch: string, unitType: string, unitId: string): string | null {
+  if (!SLICE_DISPATCH_TYPES.has(unitType)) return null;
+
+  const [targetMid, targetSid] = unitId.split("/");
+  if (!targetMid || !targetSid) return null;
+
+  const targetMidNumber = Number.parseInt(targetMid.slice(1), 10);
+  if (!Number.isFinite(targetMidNumber)) return null;
+
+  for (let milestoneNumber = 1; milestoneNumber <= targetMidNumber; milestoneNumber += 1) {
+    const mid = milestoneIdFromNumber(milestoneNumber);
+    const roadmapRel = relMilestoneFile(base, mid, "ROADMAP");
+    if (!roadmapRel) continue;
+
+    const roadmapContent = readTrackedFileFromBranch(base, mainBranch, roadmapRel);
+    if (!roadmapContent) continue;
+
+    const slices = parseRoadmapSlices(roadmapContent);
+    if (mid !== targetMid) {
+      const incomplete = slices.find(slice => !slice.done);
+      if (incomplete) {
+        return `Cannot dispatch ${unitType} ${unitId}: earlier slice ${mid}/${incomplete.id} is not complete on ${mainBranch}.`;
+      }
+      continue;
+    }
+
+    const targetIndex = slices.findIndex(slice => slice.id === targetSid);
+    if (targetIndex === -1) return null;
+
+    const incomplete = slices.slice(0, targetIndex).find(slice => !slice.done);
+    if (incomplete) {
+      return `Cannot dispatch ${unitType} ${unitId}: earlier slice ${targetMid}/${incomplete.id} is not complete on ${mainBranch}.`;
+    }
+  }
+
+  return null;
+}

package/src/resources/extensions/gsd/docs/preferences-reference.md

@@ -13,6 +13,61 @@ Full documentation for `~/.gsd/preferences.md` (global) and `.gsd/preferences.md
 
 ---
 
+## Semantics
+
+### Empty Arrays vs Omitted Fields
+
+**Empty arrays (`[]`) are equivalent to omitting the field entirely.** During validation, GSD deletes empty arrays from the preferences object (see `validatePreferences()` in `preferences.ts`):
+
+```typescript
+for (const key of ["always_use_skills", "prefer_skills", "avoid_skills", "custom_instructions"] as const) {
+  if (validated[key] && validated[key]!.length === 0) {
+    delete validated[key];
+  }
+}
+```
+
+These are functionally identical:
+
+```yaml
+# Explicit empty arrays — will be normalized away
+prefer_skills: []
+avoid_skills: []
+skill_rules: []
+
+# Omitted entirely — same result
+# (just don't write these fields)
+```
+
+**Recommendation:** Omit fields you don't need. Empty arrays add noise with no effect.
+
+### Global vs Project Preferences
+
+Preferences are loaded from two locations and merged:
+
+1. **Global:** `~/.gsd/preferences.md` — applies to all projects
+2. **Project:** `.gsd/preferences.md` — applies to the current project only
+
+**Merge behavior** (see `mergePreferences()` in `preferences.ts`):
+- **Scalar fields** (`skill_discovery`, `budget_ceiling`, etc.): Project wins if defined, otherwise global. Uses nullish coalescing (`??`).
+- **Array fields** (`always_use_skills`, `prefer_skills`, etc.): Concatenated via `mergeStringLists()` (global first, then project).
+- **Object fields** (`models`, `git`, `auto_supervisor`): Shallow merge via spread operator `{ ...base, ...override }`.
+
+For `models`, project settings override global at the phase level. If global has `planning: opus` and project has `planning: sonnet`, the project wins. But if project omits `research`, global's `research` setting is preserved.
+
+### Skill Discovery vs Skill Preferences
+
+These are **separate concerns**:
+
+| Field | What it controls | Code reference |
+|-------|-----------------|----------------|
+| `skill_discovery` | **Whether** GSD looks for relevant skills during research | `resolveSkillDiscoveryMode()` in `preferences.ts` |
+| `always_use_skills`, `prefer_skills`, `avoid_skills` | **Which** skills to use when they're found relevant | `renderPreferencesForSystemPrompt()` in `preferences.ts` |
+
+Setting `prefer_skills: []` does **not** disable skill discovery — it just means you have no preference overrides. Use `skill_discovery: off` to disable discovery entirely.
+
+---
+
 ## Field Guide
 
 - `version`: schema version. Start at `1`.
@@ -60,6 +115,27 @@ Full documentation for `~/.gsd/preferences.md` (global) and `.gsd/preferences.md
 - Use `skill_rules` for situational routing, not broad personality preferences.
 - Prefer skill names for stable built-in skills.
 - Prefer absolute paths for local personal skills.
+- **Omit fields you don't need** — empty arrays add noise with no effect.
+
+---
+
+## Minimal Example
+
+The cleanest preferences file only specifies what you actually want:
+
+```yaml
+---
+version: 1
+always_use_skills:
+  - debug-like-expert
+skill_discovery: suggest
+models:
+  planning: claude-opus-4-6
+  execution: claude-sonnet-4-6
+---
+```
+
+Everything else uses defaults. No `prefer_skills: []`, no `avoid_skills: []`, no `auto_supervisor: {}` — those are just noise.
 
 ---
 

package/src/resources/extensions/gsd/exit-command.ts

@@ -0,0 +1,18 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@gsd/pi-coding-agent";
+
+type StopAutoFn = (ctx: ExtensionCommandContext, pi: ExtensionAPI) => Promise<void>;
+
+export function registerExitCommand(
+  pi: ExtensionAPI,
+  deps: { stopAuto?: StopAutoFn } = {},
+): void {
+  pi.registerCommand("exit", {
+    description: "Exit GSD gracefully",
+    handler: async (_args: string, ctx: ExtensionCommandContext) => {
+      // Stop auto-mode first so locks and activity state are cleaned up before shutdown.
+      const stopAuto = deps.stopAuto ?? (await import("./auto.js")).stopAuto;
+      await stopAuto(ctx, pi);
+      ctx.shutdown();
+    },
+  });
+}

package/src/resources/extensions/gsd/files.ts

@@ -1,14 +1,14 @@
-// GSD Extension — File Parsing and I/O
+// GSD Extension - File Parsing and I/O
 // Parsers for roadmap, plan, summary, and continue files.
 // Used by state derivation and the status widget.
-// Pure functions, zero Pi dependencies — uses only Node built-ins.
+// Pure functions, zero Pi dependencies - uses only Node built-ins.
 
 import { promises as fs, readdirSync } from 'node:fs';
 import { dirname, resolve } from 'node:path';
 import { milestonesDir, resolveMilestoneFile, relMilestoneFile } from './paths.js';
 
 import type {
-  Roadmap, RoadmapSliceEntry, BoundaryMapEntry, RiskLevel,
+  Roadmap, BoundaryMapEntry,
   SlicePlan, TaskPlanEntry,
   Summary, SummaryFrontmatter, SummaryRequires, FileModified,
   Continue, ContinueFrontmatter, ContinueStatus,
@@ -18,6 +18,7 @@ import type {
 } from './types.ts';
 
 import { checkExistingEnvKeys } from '../get-secrets-from-user.ts';
+import { parseRoadmapSlices } from './roadmap-slices.ts';
 
 // ─── Helpers ───────────────────────────────────────────────────────────────
 
@@ -199,40 +200,8 @@ export function parseRoadmap(content: string): Roadmap {
     })();
   const successCriteria = scSection ? parseBullets(scSection) : [];
 
-  // Slices
-  const slicesSection = extractSection(content, 'Slices');
-  const slices: RoadmapSliceEntry[] = [];
-
-  if (slicesSection) {
-    const checkboxItems = slicesSection.split('\n');
-    let currentSlice: RoadmapSliceEntry | null = null;
-
-    for (const line of checkboxItems) {
-      const cbMatch = line.match(/^-\s+\[([ xX])\]\s+\*\*(\w+):\s+(.+?)\*\*\s*(.*)/);
-      if (cbMatch) {
-        if (currentSlice) slices.push(currentSlice);
-
-        const done = cbMatch[1].toLowerCase() === 'x';
-        const id = cbMatch[2];
-        const sliceTitle = cbMatch[3];
-        const rest = cbMatch[4];
-
-        const riskMatch = rest.match(/`risk:(\w+)`/);
-        const risk = (riskMatch ? riskMatch[1] : 'low') as RiskLevel;
-
-        const depsMatch = rest.match(/`depends:\[([^\]]*)\]`/);
-        const depends = depsMatch && depsMatch[1].trim()
-          ? depsMatch[1].split(',').map(s => s.trim())
-          : [];
-
-        currentSlice = { id, title: sliceTitle, risk, depends, done, demo: '' };
-      } else if (currentSlice && line.trim().startsWith('>')) {
-        const demoText = line.trim().replace(/^>\s*/, '').replace(/^After this:\s*/i, '');
-        currentSlice.demo = demoText;
-      }
-    }
-    if (currentSlice) slices.push(currentSlice);
-  }
+  // Slices  
+  const slices = parseRoadmapSlices(content);
 
   // Boundary map
   const boundaryMap: BoundaryMapEntry[] = [];
@@ -657,7 +626,7 @@ export function parseTaskPlanMustHaves(content: string): Array<{ text: string; c
         checked: cbMatch[1].toLowerCase() === 'x',
       };
     }
-    // No checkbox — treat as unchecked with full line as text
+    // No checkbox - treat as unchecked with full line as text
     return { text: line.trim(), checked: false };
   });
 }
@@ -732,7 +701,7 @@ export type UatType = 'artifact-driven' | 'live-runtime' | 'human-experience' |
 /**
  * Extract the UAT type from a UAT file's raw content.
  *
- * UAT files have no YAML frontmatter — pass raw file content directly.
+ * UAT files have no YAML frontmatter - pass raw file content directly.
  * Classification is leading-keyword-only: e.g. `mixed (artifact-driven + live-runtime)` → `'mixed'`.
  *
  * Returns `undefined` when:
@@ -811,7 +780,7 @@ export async function inlinePriorMilestoneSummary(mid: string, base: string): Pr
  * with the current environment (.env + process.env).
  *
  * Returns `null` when no manifest file exists (path resolution failure or
- * file not on disk) — callers can distinguish "no manifest" from "empty manifest".
+ * file not on disk) - callers can distinguish "no manifest" from "empty manifest".
  */
 export async function getManifestStatus(
   base: string, milestoneId: string,