gsd-pi 2.8.0 → 2.8.2

package/src/resources/extensions/gsd/prompts/plan-milestone.md

@@ -76,6 +76,6 @@ If this milestone requires any external API keys or secrets:
 
 If this milestone does not require any external API keys or secrets, skip this step entirely — do not create an empty manifest.
 
-**You MUST write the file `{{outputAbsPath}}` before finishing.**
+**You MUST write the file `{{outputPath}}` before finishing.**
 
 When done, say: "Milestone {{milestoneId}} planned."

package/src/resources/extensions/gsd/prompts/plan-slice.md

@@ -37,7 +37,7 @@ Then:
    - a matching task plan file with description, steps, must-haves, verification, inputs, and expected output
    - Observability Impact section **only if the task touches runtime boundaries, async flows, or error paths** — omit it otherwise
 6. Write `{{outputPath}}`
-7. Write individual task plans in `{{sliceAbsPath}}/tasks/`: `T01-PLAN.md`, `T02-PLAN.md`, etc.
+7. Write individual task plans in `{{slicePath}}/tasks/`: `T01-PLAN.md`, `T02-PLAN.md`, etc.
 8. **Self-audit the plan.** Walk through each check — if any fail, fix the plan files before moving on:
     - **Completion semantics:** If every task were completed exactly as written, the slice goal/demo should actually be true.
     - **Requirement coverage:** Every must-have in the slice maps to at least one task. No must-have is orphaned. If `REQUIREMENTS.md` exists, every Active requirement this slice owns maps to at least one task.
@@ -52,6 +52,6 @@ Then:
 
 The slice directory and tasks/ subdirectory already exist. Do NOT mkdir. You are on the slice branch; all work stays here.
 
-**You MUST write the file `{{outputAbsPath}}` before finishing.**
+**You MUST write the file `{{outputPath}}` before finishing.**
 
 When done, say: "Slice {{sliceId}} planned."

package/src/resources/extensions/gsd/prompts/reassess-roadmap.md

@@ -34,15 +34,15 @@ If all criteria have at least one remaining owning slice, the coverage check pas
 
 **If the roadmap is still good:**
 
-Write `{{assessmentAbsPath}}` with a brief confirmation that roadmap coverage still holds after {{completedSliceId}}. If requirements exist, explicitly note whether requirement coverage remains sound.
+Write `{{assessmentPath}}` with a brief confirmation that roadmap coverage still holds after {{completedSliceId}}. If requirements exist, explicitly note whether requirement coverage remains sound.
 
 **If changes are needed:**
 
 1. Rewrite the remaining (unchecked) slices in `{{roadmapPath}}`. Keep completed slices exactly as they are (`[x]`). Update the boundary map for changed slices. Update the proof strategy if risks changed. Update requirement coverage if ownership or scope changed.
-2. Write `{{assessmentAbsPath}}` explaining what changed and why — keep it brief and concrete.
+2. Write `{{assessmentPath}}` explaining what changed and why — keep it brief and concrete.
 3. If `.gsd/REQUIREMENTS.md` exists and requirement ownership or status changed, update it.
 4. Commit: `docs({{milestoneId}}): reassess roadmap after {{completedSliceId}}`
 
-**You MUST write the file `{{assessmentAbsPath}}` before finishing.**
+**You MUST write the file `{{assessmentPath}}` before finishing.**
 
 When done, say: "Roadmap reassessed."

package/src/resources/extensions/gsd/prompts/replan-slice.md

@@ -20,7 +20,7 @@ All relevant context has been preloaded below — the roadmap, current slice pla
 
 1. Read the blocker task summary carefully. Understand exactly what was discovered and why it blocks the current plan.
 2. Analyze the remaining `[ ]` tasks in the slice plan. Determine which are still valid, which need modification, and which should be replaced.
-3. Write `{{replanAbsPath}}` documenting:
+3. Write `{{replanPath}}` documenting:
    - What blocker was discovered and in which task
    - What changed in the plan and why
    - Which incomplete tasks were modified, added, or removed
@@ -34,6 +34,6 @@ All relevant context has been preloaded below — the roadmap, current slice pla
 6. Do not commit manually — the system auto-commits your changes after this unit completes.
 7. Update `.gsd/STATE.md`
 
