gsd-pi 2.26.0 → 2.27.0

package/src/resources/extensions/gsd/tests/parallel-merge.test.ts

@@ -0,0 +1,465 @@
+/**
+ * parallel-merge.test.ts — Tests for parallel merge reconciliation (G5).
+ *
+ * Covers:
+ *   - determineMergeOrder: sequential vs by-completion ordering, filtering
+ *   - formatMergeResults: success, conflict, empty, mixed output formatting
+ *   - mergeCompletedMilestone: clean merge with session cleanup, missing roadmap,
+ *     conflict detection with structured error
+ *   - mergeAllCompleted: stop-on-first-conflict, sequential execution order
+ *
+ * Pure-function tests need no git. Integration tests use temp repos with real
+ * git operations (same pattern as auto-worktree-milestone-merge.test.ts).
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  writeFileSync,
+  rmSync,
+  existsSync,
+  realpathSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execSync } from "node:child_process";
+
+import {
+  determineMergeOrder,
+  mergeCompletedMilestone,
+  mergeAllCompleted,
+  formatMergeResults,
+  type MergeResult,
+} from "../parallel-merge.ts";
+import type { WorkerInfo } from "../parallel-orchestrator.ts";
+import {
+  writeSessionStatus,
+  readSessionStatus,
+} from "../session-status-io.ts";
+
+// ─── Helpers ──────────────────────────────────────────────────────────────────
+
+function run(cmd: string, cwd: string): string {
+  return execSync(cmd, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createTempRepo(): string {
+  const dir = realpathSync(mkdtempSync(join(tmpdir(), "parallel-merge-test-")));
+  run("git init -b main", dir);
+  run("git config user.email test@test.com", dir);
+  run("git config user.name Test", dir);
+  writeFileSync(join(dir, "README.md"), "# test\n");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  writeFileSync(join(dir, ".gsd", "STATE.md"), "# State\n");
+  run("git add .", dir);
+  run("git commit -m init", dir);
+  return dir;
+}
+
+function makeWorker(overrides: Partial<WorkerInfo> = {}): WorkerInfo {
+  return {
+    milestoneId: "M001",
+    title: "Test milestone",
+    pid: process.pid,
+    process: null,
+    worktreePath: "/tmp/test",
+    startedAt: Date.now(),
+    state: "stopped",
+    completedUnits: 3,
+    cost: 1.5,
+    ...overrides,
+  };
+}
+
+function cleanup(dir: string): void {
+  try { rmSync(dir, { recursive: true, force: true }); } catch { /* */ }
+}
+
+/** Set up a milestone roadmap file in .gsd/milestones/<MID>/ */
+function setupRoadmap(repo: string, mid: string, title: string, slices: string[]): void {
+  const dir = join(repo, ".gsd", "milestones", mid);
+  mkdirSync(dir, { recursive: true });
+  const sliceLines = slices.map(s => `- [x] **${s}**`).join("\n");
+  writeFileSync(
+    join(dir, `${mid}-ROADMAP.md`),
+    `# ${mid}: ${title}\n\n## Slices\n${sliceLines}\n`,
+  );
+}
+
+/** Create a milestone branch with file changes, then return to main. */
+function createMilestoneBranch(
+  repo: string,
+  mid: string,
+  files: Array<{ name: string; content: string }>,
+): void {
+  run(`git checkout -b milestone/${mid}`, repo);
+  for (const f of files) {
+    const dir = join(repo, ...f.name.split("/").slice(0, -1));
+    if (dir !== repo) mkdirSync(dir, { recursive: true });
+    writeFileSync(join(repo, f.name), f.content);
+  }
+  run("git add .", repo);
+  run(`git commit -m "feat(${mid}): add files"`, repo);
+  run("git checkout main", repo);
+}
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// determineMergeOrder — Pure function tests
+// ═══════════════════════════════════════════════════════════════════════════════
+
+test("determineMergeOrder — sequential sorts by milestone ID", () => {
+  const workers = [
+    makeWorker({ milestoneId: "M003", startedAt: 100 }),
+    makeWorker({ milestoneId: "M001", startedAt: 300 }),
+    makeWorker({ milestoneId: "M002", startedAt: 200 }),
+  ];
+  const order = determineMergeOrder(workers, "sequential");
+  assert.deepEqual(order, ["M001", "M002", "M003"]);
+});
+
+test("determineMergeOrder — by-completion sorts by startedAt (earliest first)", () => {
+  const workers = [
+    makeWorker({ milestoneId: "M003", startedAt: 100 }),
+    makeWorker({ milestoneId: "M001", startedAt: 300 }),
+    makeWorker({ milestoneId: "M002", startedAt: 200 }),
+  ];
+  const order = determineMergeOrder(workers, "by-completion");
+  assert.deepEqual(order, ["M003", "M002", "M001"]);
+});
+
+test("determineMergeOrder — only includes stopped workers with completedUnits > 0", () => {
+  const workers = [
+    makeWorker({ milestoneId: "M001", state: "stopped", completedUnits: 3 }),
+    makeWorker({ milestoneId: "M002", state: "running", completedUnits: 2 }),
+    makeWorker({ milestoneId: "M003", state: "stopped", completedUnits: 0 }),
+    makeWorker({ milestoneId: "M004", state: "error", completedUnits: 5 }),
+    makeWorker({ milestoneId: "M005", state: "paused", completedUnits: 1 }),
+  ];
+  const order = determineMergeOrder(workers, "sequential");
+  assert.deepEqual(order, ["M001"]);
+});
+
+test("determineMergeOrder — empty workers returns empty array", () => {
+  assert.deepEqual(determineMergeOrder([], "sequential"), []);
+  assert.deepEqual(determineMergeOrder([], "by-completion"), []);
+});
+
+test("determineMergeOrder — defaults to sequential when order not specified", () => {
+  const workers = [
+    makeWorker({ milestoneId: "M002" }),
+    makeWorker({ milestoneId: "M001" }),
+  ];
+  const order = determineMergeOrder(workers);
+  assert.deepEqual(order, ["M001", "M002"]);
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// formatMergeResults — Pure function tests
+// ═══════════════════════════════════════════════════════════════════════════════
+
+test("formatMergeResults — empty results", () => {
+  const output = formatMergeResults([]);
+  assert.ok(output.includes("No completed milestones"));
+});
+
+test("formatMergeResults — successful merge", () => {
+  const results: MergeResult[] = [
+    { milestoneId: "M001", success: true, commitMessage: "feat(M001): Auth", pushed: true },
+  ];
+  const output = formatMergeResults(results);
+  assert.ok(output.includes("M001"));
+  assert.ok(output.includes("merged successfully"));
+  assert.ok(output.includes("(pushed)"));
+});
+
+test("formatMergeResults — successful merge without push", () => {
+  const results: MergeResult[] = [
+    { milestoneId: "M001", success: true, commitMessage: "feat(M001): Auth", pushed: false },
+  ];
+  const output = formatMergeResults(results);
+  assert.ok(output.includes("merged successfully"));
+  assert.ok(!output.includes("(pushed)"));
+});
+
+test("formatMergeResults — conflict with file list", () => {
+  const results: MergeResult[] = [
+    {
+      milestoneId: "M002",
+      success: false,
+      error: "Merge conflict: 2 conflicting file(s)",
+      conflictFiles: ["src/app.ts", "src/main.ts"],
+    },
+  ];
+  const output = formatMergeResults(results);
+  assert.ok(output.includes("CONFLICT"));
+  assert.ok(output.includes("src/app.ts"));
+  assert.ok(output.includes("src/main.ts"));
+  assert.ok(output.includes("Resolve conflicts manually"));
+});
+
+test("formatMergeResults — generic failure without conflict files", () => {
+  const results: MergeResult[] = [
+    { milestoneId: "M003", success: false, error: "No roadmap found for M003" },
+  ];
+  const output = formatMergeResults(results);
+  assert.ok(output.includes("M003"));
+  assert.ok(output.includes("failed"));
+  assert.ok(output.includes("No roadmap found"));
+});
+
+test("formatMergeResults — mixed results", () => {
+  const results: MergeResult[] = [
+    { milestoneId: "M001", success: true, commitMessage: "feat(M001): OK", pushed: false },
+    { milestoneId: "M002", success: false, error: "conflict", conflictFiles: ["a.ts"] },
+  ];
+  const output = formatMergeResults(results);
+  assert.ok(output.includes("M001"));
+  assert.ok(output.includes("merged successfully"));
+  assert.ok(output.includes("M002"));
+  assert.ok(output.includes("CONFLICT"));
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// mergeCompletedMilestone — Integration tests (real git)
+// ═══════════════════════════════════════════════════════════════════════════════
+
+test("mergeCompletedMilestone — missing roadmap returns error result", async () => {
+  const base = join(tmpdir(), `parallel-merge-noroadmap-${Date.now()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  try {
+    const result = await mergeCompletedMilestone(base, "M999");
+    assert.equal(result.success, false);
+    assert.ok(result.error?.includes("No roadmap found") || result.error?.includes("Could not read"));
+    assert.equal(result.milestoneId, "M999");
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("mergeCompletedMilestone — clean merge, session status cleaned up", async () => {
+  const savedCwd = process.cwd();
+  const repo = createTempRepo();
+
+  try {
+    // Create milestone branch with a new file
+    createMilestoneBranch(repo, "M010", [
+      { name: "auth.ts", content: "export const auth = true;\n" },
+    ]);
+
+    // Set up roadmap
+    setupRoadmap(repo, "M010", "Auth System", ["S01: JWT module"]);
+
+    // Write session status to verify cleanup
+    writeSessionStatus(repo, {
+      milestoneId: "M010",
+      pid: process.pid,
+      state: "stopped",
+      currentUnit: null,
+      completedUnits: 3,
+      cost: 1.5,
+      lastHeartbeat: Date.now(),
+      startedAt: Date.now() - 60000,
+      worktreePath: join(repo, ".gsd", "worktrees", "M010"),
+    });
+
+    // Verify session status exists before merge
+    const statusBefore = readSessionStatus(repo, "M010");
+    assert.ok(statusBefore, "session status should exist before merge");
+
+    // Merge from project root
+    process.chdir(repo);
+    const result = await mergeCompletedMilestone(repo, "M010");
+
+    assert.equal(result.success, true, `merge should succeed: ${result.error}`);
+    assert.ok(result.commitMessage, "should have commit message");
+    assert.equal(result.milestoneId, "M010");
+
+    // Verify file merged to main
+    assert.ok(existsSync(join(repo, "auth.ts")), "auth.ts should be on main");
+
+    // Verify commit on main
+    const log = run("git log --oneline main", repo);
+    assert.ok(log.includes("M010"), "commit message should reference M010");
+
+    // Verify session status cleaned up
+    const statusAfter = readSessionStatus(repo, "M010");
+    assert.equal(statusAfter, null, "session status should be cleaned up after merge");
+
+    // Verify milestone branch deleted
+    const branches = run("git branch", repo);
+    assert.ok(!branches.includes("milestone/M010"), "milestone branch should be deleted");
+  } finally {
+    process.chdir(savedCwd);
+    cleanup(repo);
+  }
+});
+
+test("mergeCompletedMilestone — conflict returns structured error with file list", async () => {
+  const savedCwd = process.cwd();
+  const repo = createTempRepo();
+
+  try {
+    // Create milestone branch that modifies README.md
+    run("git checkout -b milestone/M020", repo);
+    writeFileSync(join(repo, "README.md"), "# M020 version\n");
+    run("git add .", repo);
+    run('git commit -m "M020 changes README"', repo);
+    run("git checkout main", repo);
+
+    // Modify README.md on main to create conflict
+    writeFileSync(join(repo, "README.md"), "# main version (diverged)\n");
+    run("git add .", repo);
+    run('git commit -m "main changes README"', repo);
+
+    // Set up roadmap
+    setupRoadmap(repo, "M020", "Conflict Test", ["S01: Conflict scenario"]);
+
+    process.chdir(repo);
+    const result = await mergeCompletedMilestone(repo, "M020");
+
+    assert.equal(result.success, false, "merge should fail with conflict");
+    assert.equal(result.milestoneId, "M020");
+    assert.ok(result.conflictFiles, "should have conflictFiles");
+    assert.ok(result.conflictFiles!.length > 0, "should have at least one conflict file");
+    assert.ok(result.conflictFiles!.includes("README.md"), "README.md should be in conflicts");
+    assert.ok(result.error?.includes("conflict"), "error message should mention conflict");
+  } finally {
+    process.chdir(savedCwd);
+    // Reset git state before cleanup (repo may be in conflicted state)
+    try { run("git reset --hard HEAD", repo); } catch { /* */ }
+    cleanup(repo);
+  }
+});
+
+// ═══════════════════════════════════════════════════════════════════════════════
+// mergeAllCompleted — Integration tests
+// ═══════════════════════════════════════════════════════════════════════════════
+
+test("mergeAllCompleted — merges in sequential order", async () => {
+  const savedCwd = process.cwd();
+  const repo = createTempRepo();
+
+  try {
+    // M001: adds auth.ts
+    createMilestoneBranch(repo, "M001", [
+      { name: "auth.ts", content: "export const auth = true;\n" },
+    ]);
+    // M002: adds dashboard.ts
+    createMilestoneBranch(repo, "M002", [
+      { name: "dashboard.ts", content: "export const dash = true;\n" },
+    ]);
+
+    setupRoadmap(repo, "M001", "Auth", ["S01: Auth module"]);
+    setupRoadmap(repo, "M002", "Dashboard", ["S01: Dashboard module"]);
+
+    const workers = [
+      makeWorker({ milestoneId: "M002", startedAt: 100 }),
+      makeWorker({ milestoneId: "M001", startedAt: 200 }),
+    ];
+
+    process.chdir(repo);
+    const results = await mergeAllCompleted(repo, workers, "sequential");
+
+    // Both should succeed
+    assert.equal(results.length, 2, "should have two results");
+    assert.equal(results[0]!.milestoneId, "M001", "M001 merged first (sequential)");
+    assert.equal(results[0]!.success, true, "M001 should succeed");
+    assert.equal(results[1]!.milestoneId, "M002", "M002 merged second");
+    assert.equal(results[1]!.success, true, "M002 should succeed");
+
+    // Both files on main
+    assert.ok(existsSync(join(repo, "auth.ts")), "auth.ts on main");
+    assert.ok(existsSync(join(repo, "dashboard.ts")), "dashboard.ts on main");
+  } finally {
+    process.chdir(savedCwd);
+    cleanup(repo);
+  }
+});
+
+test("mergeAllCompleted — stops on first conflict, skips later milestones", async () => {
+  const savedCwd = process.cwd();
+  const repo = createTempRepo();
+
+  try {
+    // M001: modifies README.md (will conflict with main)
+    run("git checkout -b milestone/M001", repo);
+    writeFileSync(join(repo, "README.md"), "# M001 version\n");
+    run("git add .", repo);
+    run('git commit -m "M001 changes README"', repo);
+    run("git checkout main", repo);
+
+    // M002: adds a new file (would NOT conflict)
+    createMilestoneBranch(repo, "M002", [
+      { name: "feature.ts", content: "export const feature = true;\n" },
+    ]);
+
+    // Modify README.md on main to create conflict with M001
+    writeFileSync(join(repo, "README.md"), "# main diverged version\n");
+    run("git add .", repo);
+    run('git commit -m "main diverges README"', repo);
+
+    setupRoadmap(repo, "M001", "Conflict milestone", ["S01: Conflict test"]);
+    setupRoadmap(repo, "M002", "Clean milestone", ["S01: Clean test"]);
+
+    const workers = [
+      makeWorker({ milestoneId: "M001" }),
+      makeWorker({ milestoneId: "M002" }),
+    ];
+
+    process.chdir(repo);
+    const results = await mergeAllCompleted(repo, workers, "sequential");
+
+    // Only M001 attempted (conflict stops the queue)
+    assert.equal(results.length, 1, "should only have one result — stopped after conflict");
+    assert.equal(results[0]!.milestoneId, "M001");
+    assert.equal(results[0]!.success, false, "M001 should fail");
+    assert.ok(results[0]!.conflictFiles && results[0]!.conflictFiles.length > 0, "should have conflict files");
+
+    // M002 was NOT attempted
+    assert.ok(!results.some(r => r.milestoneId === "M002"), "M002 should not be attempted");
+
+    // feature.ts should NOT be on main (M002 never merged)
+    assert.ok(!existsSync(join(repo, "feature.ts")), "feature.ts should not be on main");
+  } finally {
+    process.chdir(savedCwd);
+    try { run("git reset --hard HEAD", repo); } catch { /* */ }
+    cleanup(repo);
+  }
+});
+
+test("mergeAllCompleted — by-completion order respects startedAt", async () => {
+  const savedCwd = process.cwd();
+  const repo = createTempRepo();
+
+  try {
+    // M001: adds auth.ts (started later)
+    createMilestoneBranch(repo, "M001", [
+      { name: "auth.ts", content: "export const auth = true;\n" },
+    ]);
+    // M002: adds feature.ts (started earlier)
+    createMilestoneBranch(repo, "M002", [
+      { name: "feature.ts", content: "export const feature = true;\n" },
+    ]);
+
+    setupRoadmap(repo, "M001", "Auth", ["S01: Auth module"]);
+    setupRoadmap(repo, "M002", "Feature", ["S01: Feature module"]);
+
+    const workers = [
+      makeWorker({ milestoneId: "M001", startedAt: 2000 }),
+      makeWorker({ milestoneId: "M002", startedAt: 1000 }),
+    ];
+
+    process.chdir(repo);
+    const results = await mergeAllCompleted(repo, workers, "by-completion");
+
+    // M002 should be merged first (earlier startedAt)
+    assert.equal(results.length, 2);
+    assert.equal(results[0]!.milestoneId, "M002", "M002 merged first (earlier startedAt)");
+    assert.equal(results[1]!.milestoneId, "M001", "M001 merged second");
+  } finally {
+    process.chdir(savedCwd);
+    cleanup(repo);
+  }
+});

package/src/resources/extensions/gsd/tests/parallel-orchestration.test.ts

@@ -35,6 +35,7 @@ import {
   getWorkerStatuses,
   startParallel,
   stopParallel,
+  shutdownParallel,
   pauseWorker,
   resumeWorker,
   getAggregateCost,
@@ -301,7 +302,9 @@ describe("parallel-orchestrator: lifecycle", () => {
     const status = readSessionStatus(base, "M001");
     assert.ok(status);
     assert.equal(status.milestoneId, "M001");
-    assert.equal(status.state, "running");
+    // State is "running" if spawn succeeds, "error" if binary not found (CI)
+    assert.ok(status.state === "running" || status.state === "error",
+      `expected running or error, got ${status.state}`);
   });
 
   it("stopParallel stops all workers", async () => {
@@ -319,24 +322,50 @@ describe("parallel-orchestrator: lifecycle", () => {
     const m1 = workers.find(w => w.milestoneId === "M001");
     const m2 = workers.find(w => w.milestoneId === "M002");
     assert.equal(m1?.state, "stopped");
-    assert.equal(m2?.state, "running");
+    // M002 is "running" if spawn succeeded, "error" if binary not found (CI)
+    assert.ok(m2?.state === "running" || m2?.state === "error",
+      `expected running or error, got ${m2?.state}`);
     assert.equal(isParallelActive(), true);
   });
 
   it("pauseWorker and resumeWorker toggle worker state", async () => {
     await startParallel(base, ["M001"], undefined);
-    pauseWorker(base, "M001");
-    assert.equal(getWorkerStatuses()[0].state, "paused");
-    resumeWorker(base, "M001");
-    assert.equal(getWorkerStatuses()[0].state, "running");
+    const initial = getWorkerStatuses()[0].state;
+    // Only test pause/resume if worker is in a pausable state
+    if (initial === "running") {
+      pauseWorker(base, "M001");
+      assert.equal(getWorkerStatuses()[0].state, "paused");
+      resumeWorker(base, "M001");
+      assert.equal(getWorkerStatuses()[0].state, "running");
+    } else {
+      // Spawn failed (CI) — pause/resume are no-ops on error state
+      pauseWorker(base, "M001");
+      assert.equal(getWorkerStatuses()[0].state, initial);
+    }
   });
 
   it("pauseWorker sends pause signal", async () => {
     await startParallel(base, ["M001"], undefined);
-    pauseWorker(base, "M001");
-    const signal = consumeSignal(base, "M001");
-    assert.ok(signal);
-    assert.equal(signal.signal, "pause");
+    const w = getWorkerStatuses()[0];
+    if (w.state === "running") {
+      pauseWorker(base, "M001");
+      const signal = consumeSignal(base, "M001");
+      assert.ok(signal);
+      assert.equal(signal.signal, "pause");
+    } else {
+      // Spawn failed — pauseWorker is a no-op, signal not written
+      pauseWorker(base, "M001");
+      const signal = consumeSignal(base, "M001");
+      assert.equal(signal, null);
+    }
+  });
+
+  it("shutdownParallel deactivates the orchestrator state", async () => {
+    await startParallel(base, ["M001"], undefined);
+    assert.equal(isParallelActive(), true);
+    await shutdownParallel(base);
+    assert.equal(isParallelActive(), false);
+    assert.equal(getOrchestratorState(), null);
   });
 });
 

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

@@ -0,0 +1,71 @@
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { createTestContext } from './test-helpers.ts';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const worktreePromptsDir = join(__dirname, "..", "prompts");
+
+const { assertTrue, report } = createTestContext();
+
+function loadPromptFromWorktree(name: string, vars: Record<string, string> = {}): string {
+  const path = join(worktreePromptsDir, `${name}.md`);
+  let content = readFileSync(path, "utf-8");
+  for (const [key, value] of Object.entries(vars)) {
+    content = content.replaceAll(`{{${key}}}`, value);
+  }
+  return content.trim();
+}
+
+const BASE_VARS = {
+  workingDirectory: "/tmp/test-project",
+  milestoneId: "M001",
+  sliceId: "S01",
+  sliceTitle: "Test Slice",
+  slicePath: ".gsd/milestones/M001/slices/S01",
+  roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md",
+  researchPath: ".gsd/milestones/M001/slices/S01/S01-RESEARCH.md",
+  outputPath: "/tmp/test-project/.gsd/milestones/M001/slices/S01/S01-PLAN.md",
+  inlinedContext: "--- test inlined context ---",
+  dependencySummaries: "",
+  executorContextConstraints: "",
+};
+
+async function main(): Promise<void> {
+
+  // ─── commit_docs=true (default): commit step is present ─────────────────
+  console.log("\n=== plan-slice prompt: commit_docs default (true) ===");
+  {
+    const commitInstruction = `Commit: \`docs(S01): add slice plan\``;
+    const result = loadPromptFromWorktree("plan-slice", { ...BASE_VARS, commitInstruction });
+
+    assertTrue(result.includes("docs(S01): add slice plan"), "commit step present when commit_docs is not false");
+    assertTrue(result.includes("Update `.gsd/STATE.md`"), "STATE.md update step present");
+    assertTrue(!result.includes("{{commitInstruction}}"), "no unresolved placeholder");
+  }
+
+  // ─── commit_docs=false: no commit step, only STATE.md update ────────────
+  console.log("\n=== plan-slice prompt: commit_docs=false ===");
+  {
+    const commitInstruction = "Do not commit — planning docs are not tracked in git for this project.";
+    const result = loadPromptFromWorktree("plan-slice", { ...BASE_VARS, commitInstruction });
+
+    assertTrue(!result.includes("docs(S01): add slice plan"), "commit step absent when commit_docs=false");
+    assertTrue(result.includes("Do not commit"), "no-commit instruction present");
+    assertTrue(result.includes("Update `.gsd/STATE.md`"), "STATE.md update step still present");
+    assertTrue(!result.includes("{{commitInstruction}}"), "no unresolved placeholder");
+  }
+
+  // ─── all base variables are substituted ─────────────────────────────────
+  console.log("\n=== plan-slice prompt: all variables substituted ===");
+  {
+    const commitInstruction = `Commit: \`docs(S01): add slice plan\``;
+    const result = loadPromptFromWorktree("plan-slice", { ...BASE_VARS, commitInstruction });
+
+    assertTrue(!result.includes("{{"), "no unresolved placeholders remain");
+    assertTrue(result.includes("M001"), "milestoneId substituted");
+    assertTrue(result.includes("S01"), "sliceId substituted");
+  }
+}
+
+main().then(report);

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

@@ -40,6 +40,7 @@ function writeRoadmap(base: string, mid: string, content: string): void {
 function writePlan(base: string, mid: string, sid: string, content: string): void {
   const dir = join(base, '.gsd', 'milestones', mid, 'slices', sid);
   mkdirSync(join(dir, 'tasks'), { recursive: true });
+  writeFileSync(join(dir, "tasks", "T01-PLAN.md"), "# T01 Plan\n");
   writeFileSync(join(dir, `${sid}-PLAN.md`), content);
 }
 
@@ -493,4 +494,45 @@ console.log('\n=== doctor: no blocker → no blocker_discovered_no_replan issue
   rmSync(base, { recursive: true, force: true });
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Artifact Resolution: resolveExpectedArtifactPath for replan-slice (#858)
+// ═══════════════════════════════════════════════════════════════════════════
+
+import { resolveExpectedArtifactPath, verifyExpectedArtifact } from '../auto-recovery.ts';
+
+console.log('\n=== artifact: resolveExpectedArtifactPath returns REPLAN.md path for replan-slice ===');
+{
+  const base = createFixtureBase();
+  writeRoadmap(base, 'M001', ROADMAP_ONE_SLICE);
+  writePlan(base, 'M001', 'S01', makePlanT01DoneT02Pending());
+
+  const path = resolveExpectedArtifactPath('replan-slice', 'M001/S01', base);
+  assertTrue(path !== null, 'resolveExpectedArtifactPath returns non-null for replan-slice');
+  assertTrue(path!.endsWith('S01-REPLAN.md'), 'path ends with S01-REPLAN.md');
+  rmSync(base, { recursive: true, force: true });
+}
+
+console.log('\n=== artifact: verifyExpectedArtifact fails when REPLAN.md missing (#858) ===');
+{
+  const base = createFixtureBase();
+  writeRoadmap(base, 'M001', ROADMAP_ONE_SLICE);
+  writePlan(base, 'M001', 'S01', makePlanT01DoneT02Pending());
+
+  const result = verifyExpectedArtifact('replan-slice', 'M001/S01', base);
+  assertEq(result, false, 'verifyExpectedArtifact returns false when REPLAN.md is missing');
+  rmSync(base, { recursive: true, force: true });
+}
+
+console.log('\n=== artifact: verifyExpectedArtifact passes when REPLAN.md exists (#858) ===');
+{
+  const base = createFixtureBase();
+  writeRoadmap(base, 'M001', ROADMAP_ONE_SLICE);
+  writePlan(base, 'M001', 'S01', makePlanT01DoneT02Pending());
+  writeReplanFile(base, 'M001', 'S01', '# Replan\n\nBlocker addressed.');
+
+  const result = verifyExpectedArtifact('replan-slice', 'M001/S01', base);
+  assertEq(result, true, 'verifyExpectedArtifact returns true when REPLAN.md exists');
+  rmSync(base, { recursive: true, force: true });
+}
+
 report();