gsd-pi 2.8.1 → 2.8.2

package/src/resources/extensions/gsd/guided-flow.ts

@@ -21,7 +21,7 @@ import {
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, readdirSync, rmSync } from "node:fs";
 import { execSync, execFileSync } from "node:child_process";
-import { ensureGitignore, ensurePreferences } from "./gitignore.js";
+import { ensureGitignore, ensurePreferences, untrackRuntimeFiles } from "./gitignore.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { showConfirm } from "../shared/confirm-ui.js";
 
@@ -87,13 +87,13 @@ function dispatchWorkflow(pi: ExtensionAPI, note: string, customType = "gsd-run"
  * Build the discuss-and-plan prompt for a new milestone.
  * Used by all three "new milestone" paths (first ever, no active, all complete).
  */
-function buildDiscussPrompt(nextId: string, preamble: string, basePath: string): string {
-  const milestoneDirAbs = join(basePath, ".gsd", "milestones", nextId);
+function buildDiscussPrompt(nextId: string, preamble: string, _basePath: string): string {
+  const milestoneRel = `.gsd/milestones/${nextId}`;
   return loadPrompt("discuss", {
     milestoneId: nextId,
     preamble,
-    contextAbsPath: join(milestoneDirAbs, `${nextId}-CONTEXT.md`),
-    roadmapAbsPath: join(milestoneDirAbs, `${nextId}-ROADMAP.md`),
+    contextPath: `${milestoneRel}/${nextId}-CONTEXT.md`,
+    roadmapPath: `${milestoneRel}/${nextId}-ROADMAP.md`,
   });
 }
 
@@ -345,16 +345,16 @@ async function buildDiscussSlicePrompt(
     ? `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`
     : `## Inlined Context\n\n_(no context files found yet — go in blind and ask broad questions)_`;
 
-  const sliceDirAbsPath = join(base, ".gsd", "milestones", mid, "slices", sid);
-  const contextAbsPath = join(sliceDirAbsPath, `${sid}-CONTEXT.md`);
+  const sliceDirPath = `.gsd/milestones/${mid}/slices/${sid}`;
+  const sliceContextPath = `${sliceDirPath}/${sid}-CONTEXT.md`;
 
   return loadPrompt("guided-discuss-slice", {
     milestoneId: mid,
     sliceId: sid,
     sliceTitle: sTitle,
     inlinedContext,
-    sliceDirAbsPath,
-    contextAbsPath,
+    sliceDirPath,
+    contextPath: sliceContextPath,
     projectRoot: base,
   });
 }
@@ -457,6 +457,7 @@ export async function showSmartEntry(
 
   // ── Ensure .gitignore has baseline patterns ──────────────────────────
   ensureGitignore(basePath);
+  untrackRuntimeFiles(basePath);
 
   // ── No GSD project OR no milestone → Create first/next milestone ────
   if (!existsSync(join(basePath, ".gsd"))) {

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

@@ -12,7 +12,7 @@ Then:
 3. Verify each **success criterion** from the milestone definition in `{{roadmapPath}}`. For each criterion, confirm it was met with specific evidence from slice summaries, test results, or observable behavior. List any criterion that was NOT met.
 4. Verify the milestone's **definition of done** — all slices are `[x]`, all slice summaries exist, and any cross-slice integration points work correctly.
 5. Validate **requirement status transitions**. For each requirement that changed status during this milestone, confirm the transition is supported by evidence. Requirements can move between Active, Validated, Deferred, Blocked, or Out of Scope — but only with proof.
-6. Write `{{milestoneSummaryAbsPath}}` using the milestone-summary template. Fill all frontmatter fields and narrative sections. The `requirement_outcomes` field must list every requirement that changed status with `from_status`, `to_status`, and `proof`.
+6. Write `{{milestoneSummaryPath}}` using the milestone-summary template. Fill all frontmatter fields and narrative sections. The `requirement_outcomes` field must list every requirement that changed status with `from_status`, `to_status`, and `proof`.
 7. Update `.gsd/REQUIREMENTS.md` if any requirement status transitions were validated in step 5.
 8. Update `.gsd/PROJECT.md` to reflect milestone completion and current project state.
 9. Do not commit manually — the system auto-commits your changes after this unit completes.
@@ -20,6 +20,6 @@ Then:
 
 **Important:** Do NOT skip the success criteria and definition of done verification (steps 3-4). The milestone summary must reflect actual verified outcomes, not assumed success. If any criterion was not met, document it clearly in the summary and do not mark the milestone as passing verification.
 
-**You MUST write `{{milestoneSummaryAbsPath}}` AND update PROJECT.md before finishing.**
+**You MUST write `{{milestoneSummaryPath}}` AND update PROJECT.md before finishing.**
 
 When done, say: "Milestone {{milestoneId}} complete."

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

@@ -16,14 +16,14 @@ Then:
 3. Run all slice-level verification checks defined in the slice plan. All must pass before marking the slice done. If any fail, fix them first.
 4. If the slice plan includes observability/diagnostic surfaces, confirm they work. Skip this for simple slices that don't have observability sections.
 5. If `.gsd/REQUIREMENTS.md` exists, update it based on what this slice actually proved. Move requirements between Active, Validated, Deferred, Blocked, or Out of Scope only when the evidence from execution supports that change.
-6. Write `{{sliceSummaryAbsPath}}` (compress all task summaries).
-7. Write `{{sliceUatAbsPath}}` — a concrete UAT script with real test cases derived from the slice plan and task summaries. Include preconditions, numbered steps with expected outcomes, and edge cases. This must NOT be a placeholder or generic template — tailor every test case to what this slice actually built.
+6. Write `{{sliceSummaryPath}}` (compress all task summaries).
+7. Write `{{sliceUatPath}}` — a concrete UAT script with real test cases derived from the slice plan and task summaries. Include preconditions, numbered steps with expected outcomes, and edge cases. This must NOT be a placeholder or generic template — tailor every test case to what this slice actually built.
 8. Review task summaries for `key_decisions`. Append any significant decisions to `.gsd/DECISIONS.md` if missing.
 9. Mark {{sliceId}} done in `{{roadmapPath}}` (change `[ ]` to `[x]`)
 10. Do not commit or squash-merge manually — the system auto-commits your changes and handles the merge after this unit succeeds.
 11. Update `.gsd/PROJECT.md` if it exists — refresh current state if needed.
 12. Update `.gsd/STATE.md`
 
-**You MUST do ALL THREE before finishing: (1) write `{{sliceSummaryAbsPath}}`, (2) write `{{sliceUatAbsPath}}`, (3) mark {{sliceId}} as `[x]` in `{{roadmapPath}}`. The unit will not be marked complete if any of these files are missing.**
+**You MUST do ALL THREE before finishing: (1) write `{{sliceSummaryPath}}`, (2) write `{{sliceUatPath}}`, (3) mark {{sliceId}} as `[x]` in `{{roadmapPath}}`. The unit will not be marked complete if any of these files are missing.**
 
 When done, say: "Slice {{sliceId}} complete."

package/src/resources/extensions/gsd/prompts/discuss.md

@@ -191,8 +191,8 @@ Once the user is satisfied, in a single pass:
 **Depth-Preservation Guidance for context.md:**
 When writing context.md, preserve the user's exact terminology, emphasis, and specific framing from the discussion. Do not paraphrase user nuance into generic summaries. If the user said "craft feel," write "craft feel" — not "high-quality user experience." If they emphasized a specific constraint or negative requirement, carry that emphasis through verbatim. The context file is downstream agents' only window into this conversation — flattening specifics into generics loses the signal that shaped every decision.
 
-4. Write `{{contextAbsPath}}` — read the template at `~/.gsd/agent/extensions/gsd/templates/context.md` first. Preserve key risks, unknowns, existing codebase constraints, integration points, and relevant requirements surfaced during discussion.
-5. Write `{{roadmapAbsPath}}` — read the template at `~/.gsd/agent/extensions/gsd/templates/roadmap.md` first. Decompose into demoable vertical slices with checkboxes, risk, depends, demo sentences, proof strategy, verification classes, milestone definition of done, requirement coverage, and a boundary map. If the milestone crosses multiple runtime boundaries, include an explicit final integration slice that proves the assembled system works end-to-end in a real environment.
+4. Write `{{contextPath}}` — read the template at `~/.gsd/agent/extensions/gsd/templates/context.md` first. Preserve key risks, unknowns, existing codebase constraints, integration points, and relevant requirements surfaced during discussion.
+5. Write `{{roadmapPath}}` — read the template at `~/.gsd/agent/extensions/gsd/templates/roadmap.md` first. Decompose into demoable vertical slices with checkboxes, risk, depends, demo sentences, proof strategy, verification classes, milestone definition of done, requirement coverage, and a boundary map. If the milestone crosses multiple runtime boundaries, include an explicit final integration slice that proves the assembled system works end-to-end in a real environment.
 6. Seed `.gsd/DECISIONS.md` — read the template at `~/.gsd/agent/extensions/gsd/templates/decisions.md` first. Append rows for any architectural or pattern decisions made during discussion.
 7. Update `.gsd/STATE.md`
 8. Commit: `docs({{milestoneId}}): context, requirements, and roadmap`

package/src/resources/extensions/gsd/prompts/execute-task.md

@@ -49,13 +49,13 @@ Then:
 11. **Blocker discovery:** If execution reveals that the remaining slice plan is fundamentally invalid — not just a bug or minor deviation, but a plan-invalidating finding like a wrong API, missing capability, or architectural mismatch — set `blocker_discovered: true` in the task summary frontmatter and describe the blocker clearly in the summary narrative. Do NOT set `blocker_discovered: true` for ordinary debugging, minor deviations, or issues that can be fixed within the current task or the remaining plan. This flag triggers an automatic replan of the slice.
 12. If you made an architectural, pattern, library, or observability decision during this task that downstream work should know about, append it to `.gsd/DECISIONS.md` (read the template at `~/.gsd/agent/extensions/gsd/templates/decisions.md` if the file doesn't exist yet). Not every task produces decisions — only append when a meaningful choice was made.
 13. Read the template at `~/.gsd/agent/extensions/gsd/templates/task-summary.md`
-14. Write `{{taskSummaryAbsPath}}`
+14. Write `{{taskSummaryPath}}`
 15. Mark {{taskId}} done in `{{planPath}}` (change `[ ]` to `[x]`)
 16. Do not commit manually — the system auto-commits your changes after this unit completes.
 17. Update `.gsd/STATE.md`
 
 You are on the slice branch. All work stays here.
 
-**You MUST mark {{taskId}} as `[x]` in `{{planPath}}` AND write `{{taskSummaryAbsPath}}` before finishing.**
+**You MUST mark {{taskId}} as `[x]` in `{{planPath}}` AND write `{{taskSummaryPath}}` before finishing.**
 
 When done, say: "Task {{taskId}} complete."

package/src/resources/extensions/gsd/prompts/guided-discuss-slice.md

@@ -46,8 +46,8 @@ If the user wants to keep going, keep asking. Stop when they say wrap up.
 Once the user is ready to wrap up:
 
 1. Read the slice context template at `~/.gsd/agent/extensions/gsd/templates/slice-context.md`
-2. `mkdir -p {{sliceDirAbsPath}}`
-3. Write `{{contextAbsPath}}` — use the template structure, filling in:
+2. `mkdir -p {{sliceDirPath}}`
+3. Write `{{contextPath}}` — use the template structure, filling in:
    - **Goal** — one sentence: what this slice delivers
    - **Why this Slice** — why now, what it unblocks
    - **Scope / In Scope** — what was confirmed in scope during the interview
@@ -55,5 +55,5 @@ Once the user is ready to wrap up:
    - **Constraints** — anything the user flagged as a hard constraint
    - **Integration Points** — what this slice consumes and produces
    - **Open Questions** — anything still unresolved, with current thinking
-4. Commit: `git -C {{projectRoot}} add {{contextAbsPath}} && git -C {{projectRoot}} commit -m "docs({{milestoneId}}/{{sliceId}}): slice context from discuss"`
+4. Commit: `git -C {{projectRoot}} add {{contextPath}} && git -C {{projectRoot}} commit -m "docs({{milestoneId}}/{{sliceId}}): slice context from discuss"`
 5. Say exactly: `"{{sliceId}} context written."` — nothing else.

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/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";
@@ -1370,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/run-uat.test.ts

@@ -226,7 +226,6 @@ async function main(): Promise<void> {
   const milestoneId = 'M001';
   const sliceId = 'S01';
   const uatPath = '.gsd/milestones/M001/slices/S01/S01-UAT.md';
-  const uatResultAbsPath = '/tmp/gsd-test/S01-UAT-RESULT.md';
   const uatResultPath = '.gsd/milestones/M001/slices/S01/S01-UAT-RESULT.md';
   const uatType = 'artifact-driven';
   const inlinedContext = '<!-- no context -->';
@@ -238,7 +237,6 @@ async function main(): Promise<void> {
       milestoneId,
       sliceId,
       uatPath,
-      uatResultAbsPath,
       uatResultPath,
       uatType,
       inlinedContext,
@@ -261,8 +259,8 @@ async function main(): Promise<void> {
     `prompt contains sliceId value "${sliceId}" after substitution`,
   );
   assert(
-    promptResult?.includes(uatResultAbsPath) ?? false,
-    `prompt contains uatResultAbsPath value after substitution`,
+    promptResult?.includes(uatResultPath) ?? false,
+    `prompt contains uatResultPath value after substitution`,
   );
   assert(
     !/\{\{[^}]+\}\}/.test(promptResult ?? ''),