-**You MUST write `{{replanAbsPath}}` and the updated slice plan before finishing.**
+**You MUST write `{{replanPath}}` and the updated slice plan before finishing.**
 
 When done, say: "Slice {{sliceId}} replanned."

package/src/resources/extensions/gsd/prompts/research-milestone.md

@@ -32,6 +32,6 @@ Then research the codebase and relevant technologies. Narrate key findings and s
 
 **Research is advisory, not auto-binding.** Surface candidate requirements clearly instead of silently expanding scope.
 
-**You MUST write the file `{{outputAbsPath}}` before finishing.**
+**You MUST write the file `{{outputPath}}` before finishing.**
 
 When done, say: "Milestone {{milestoneId}} researched."

package/src/resources/extensions/gsd/prompts/research-slice.md

@@ -23,6 +23,6 @@ Then research what this slice needs. Narrate key findings and surprises as you g
 
 The slice directory already exists at `{{slicePath}}/`. Do NOT mkdir — just write the file.
 
-**You MUST write the file `{{outputAbsPath}}` before finishing.**
+**You MUST write the file `{{outputPath}}` before finishing.**
 
 When done, say: "Slice {{sliceId}} researched."

package/src/resources/extensions/gsd/prompts/run-uat.md

@@ -14,7 +14,7 @@ If a `GSD Skill Preferences` block is present in system context, use it to decid
 
 **UAT file:** `{{uatPath}}`
 **UAT type:** `{{uatType}}`
-**Result file to write:** `{{uatResultAbsPath}}` (relative: `{{uatResultPath}}`)
+**Result file to write:** `{{uatResultPath}}`
 
 ### If UAT type is `artifact-driven`
 
@@ -37,7 +37,7 @@ After running all checks, compute the **overall verdict**:
 - `FAIL` — one or more checks failed
 - `PARTIAL` — some checks passed, some failed or were skipped
 
-Write `{{uatResultAbsPath}}` with:
+Write `{{uatResultPath}}` with:
 
 ```markdown
 ---
@@ -68,7 +68,7 @@ date: <ISO 8601 timestamp>
 
 This UAT type requires human execution or live-runtime observation that you cannot perform mechanically. Your role is to surface it clearly for review.
 
-Write `{{uatResultAbsPath}}` with:
+Write `{{uatResultPath}}` with:
 
 ```markdown
 ---
@@ -104,6 +104,6 @@ Once updated, run `/gsd auto` to resume auto-mode.
 
 ---
 
-**You MUST write `{{uatResultAbsPath}}` before finishing.**
+**You MUST write `{{uatResultPath}}` before finishing.**
 
 When done, say: "UAT {{sliceId}} complete."

package/src/resources/extensions/gsd/roadmap-slices.ts

@@ -0,0 +1,50 @@
+import type { RoadmapSliceEntry, RiskLevel } from "./types.ts";
+
+function extractSlicesSection(content: string): string {
+  const headingMatch = /^## Slices\s*$/m.exec(content);
+  if (!headingMatch || headingMatch.index == null) return "";
+
+  const start = headingMatch.index + headingMatch[0].length;
+  const rest = content.slice(start).replace(/^\r?\n/, "");
+  const nextHeading = /^##\s+/m.exec(rest);
+  return (nextHeading ? rest.slice(0, nextHeading.index) : rest).trimEnd();
+}
+
+export function parseRoadmapSlices(content: string): RoadmapSliceEntry[] {
+  const slicesSection = extractSlicesSection(content);
+  const slices: RoadmapSliceEntry[] = [];
+  if (!slicesSection) return slices;
+
+  const checkboxItems = slicesSection.split("\n");
+  let currentSlice: RoadmapSliceEntry | null = null;
+
+  for (const line of checkboxItems) {
+    const cbMatch = line.match(/^\s*-\s+\[([ xX])\]\s+\*\*(\w+):\s+(.+?)\*\*\s*(.*)/);
+    if (cbMatch) {
+      if (currentSlice) slices.push(currentSlice);
+
+      const done = cbMatch[1].toLowerCase() === "x";
+      const id = cbMatch[2]!;
+      const title = 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, risk, depends, done, demo: "" };
+      continue;
+    }
+
+    if (currentSlice && line.trim().startsWith(">")) {
+      currentSlice.demo = line.trim().replace(/^>\s*/, "").replace(/^After this:\s*/i, "");
+    }
+  }
+
+  if (currentSlice) slices.push(currentSlice);
+  return slices;
+}

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

@@ -0,0 +1,102 @@
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { execSync } from "node:child_process";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { getPriorSliceCompletionBlocker } from "../dispatch-guard.ts";
+
+let passed = 0;
+let failed = 0;
+
+function assertEq<T>(actual: T, expected: T, message: string): void {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) {
+    passed += 1;
+    return;
+  }
+  failed += 1;
+  console.error(`FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+}
+
+function run(command: string, cwd: string): void {
+  execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"] });
+}
+
+const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
+try {
+  mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
+  mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), [
+    "# M002: Previous",
+    "",
+    "## Slices",
+    "- [x] **S01: Done** `risk:low` `depends:[]`",
+    "- [ ] **S02: Pending** `risk:low` `depends:[S01]`",
+    "",
+  ].join("\n"));
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"), [
+    "# M003: Current",
+    "",
+    "## Slices",
+    "- [ ] **S01: First** `risk:low` `depends:[]`",
+    "- [ ] **S02: Second** `risk:low` `depends:[S01]`",
+    "",
+  ].join("\n"));
+
+  run("git init -b main", repo);
+  run("git config user.email test@example.com", repo);
+  run("git config user.name Test", repo);
+  run("git add .", repo);
+  run("git commit -m init", repo);
+
+  assertEq(
+    getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M003/S01"),
+    "Cannot dispatch plan-slice M003/S01: earlier slice M002/S02 is not complete on main.",
+    "blocks first slice of next milestone when prior milestone is incomplete on main",
+  );
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), [
+    "# M002: Previous",
+    "",
+    "## Slices",
+    "- [x] **S01: Done** `risk:low` `depends:[]`",
+    "- [x] **S02: Done** `risk:low` `depends:[S01]`",
+    "",
+  ].join("\n"));
+  run("git add .", repo);
+  run("git commit -m complete-m002", repo);
+
+  assertEq(
+    getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M003/S02/T01"),
+    "Cannot dispatch execute-task M003/S02/T01: earlier slice M003/S01 is not complete on main.",
+    "blocks later slice in same milestone when an earlier slice is incomplete on main",
+  );
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"), [
+    "# M003: Current",
+    "",
+    "## Slices",
+    "- [x] **S01: First** `risk:low` `depends:[]`",
+    "- [ ] **S02: Second** `risk:low` `depends:[S01]`",
+    "",
+  ].join("\n"));
+  run("git add .", repo);
+  run("git commit -m complete-m003-s01", repo);
+
+  assertEq(
+    getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M003/S02/T01"),
+    null,
+    "allows dispatch when all earlier slices are complete on main",
+  );
+
+  assertEq(
+    getPriorSliceCompletionBlocker(repo, "main", "plan-milestone", "M003"),
+    null,
+    "does not affect non-slice dispatch types",
+  );
+} finally {
+  rmSync(repo, { recursive: true, force: true });
+}
+
+console.log(`Passed: ${passed}, Failed: ${failed}`);
+if (failed > 0) process.exit(1);

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

@@ -0,0 +1,50 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { registerExitCommand } from "../exit-command.ts";
+
+test("/exit requests graceful shutdown instead of process.exit", async () => {
+  const commands = new Map<
+    string,
+    {
+      description?: string;
+      handler: (args: string, ctx: { shutdown: () => Promise<void> }) => Promise<void>;
+    }
+  >();
+
+  const pi = {
+    registerCommand(name: string, options: any) {
+      commands.set(name, options);
+    },
+  };
+
+  let stopAutoCalls = 0;
+  registerExitCommand(pi as any, {
+    async stopAuto() {
+      stopAutoCalls += 1;
+    },
+  });
+
+  const exit = commands.get("exit");
+  assert.ok(exit, "registerExitCommand should register /exit");
+  assert.equal(exit.description, "Exit GSD gracefully");
+
+  let shutdownCalls = 0;
+  const originalExit = process.exit;
+  process.exit = ((code?: number) => {
+    throw new Error(`process.exit should not be called: ${code ?? "undefined"}`);
+  }) as typeof process.exit;
+
+  try {
+    await exit.handler("", {
+      async shutdown() {
+        shutdownCalls += 1;
+      },
+    });
+  } finally {
+    process.exit = originalExit;
+  }
+
+  assert.equal(stopAutoCalls, 1, "handler should stop auto-mode exactly once before shutdown");
+  assert.equal(shutdownCalls, 1, "handler should request graceful shutdown exactly once");
+});

package/src/resources/extensions/gsd/tests/git-service.test.ts

@@ -1,4 +1,4 @@
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
@@ -210,8 +210,8 @@ async function main(): Promise<void> {
 
   assertEq(
     RUNTIME_EXCLUSION_PATHS.length,
-    6,
-    "exactly 6 runtime exclusion paths"
+    7,
+    "exactly 7 runtime exclusion paths"
   );
 
   const expectedPaths = [
@@ -220,6 +220,7 @@ async function main(): Promise<void> {
     ".gsd/worktrees/",
     ".gsd/auto.lock",
     ".gsd/metrics.json",
+    ".gsd/completed-units.json",
     ".gsd/STATE.md",
   ];
 
@@ -347,52 +348,76 @@ async function main(): Promise<void> {
     rmSync(repo, { recursive: true, force: true });
   }
 
-  // ─── GitServiceImpl: smart staging fallback ────────────────────────────
+  // ─── GitServiceImpl: smart staging excludes tracked runtime files ──────
 
-  console.log("\n=== GitServiceImpl: smart staging fallback ===");
+  console.log("\n=== GitServiceImpl: smart staging excludes tracked runtime files ===");
 
   {
-    // We can't easily make the pathspec fail in a real repo, but we can test
-    // the fallback behavior by verifying that if smart staging somehow fails,
-    // everything gets staged. We do this by checking that a commit with both
-    // runtime and real files works when pathspec would fail.
+    // Reproduces the real bug: .gsd/ runtime files that are already tracked
+    // (in the git index) must be excluded from staging even when .gsd/ is
+    // in .gitignore. The old pathspec-exclude approach failed silently in
+    // this case and fell back to `git add -A`, staging everything.
     //
-    // To force the fallback: temporarily override RUNTIME_EXCLUSION_PATHS
-    // with an invalid pathspec. Since we can't modify a readonly array,
-    // we'll test the actual fallback by creating a custom subclass.
+    // The fix has three layers:
+    // 1. Auto-cleanup: git rm --cached removes tracked runtime files from index
+    // 2. Stage-then-unstage: git add -A + git reset HEAD replaces pathspec excludes
+    // 3. Pre-checkout discard: git checkout -- .gsd/ clears dirty runtime files
 
     const repo = initTempRepo();
+    const svc = new GitServiceImpl(repo);
 
-    // Create a subclass that overrides smartStage to simulate failure + fallback
-    class FallbackTestService extends GitServiceImpl {
-      fallbackUsed = false;
-      smartStageWithBadPathspec(): void {
-        // Simulate: try bad pathspec, catch, fallback
-        try {
-          runGit(this.basePath, ["add", "-A", "--", ".", ":(exclude)__NONEXISTENT_PATHSPEC_SYNTAX_ERROR__["]);
-          // If the above doesn't throw, git accepted it (some versions do).
-          // That's fine — the point is testing the fallback path.
-          throw new Error("force fallback for test");
-        } catch {
-          console.error("GitService: smart staging failed, falling back to git add -A");
-          this.fallbackUsed = true;
-          runGit(this.basePath, ["add", "-A"]);
-        }
-      }
-    }
-
-    const svc = new FallbackTestService(repo);
+    // Simulate a repo where .gsd/ files were previously force-added
+    createFile(repo, ".gsd/metrics.json", '{"version":1}');
+    createFile(repo, ".gsd/completed-units.json", '["unit1"]');
+    createFile(repo, ".gsd/activity/log.jsonl", '{"ts":1}');
     createFile(repo, "src/real.ts", "real code");
-    createFile(repo, ".gsd/activity/log.jsonl", "log");
+    // Force-add .gsd/ files to simulate historical tracking
+    runGit(repo, ["add", "-f", ".gsd/metrics.json", ".gsd/completed-units.json", ".gsd/activity/log.jsonl", "src/real.ts"]);
+    runGit(repo, ["commit", "-F", "-"], { input: "init with tracked runtime files" });
+
+    // Add .gitignore with .gsd/ (matches real-world setup from ensureGitignore)
+    createFile(repo, ".gitignore", ".gsd/\n");
+    runGit(repo, ["add", ".gitignore"]);
+    runGit(repo, ["commit", "-F", "-"], { input: "add gitignore" });
+
+    // Verify runtime files are tracked (precondition)
+    const tracked = run("git ls-files .gsd/", repo);
+    assert(tracked.includes("metrics.json"), "precondition: metrics.json tracked");
+    assert(tracked.includes("completed-units.json"), "precondition: completed-units.json tracked");
+    assert(tracked.includes("activity/log.jsonl"), "precondition: activity log tracked");
+
+    // Now modify both runtime and real files
+    createFile(repo, ".gsd/metrics.json", '{"version":2}');
+    createFile(repo, ".gsd/completed-units.json", '["unit1","unit2"]');
+    createFile(repo, ".gsd/activity/log.jsonl", '{"ts":2}');
+    createFile(repo, "src/real.ts", "updated code");
+
+    // autoCommit should commit real.ts. The first call also runs auto-cleanup
+    // which removes runtime files from the index via a dedicated commit.
+    const msg = svc.autoCommit("execute-task", "M001/S01/T01");
+    assert(msg !== null, "autoCommit produces a commit");
+
+    const show = run("git show --stat HEAD", repo);
+    assert(show.includes("src/real.ts"), "real files are committed");
+
+    // After the commit, runtime files must no longer be in the git index.
+    // They remain on disk but are untracked (protected by .gitignore).
+    const trackedAfter = run("git ls-files .gsd/", repo);
+    assertEq(trackedAfter, "", "no .gsd/ runtime files remain in the index");
 
-    // Call the fallback path manually
-    svc.smartStageWithBadPathspec();
+    // Verify a second autoCommit with changed runtime files does NOT stage them
+    createFile(repo, ".gsd/metrics.json", '{"version":3}');
+    createFile(repo, ".gsd/completed-units.json", '["unit1","unit2","unit3"]');
+    createFile(repo, "src/real.ts", "third version");
 
-    // Check that everything was staged (fallback stages all)
-    const staged = run("git diff --cached --name-only", repo);
-    assert(staged.includes("src/real.ts"), "fallback stages real files");
-    assert(staged.includes(".gsd/activity/log.jsonl"), "fallback stages runtime files too (no exclusion)");
-    assert(svc.fallbackUsed, "fallback path was actually used");
+    const msg2 = svc.autoCommit("execute-task", "M001/S01/T02");
+    assert(msg2 !== null, "second autoCommit produces a commit");
+
+    const show2 = run("git show --stat HEAD", repo);
+    assert(show2.includes("src/real.ts"), "real files committed in second commit");
+    assert(!show2.includes("metrics"), "metrics.json not in second commit");
+    assert(!show2.includes("completed-units"), "completed-units.json not in second commit");
+    assert(!show2.includes("activity"), "activity not in second commit");
 
     rmSync(repo, { recursive: true, force: true });
   }
@@ -1345,6 +1370,58 @@ async function main(): Promise<void> {
     assert(true, "PreMergeCheckResult type exported and usable");
   }
 
+  // ─── untrackRuntimeFiles: removes tracked runtime files from index ───
+
+  console.log("\n=== untrackRuntimeFiles ===");
+
+  {
+    const { untrackRuntimeFiles } = await import("../gitignore.ts");
+    const repo = mkdtempSync(join(tmpdir(), "gsd-untrack-"));
+    run("git init -b main", repo);
+    run("git config user.email test@test.com", repo);
+    run("git config user.name Test", repo);
+
+    // Create and track runtime files (simulates pre-.gitignore state)
+    mkdirSync(join(repo, ".gsd", "activity"), { recursive: true });
+    mkdirSync(join(repo, ".gsd", "runtime"), { recursive: true });
+    writeFileSync(join(repo, ".gsd", "completed-units.json"), '["u1"]');
+    writeFileSync(join(repo, ".gsd", "metrics.json"), '{}');
+    writeFileSync(join(repo, ".gsd", "STATE.md"), "# State");
+    writeFileSync(join(repo, ".gsd", "activity", "log.jsonl"), "{}");
+    writeFileSync(join(repo, ".gsd", "runtime", "data.json"), "{}");
+    writeFileSync(join(repo, "src.ts"), "code");
+    run("git add -A", repo);
+    run("git commit -m init", repo);
+
+    // Precondition: runtime files are tracked
+    const trackedBefore = run("git ls-files .gsd/", repo);
+    assert(trackedBefore.includes("completed-units.json"), "untrack: precondition — completed-units tracked");
+    assert(trackedBefore.includes("metrics.json"), "untrack: precondition — metrics tracked");
+
+    // Run untrackRuntimeFiles
+    untrackRuntimeFiles(repo);
+
+    // Runtime files should be removed from the index
+    const trackedAfter = run("git ls-files .gsd/", repo);
+    assertEq(trackedAfter, "", "untrack: all runtime files removed from index");
+
+    // Non-runtime files remain tracked
+    const srcTracked = run("git ls-files src.ts", repo);
+    assert(srcTracked.includes("src.ts"), "untrack: non-runtime files remain tracked");
+
+    // Files still exist on disk
+    assert(existsSync(join(repo, ".gsd", "completed-units.json")),
+      "untrack: completed-units.json still on disk");
+    assert(existsSync(join(repo, ".gsd", "metrics.json")),
+      "untrack: metrics.json still on disk");
+
+    // Idempotent — running again doesn't error
+    untrackRuntimeFiles(repo);
+    assert(true, "untrack: second call is idempotent (no error)");
+
+    rmSync(repo, { recursive: true, force: true });
+  }
+
   console.log(`\nResults: ${passed} passed, ${failed} failed`);
   if (failed > 0) process.exit(1);
   console.log("All tests passed ✓");

package/src/resources/extensions/gsd/tests/reassess-prompt.test.ts

@@ -54,7 +54,7 @@ async function main(): Promise<void> {
     const testVars = {
       milestoneId: "M099",
       completedSliceId: "S03",
-      assessmentAbsPath: ".gsd/milestones/M099/slices/S03/S03-ASSESSMENT.md",
+      assessmentPath: ".gsd/milestones/M099/slices/S03/S03-ASSESSMENT.md",
       roadmapPath: ".gsd/milestones/M099/M099-ROADMAP.md",
       inlinedContext: "--- test inlined context block ---",
     };
@@ -75,14 +75,14 @@ async function main(): Promise<void> {
     // Verify all test variables were substituted into the output
     assert(result.includes("M099"), "prompt contains milestoneId 'M099'");
     assert(result.includes("S03"), "prompt contains completedSliceId 'S03'");
-    assert(result.includes(".gsd/milestones/M099/slices/S03/S03-ASSESSMENT.md"), "prompt contains assessmentAbsPath");
+    assert(result.includes(".gsd/milestones/M099/slices/S03/S03-ASSESSMENT.md"), "prompt contains assessmentPath");
     assert(result.includes(".gsd/milestones/M099/M099-ROADMAP.md"), "prompt contains roadmapPath");
     assert(result.includes("--- test inlined context block ---"), "prompt contains inlinedContext");
 
     // Verify no un-substituted variables remain
     assert(!result.includes("{{milestoneId}}"), "no un-substituted {{milestoneId}}");
     assert(!result.includes("{{completedSliceId}}"), "no un-substituted {{completedSliceId}}");
-    assert(!result.includes("{{assessmentAbsPath}}"), "no un-substituted {{assessmentAbsPath}}");
+    assert(!result.includes("{{assessmentPath}}"), "no un-substituted {{assessmentPath}}");
     assert(!result.includes("{{roadmapPath}}"), "no un-substituted {{roadmapPath}}");
     assert(!result.includes("{{inlinedContext}}"), "no un-substituted {{inlinedContext}}");
   }
@@ -93,7 +93,7 @@ async function main(): Promise<void> {
     const prompt = loadPromptFromWorktree("reassess-roadmap", {
       milestoneId: "M001",
       completedSliceId: "S01",
-      assessmentAbsPath: ".gsd/milestones/M001/slices/S01/S01-ASSESSMENT.md",
+      assessmentPath: ".gsd/milestones/M001/slices/S01/S01-ASSESSMENT.md",
       roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md",
       inlinedContext: "context",
     });
@@ -132,7 +132,7 @@ async function main(): Promise<void> {
     const prompt = loadPromptFromWorktree("reassess-roadmap", {
       milestoneId: "M001",
       completedSliceId: "S01",
-      assessmentAbsPath: ".gsd/milestones/M001/slices/S01/S01-ASSESSMENT.md",
+      assessmentPath: ".gsd/milestones/M001/slices/S01/S01-ASSESSMENT.md",
       roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md",
       inlinedContext: "context",
     });

package/src/resources/extensions/gsd/tests/replan-slice.test.ts

@@ -404,12 +404,13 @@ console.log('\n=== prompt: replan-slice contains preserve-completed-tasks instru
     slicePath: '.gsd/milestones/M001/slices/S01',
     planPath: '.gsd/milestones/M001/slices/S01/S01-PLAN.md',
     blockerTaskId: 'T01',
+    replanPath: '.gsd/milestones/M001/slices/S01/S01-REPLAN.md',
     inlinedContext: '',
   });
 
   assert(prompt.includes('Do NOT renumber or remove completed tasks'), 'prompt contains preserve-completed-tasks instruction');
   assert(prompt.includes('[x]'), 'prompt mentions [x] checkmarks');
-  assert(prompt.includes('replanAbsPath') || prompt.includes('REPLAN'), 'prompt references replan output path');
+  assert(prompt.includes('REPLAN'), 'prompt references replan output path');
   assert(prompt.includes('blocker_discovered'), 'prompt mentions blocker_discovered');
 }
 

package/src/resources/extensions/gsd/tests/roadmap-slices.test.ts

@@ -0,0 +1,59 @@
+import { parseRoadmap } from "../files.ts";
+import { parseRoadmapSlices } from "../roadmap-slices.ts";
+
+let passed = 0;
+let failed = 0;
+
+function assert(condition: boolean, message: string): void {
+  if (condition) passed += 1;
+  else {
+    failed += 1;
+    console.error(`FAIL: ${message}`);
+  }
+}
+
+function assertEq<T>(actual: T, expected: T, message: string): void {
+  if (JSON.stringify(actual) === JSON.stringify(expected)) passed += 1;
+  else {
+    failed += 1;
+    console.error(`FAIL: ${message} — expected ${JSON.stringify(expected)}, got ${JSON.stringify(actual)}`);
+  }
+}
+
+const content = `# M003: Current
+
+**Vision:** Build the thing.
+
+## Slices
+- [x] **S01: First Slice** \`risk:low\` \`depends:[]\`
+  > After this: First demo works.
+- [ ] **S02: Second Slice** \`risk:medium\` \`depends:[S01]\`
+- [x] **S03: Third Slice** \`depends:[S01, S02]\`
+  > After this: Third demo works.
+
+## Boundary Map
+### S01 → S02
+Produces:
+  foo.ts
+`;
+
+console.log("\n=== parseRoadmapSlices ===");
+const slices = parseRoadmapSlices(content);
+assertEq(slices.length, 3, "slice count");
+assertEq(slices[0]?.id, "S01", "first id");
+assertEq(slices[0]?.done, true, "first done");
+assertEq(slices[0]?.demo, "First demo works.", "first demo");
+assertEq(slices[1]?.depends, ["S01"], "second depends");
+assertEq(slices[1]?.risk, "medium", "second risk");
+assertEq(slices[2]?.risk, "low", "missing risk defaults to low");
+assertEq(slices[2]?.depends, ["S01", "S02"], "third depends");
+
+console.log("\n=== parseRoadmap integration ===");
+const roadmap = parseRoadmap(content);
+assertEq(roadmap.slices, slices, "parseRoadmap uses extracted slice parser");
+assertEq(roadmap.title, "M003: Current", "roadmap title preserved");
+assertEq(roadmap.vision, "Build the thing.", "roadmap vision preserved");
+assert(roadmap.boundaryMap.length === 1, "boundary map still parsed");
+
+console.log(`Passed: ${passed}, Failed: ${failed}`);
+if (failed > 0) process.exit(1);