@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

package/src/resources/extensions/gsd/tests/flat-phase-validation-path.test.ts

@@ -0,0 +1,74 @@
+// Project/App: gsd-pi
+// File Purpose: Regression test for upstream issue #876 — flat-phase
+// validation-path readers must use layout-aware helpers, not hardcoded
+// legacy paths.
+
+import { existsSync, mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import { relMilestoneFile, resolveMilestoneFile } from "../paths.ts";
+
+function makeFlatPhaseFixture(): { basePath: string; cleanup: () => void } {
+  const basePath = mkdtempSync(join(tmpdir(), "flat-phase-validation-"));
+  const phaseDir = join(basePath, ".gsd", "phases", "01-foo");
+  mkdirSync(phaseDir, { recursive: true });
+  const validationPath = join(phaseDir, "01-VALIDATION.md");
+  writeFileSync(
+    validationPath,
+    [
+      "---",
+      "verdict: pass",
+      "---",
+      "",
+      "# M001 Validation",
+      "",
+      "All slices verified.",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+  return { basePath, cleanup: () => rmSync(basePath, { recursive: true, force: true }) };
+}
+
+test("flat-phase: relMilestoneFile resolves to the layout-aware path", () => {
+  const { basePath, cleanup } = makeFlatPhaseFixture();
+  try {
+    const rel = relMilestoneFile(basePath, "M001", "VALIDATION");
+    assert.equal(rel, ".gsd/phases/01-foo/01-VALIDATION.md");
+    const abs = join(basePath, rel);
+    assert.equal(existsSync(abs), true);
+  } finally {
+    cleanup();
+  }
+});
+
+test("flat-phase: resolveMilestoneFile finds the on-disk file", () => {
+  const { basePath, cleanup } = makeFlatPhaseFixture();
+  try {
+    const abs = resolveMilestoneFile(basePath, "M001", "VALIDATION");
+    assert.ok(abs, "resolveMilestoneFile must return a path for the flat-phase fixture");
+    assert.equal(abs!.endsWith("/.gsd/phases/01-foo/01-VALIDATION.md"), true);
+    assert.equal(existsSync(abs!), true);
+  } finally {
+    cleanup();
+  }
+});
+
+test("flat-phase: the legacy hardcoded path does NOT resolve (regression for #876)", () => {
+  const { basePath, cleanup } = makeFlatPhaseFixture();
+  try {
+    // This is the path that auto-verification.ts:264-270 used to construct.
+    // It must NOT exist on a flat-phase project — that's the whole bug.
+    const legacyHardcoded = join(basePath, ".gsd", "milestones", "M001", "M001-VALIDATION.md");
+    assert.equal(
+      existsSync(legacyHardcoded),
+      false,
+      "legacy hardcoded path must not exist in flat-phase fixture — if it does, the test fixture is wrong",
+    );
+  } finally {
+    cleanup();
+  }
+});

package/src/resources/extensions/gsd/tests/flat-rate-routing-guard.test.ts

@@ -51,6 +51,7 @@ describe("flat-rate provider routing guard (#3453)", () => {
         join(tempProject, ".gsd", "PREFERENCES.md"),
         [
           "---",
+          "token_profile: burn-max",
           "dynamic_routing:",
           "  enabled: true",
           "  tier_models:",
@@ -231,7 +232,7 @@ describe("flat-rate routing opt-in (#4386)", () => {
       mkdirSync(join(tempProject, ".gsd"), { recursive: true });
       writeFileSync(
         join(tempProject, ".gsd", "PREFERENCES.md"),
-        ["---", "version: 1", prefsYaml, "---"].join("\n"),
+        ["---", "version: 1", "token_profile: burn-max", prefsYaml, "---"].join("\n"),
         "utf-8",
       );
       process.env.GSD_HOME = tempGsdHome;

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

@@ -3,7 +3,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -11,8 +11,18 @@ import { tmpdir } from "node:os";
 import { buildGsdHomeModel, showGsdHome } from "../gsd-command-home.ts";
 import { buildIdleMenuSummary, detectIdleMilestoneResidueHint } from "../closeout-wizard.ts";
 import { closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
+import { createWorktree } from "../worktree-manager.ts";
 import type { GSDState } from "../types.ts";
 
+function initGitRepo(base: string): void {
+  execFileSync("git", ["init", "-b", "main"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.name", "Test User"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["config", "user.email", "test@example.com"], { cwd: base, stdio: "ignore" });
+  writeFileSync(join(base, "README.md"), "# test\n", "utf-8");
+  execFileSync("git", ["add", "README.md"], { cwd: base, stdio: "ignore" });
+  execFileSync("git", ["commit", "-m", "init"], { cwd: base, stdio: "ignore" });
+}
+
 function baseState(overrides: Partial<GSDState> = {}): GSDState {
   return {
     activeMilestone: { id: "M001", title: "Menu Cleanup" },
@@ -160,13 +170,13 @@ test("detectIdleMilestoneResidueHint reports missing workflow database in a git
 test("detectIdleMilestoneResidueHint matches unique-format milestone ids (M###-abc123)", () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-home-residue-unique-"));
   try {
-    execFileSync("git", ["init", "-b", "main"], { cwd: base, stdio: "ignore" });
-    mkdirSync(join(base, ".gsd-worktrees", "M042-abc123"), { recursive: true });
+    initGitRepo(base);
+    createWorktree(base, "M042-abc123");
     mkdirSync(join(base, ".gsd"), { recursive: true });
 
     openDatabase(join(base, ".gsd", "gsd.db"));
     try {
-      // Closed milestone with lingering worktree dir — classic residue.
+      // Closed milestone with a live git worktree still registered — classic residue.
       insertMilestone({ id: "M042-abc123", title: "Closed Unique", status: "complete" });
       const hint = detectIdleMilestoneResidueHint(base);
       assert.ok(hint, "unique-format closed milestone with worktree should be detected");
@@ -180,12 +190,35 @@ test("detectIdleMilestoneResidueHint matches unique-format milestone ids (M###-a
   }
 });
 
+test("detectIdleMilestoneResidueHint prunes bg-shell ghost dirs and does not warn", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-home-residue-ghost-"));
+  try {
+    initGitRepo(base);
+    const ghostDir = join(base, ".gsd-worktrees", "M009");
+    mkdirSync(join(ghostDir, ".bg-shell"), { recursive: true });
+    writeFileSync(join(ghostDir, ".bg-shell", "manifest.json"), "[]\n", "utf-8");
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    try {
+      insertMilestone({ id: "M009", title: "Search Tasks", status: "complete" });
+      const hint = detectIdleMilestoneResidueHint(base);
+      assert.equal(hint, null, "bg-shell-only ghost worktree dir must not trigger residue hint");
+      assert.equal(existsSync(ghostDir), false, "ghost worktree dir should be auto-pruned");
+    } finally {
+      closeDatabase();
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
 test("detectIdleMilestoneResidueHint ignores in-flight milestones with worktree artifacts", () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-home-residue-active-"));
   try {
-    execFileSync("git", ["init", "-b", "main"], { cwd: base, stdio: "ignore" });
-    mkdirSync(join(base, ".gsd-worktrees", "M001"), { recursive: true });
-    mkdirSync(join(base, ".gsd-worktrees", "M002-abc123"), { recursive: true });
+    initGitRepo(base);
+    createWorktree(base, "M001");
+    createWorktree(base, "M002-abc123");
     mkdirSync(join(base, ".gsd"), { recursive: true });
 
     openDatabase(join(base, ".gsd", "gsd.db"));

package/src/resources/extensions/gsd/tests/gsd-core-parity-routing.test.ts

@@ -0,0 +1,183 @@
+// gsd-pi — Comprehensive routing test for all additional commands
+// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
+//
+// Asserts that EVERY gsd-core command name is handled by the gsd-pi dispatcher —
+// either as an implemented native workflow (dispatches a prompt) or as an alias
+// (redirect / unavailable notice). None may fall through to "Unknown".
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { existsSync, mkdirSync, mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import { handleGSDCommand } from "../commands/dispatcher.ts";
+
+function createMockPi() {
+  const sent: any[] = [];
+  return {
+    sent,
+    sendMessage: (message: any) => sent.push(message),
+    registerCommand() {},
+    registerTool() {},
+    registerShortcut() {},
+    on() {},
+  };
+}
+
+function createMockCtx(cwd?: string) {
+  const notifications: { message: string; level: string }[] = [];
+  return {
+    cwd,
+    notifications,
+    ui: {
+      notify(message: string, level: string) {
+        notifications.push({ message, level });
+      },
+      custom: async () => {},
+    },
+    shutdown: async () => {},
+  };
+}
+
+function createTempGsdProject(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-core-parity-"));
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  return base;
+}
+
+// The complete list of gsd-core command names (from ~/github/open-gsd/gsd-core/commands/gsd/*.md).
+// extract-learnings and complete-milestone are natively handled by ops.ts (pre-existing).
+const GSD_CORE_COMMANDS = [
+  "add-tests",
+  "ai-integration-phase",
+  "audit-fix",
+  "audit-milestone",
+  "audit-uat",
+  "autonomous",
+  "capture",
+  "cleanup",
+  "code-review",
+  "complete-milestone",
+  "debug",
+  "discuss-phase",
+  "docs-update",
+  "execute-phase",
+  "explore",
+  "extract-learnings",
+  "graphify",
+  "health",
+  "help",
+  "import",
+  "inbox",
+  "ingest-docs",
+  "manager",
+  "map-codebase",
+  "milestone-summary",
+  "mvp-phase",
+  "new-milestone",
+  "new-project",
+  "ns-context",
+  "ns-ideate",
+  "ns-manage",
+  "ns-project",
+  "ns-review",
+  "ns-workflow",
+  "pause-work",
+  "phase",
+  "plan-phase",
+  "plan-review-convergence",
+  "progress",
+  "resume-work",
+  "review",
+  "review-backlog",
+  "secure-phase",
+  "settings",
+  "sketch",
+  "spec-phase",
+  "spike",
+  "stats",
+  "surface",
+  "thread",
+  "ui-phase",
+  "ui-review",
+  "ultraplan-phase",
+  "validate-phase",
+  "verify-work",
+  "workspace",
+  "workstreams",
+] as const;
+
+describe("gsd-core command parity routing", () => {
+  // Commands that legitimately don't dispatch a prompt on a bare invocation in a
+  // mock environment (they need a real .gsd/ project / TUI / gh CLI). We only
+  // assert they don't fall through to "Unknown".
+  test("every gsd-core command is handled (no 'Unknown' fallthrough)", async () => {
+    const unhandled: string[] = [];
+    const base = createTempGsdProject();
+    try {
+      for (const cmd of GSD_CORE_COMMANDS) {
+        const pi = createMockPi();
+        const ctx = createMockCtx(base);
+        try {
+          await handleGSDCommand(cmd, ctx as any, pi as any);
+        } catch {
+          // Some commands throw GSDNoProjectError etc. in a mock env — that still
+          // means they were recognized and routed, not "Unknown".
+        }
+        const fellThrough = ctx.notifications.some(
+          (n) => n.message.startsWith("Unknown:") && n.message.includes(`/gsd ${cmd}`),
+        );
+        if (fellThrough) unhandled.push(cmd);
+      }
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
+    assert.deepStrictEqual(
+      unhandled,
+      [],
+      `These gsd-core commands fell through to "Unknown" (not routed):\n  ${unhandled.join(", ")}`,
+    );
+  });
+
+  test("implemented commands dispatch a prompt via pi.sendMessage", async () => {
+    const implemented = [
+      "explore", "spike", "sketch",
+      "map-codebase", "docs-update", "graphify", "stats", "progress", "health", "surface",
+      "code-review", "review", "audit-milestone", "audit-uat", "audit-fix", "ui-review",
+      "secure-phase", "validate-phase", "verify-work", "plan-review-convergence",
+      "discuss-phase", "plan-phase", "execute-phase", "spec-phase", "mvp-phase",
+      "ui-phase", "ai-integration-phase", "ultraplan-phase", "autonomous",
+      "pause-work", "resume-work",
+      "manager", "thread", "workstreams", "milestone-summary",
+      "review-backlog", "inbox", "import", "ingest-docs", "profile-user", "settings",
+    ];
+    const noPrompt: string[] = [];
+    const base = createTempGsdProject();
+    const processCwd = createTempGsdProject();
+    const originalCwd = process.cwd();
+    try {
+      process.chdir(processCwd);
+      for (const cmd of implemented) {
+        const pi = createMockPi();
+        const ctx = createMockCtx(base);
+        await handleGSDCommand(cmd, ctx as any, pi as any);
+        if (pi.sent.length !== 1) noPrompt.push(`${cmd} (sent ${pi.sent.length})`);
+      }
+      assert.equal(existsSync(join(processCwd, ".gsd", "spikes")), false);
+      assert.equal(existsSync(join(processCwd, ".gsd", "sketches")), false);
+      assert.equal(existsSync(join(processCwd, ".gsd", "codebase")), false);
+      assert.equal(existsSync(join(processCwd, ".gsd", "knowledge")), false);
+      assert.equal(existsSync(join(processCwd, ".gsd", "reviews")), false);
+    } finally {
+      process.chdir(originalCwd);
+      rmSync(base, { recursive: true, force: true });
+      rmSync(processCwd, { recursive: true, force: true });
+    }
+    assert.deepStrictEqual(
+      noPrompt,
+      [],
+      `These implemented commands did not dispatch exactly one prompt:\n  ${noPrompt.join(", ")}`,
+    );
+  });
+});

package/src/resources/extensions/gsd/tests/guidance.test.ts

@@ -145,4 +145,29 @@ describe("doctor fix hints", () => {
   test("codes without authored guidance resolve to undefined", () => {
     assert.equal(doctorFixHint("delimiter_in_title"), undefined);
   });
+
+  test("fixable issue codes instruct /gsd doctor fix, not bare /gsd doctor", () => {
+    const fixableCodes = [
+      "stale_crash_lock",
+      "stale_parallel_session",
+      "orphaned_auto_worktree",
+      "gitignore_missing_patterns",
+      "state_file_stale",
+      "state_file_missing",
+      "projection_drift",
+    ] as const;
+
+    for (const code of fixableCodes) {
+      const hint = doctorFixHint(code);
+      assert.ok(hint, `expected a hint for ${code}`);
+      assert.match(hint, /\/gsd doctor fix/, `hint for ${code} must use /gsd doctor fix`);
+    }
+  });
+
+  test("db_unavailable uses bare /gsd doctor (diagnostic only, no auto-fix)", () => {
+    const hint = doctorFixHint("db_unavailable");
+    assert.ok(hint);
+    assert.match(hint, /\/gsd doctor/);
+    assert.doesNotMatch(hint, /\/gsd doctor fix/);
+  });
 });

package/src/resources/extensions/gsd/tests/integration/auto-recovery.test.ts

@@ -560,7 +560,12 @@ test("verifyExpectedArtifact execute-task rejects heading-style plan without che
 });
 
 test("verifyExpectedArtifact plan-slice passes for rendered slice/task plan artifacts from DB", async () => {
-  const base = makeTmpBase();
+  // Do NOT use makeTmpBase() here — it creates a legacy milestones/ dir which forces
+  // renderPlanFromDb into the legacy path layout and creates a spurious tasks/ dir that
+  // triggers the per-task file check even when dbPrimary=true. Create only .gsd/ so
+  // resolveMilestonePath returns null and the flat-phase path is used instead.
+  const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
   const dbPath = join(base, ".gsd", "gsd.db");
   openDatabase(dbPath);
   try {
@@ -614,26 +619,28 @@ test("verifyExpectedArtifact plan-slice passes for rendered slice/task plan arti
 
     const rendered = await renderPlanFromDb(base, "M001", "S01");
     assert.ok(existsSync(rendered.planPath), "renderPlanFromDb should write the slice plan");
-    assert.equal(rendered.taskPlanPaths.length, 2, "renderPlanFromDb should render one task plan per task");
+    // Flat-phase: tasks are checkboxes inside the slice plan — no per-task plan files.
+    assert.equal(rendered.taskPlanPaths.length, 0, "flat-phase: renderPlanFromDb returns no per-task plan paths");
 
     const planContent = readFileSync(rendered.planPath, "utf-8");
     const parsedPlan = parsePlan(planContent);
     assert.equal(parsedPlan.tasks.length, 2, "rendered slice plan should parse into task entries");
 
-    const taskPlanContent = readFileSync(rendered.taskPlanPaths[0], "utf-8");
-    const taskPlan = parseTaskPlanFile(taskPlanContent);
-    assert.deepEqual(taskPlan.frontmatter.skills_used, [], "rendered task plans should use conservative empty skills_used");
-
+    // DB-primary: task rows prove the slice was planned; no per-task file check.
     const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
-    assert.equal(result, true, "plan-slice verification should pass when rendered task plan files exist");
+    assert.equal(result, true, "plan-slice verification should pass when DB has task rows");
   } finally {
     closeDatabase();
     cleanup(base);
   }
 });
 
-test("verifyExpectedArtifact plan-slice fails after deleting a rendered task plan file", async () => {
-  const base = makeTmpBase();
+test("verifyExpectedArtifact plan-slice fails after deleting the slice plan file", async () => {
+  // Do NOT use makeTmpBase() here — same reason as the passing test above: the legacy
+  // milestones/ dir forces a legacy path and creates a tasks/ dir that incorrectly
+  // triggers the per-task file check. Create only .gsd/ to stay on the flat-phase path.
+  const base = join(tmpdir(), `gsd-test-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd"), { recursive: true });
   const dbPath = join(base, ".gsd", "gsd.db");
   openDatabase(dbPath);
   try {
@@ -686,10 +693,11 @@ test("verifyExpectedArtifact plan-slice fails after deleting a rendered task pla
     });
 
     const rendered = await renderPlanFromDb(base, "M001", "S01");
-    rmSync(rendered.taskPlanPaths[1]);
+    // Flat-phase: per-task plan files do not exist; delete the slice plan itself to fail verification.
+    rmSync(rendered.planPath);
 
     const result = verifyExpectedArtifact("plan-slice", "M001/S01", base);
-    assert.equal(result, false, "plan-slice verification should fail when a rendered task plan file is removed");
+    assert.equal(result, false, "plan-slice verification should fail when the slice plan file is removed");
   } finally {
     closeDatabase();
     cleanup(base);

package/src/resources/extensions/gsd/tests/integration/auto-worktree-milestone-merge.test.ts

@@ -23,6 +23,7 @@ import {
   createAutoWorktree,
   mergeMilestoneToMain,
   getAutoWorktreeOriginalBase,
+  _setRestoreEntryFnForTests,
 } from "../../auto-worktree.ts";
 import { getSliceBranchName } from "../../worktree.ts";
 import { nativeMergeSquash } from "../../native-git-bridge.ts";
@@ -1012,4 +1013,78 @@ describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
     assert.ok(!existsSync(join(repo, ".gsd", ".milestone-shelter")), "shelter removed on successful restore");
     assert.ok(result.commitMessage.length > 0, "merge completed");
   });
+
+  // #2505 log coverage: when the per-entry shelter restore throws (here via the
+  // _setRestoreEntryFnForTests seam — the only deterministic way to reach this
+  // path, since shelter + restore run synchronously in one merge call), the
+  // merge must log a `worktree` ERROR naming the entry (auto-worktree.ts:1809),
+  // emit a retention warning (:1816), and PRESERVE the shelter dir so the
+  // queued milestone files (whose on-disk sources were deleted during the
+  // shelter step) remain recoverable. The existing #2505 test only covered the
+  // success path; this pins the failure-path log + the data-loss guard.
+  test("#2505 logs: shelter restore failure logs a worktree error and retains the shelter", () => {
+    const repo = freshRepo();
+    const wtPath = createAutoWorktree(repo, "M210");
+
+    addSliceToMilestone(repo, wtPath, "M210", "S01", "Feature", [
+      { file: "feature.ts", content: "export const f = 1;\n", message: "add feature" },
+    ]);
+
+    // Seed a queued (non-target) milestone that will be sheltered then restored.
+    const queuedDir = join(repo, ".gsd", "milestones", "M211");
+    mkdirSync(queuedDir, { recursive: true });
+    writeFileSync(join(queuedDir, "CONTEXT.md"), "# queued\n");
+
+    const roadmap = makeRoadmap("M210", "Milestone w/ failing restore", [
+      { id: "S01", title: "Feature" },
+    ]);
+
+    // Inject a restore entry fn that always throws, forcing the best-effort
+    // failure path. restoreDefault() is invoked in finally so no other test in
+    // the process observes the injected behavior.
+    const restoreDefault = _setRestoreEntryFnForTests(() => {
+      throw new Error("forced restore failure");
+    });
+
+    const previousStderr = setStderrLoggingEnabled(false);
+    let logs: ReturnType<typeof drainLogs> = [];
+    try {
+      mergeMilestoneToMain(repo, "M210", roadmap);
+      logs = drainLogs();
+    } finally {
+      setStderrLoggingEnabled(previousStderr);
+      restoreDefault();
+    }
+
+    const worktreeLogs = logs.filter((e) => e.component === "worktree");
+
+    const restoreError = worktreeLogs.find(
+      (e) => e.severity === "error" && /shelter restore failed/u.test(e.message),
+    );
+    assert.ok(
+      restoreError,
+      "a worktree ERROR must be logged when the shelter restore fails (got: " +
+        worktreeLogs.map((e) => e.message).join(" | ") + ")",
+    );
+    assert.match(
+      restoreError!.message,
+      /shelter restore failed \(M211\)/u,
+      "the error must name the unrestored milestone entry",
+    );
+    assert.match(
+      restoreError!.message,
+      /forced restore failure/u,
+      "the error must carry the underlying restore failure detail",
+    );
+
+    // #2505 data-loss guard: the shelter must survive so files stay recoverable.
+    assert.ok(
+      worktreeLogs.some((e) => /shelter retained/u.test(e.message)),
+      "a retention warning must be logged when a restore entry fails",
+    );
+    assert.ok(
+      existsSync(join(repo, ".gsd", ".milestone-shelter")),
+      "the shelter dir must be retained when a restore entry fails",
+    );
+  });
 });

package/src/resources/extensions/gsd/tests/integration/commands-eval-review.integration.test.ts

@@ -139,8 +139,12 @@ describe("integration: /gsd eval-review helper chain on a real on-disk slice", (
     assert.ok(prompt.includes("src/llm/budget.ts:42"));
     assert.ok(prompt.includes("langfuse"));
 
-    // Output path is the canonical slice file path
-    assert.ok(prompt.includes(`${layout.sliceId}-EVAL-REVIEW.md`));
+    // Output path is the canonical slice file path — buildSliceFileName("S07", ...)
+    // produces "07-EVAL-REVIEW.md" (flat-phase MM-SUFFIX.md format).
+    assert.ok(
+      prompt.includes("07-EVAL-REVIEW.md") || prompt.includes(`${layout.sliceId}-EVAL-REVIEW.md`),
+      `prompt should include eval-review output filename (got: ${ctx.outputPath})`,
+    );
   });
 
   it("falls back to the no-spec audit mode when AI-SPEC.md is absent", async () => {

package/src/resources/extensions/gsd/tests/integration/gitignore-tracked-gsd.test.ts

@@ -113,6 +113,61 @@ test("ensureGitignore does NOT add .gsd when .gsd/ has tracked files (#1364)", (
   }
 });
 
+test("ensureGitignore adds granular runtime patterns when .gsd/ has tracked files", (t) => {
+  // Regression: pre-completion close-out gate (auto-dispatch.ts) blocks when
+  // RUNTIME_EXCLUSION_PATHS artifacts appear as untracked. They are excluded
+  // from smartStage by design, so the auto-commit can never absorb them; the
+  // umbrella .gsd ignore pattern would normally cover them, but it is stripped
+  // when .gsd/ has tracked files. Without a granular fallback, runtime paths
+  // surface as `??` in `git status` and trip the close-out gate forever.
+  const dir = makeTempRepo();
+  try {
+    // Set up .gsd/ with tracked files (mirrors the close-out smoke scenario).
+    mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+    writeFileSync(join(dir, ".gsd", "PROJECT.md"), "# Test Project\n");
+    git(dir, "add", ".gsd/");
+    git(dir, "commit", "-m", "track gsd state");
+
+    ensureGitignore(dir);
+
+    const gitignore = readFileSync(join(dir, ".gitignore"), "utf-8");
+    const lines = new Set(gitignore.split("\n").map((l) => l.trim()));
+
+    // The umbrella pattern must still be omitted (preserves #1364).
+    assert.ok(!lines.has(".gsd"), `.gsd should not appear when tracked; got:\n${gitignore}`);
+
+    // The runtime artifacts that break the close-out gate must be ignored.
+    for (const pattern of [
+      ".gsd/STATE.md",
+      ".gsd/runtime/",
+      ".gsd/activity/",
+      ".gsd/audit/",
+      ".gsd/journal/",
+      ".gsd/gsd.db*",
+      ".gsd/event-log.jsonl",
+      ".gsd/metrics.json",
+      ".gsd/state-manifest.json",
+    ]) {
+      assert.ok(
+        lines.has(pattern),
+        `Expected ${pattern} in .gitignore so close-out gate sees a clean tree; got:\n${gitignore}`,
+      );
+    }
+
+    // BASELINE and GSD_RUNTIME both contain .gsd-worktrees/ — must not duplicate.
+    const worktreeOccurrences = gitignore
+      .split("\n")
+      .filter((l) => l.trim() === ".gsd-worktrees/").length;
+    assert.equal(
+      worktreeOccurrences,
+      1,
+      `.gsd-worktrees/ should appear exactly once; got ${worktreeOccurrences} in:\n${gitignore}`,
+    );
+  } finally {
+    cleanup(dir);
+  }
+});
+
 test("ensureGitignore adds .gsd when .gsd/ has NO tracked files", (t) => {
   const dir = makeTempRepo();
   try {

package/src/resources/extensions/gsd/tests/integration/idle-recovery.test.ts

@@ -112,10 +112,11 @@ test('writeBlockerPlaceholder: creates directory if missing', () => {
   try {
     // Only create milestone dir, not slice dir
     mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-    // resolveSlicePath needs the slice dir to exist to resolve, so this should return null
+    // resolveSliceArtifactPath now returns a canonical path even when the dir
+    // doesn't exist (relSliceFile fallback), so writeBlockerPlaceholder creates
+    // the directory and writes the placeholder file — returning a non-null diagnosis.
     const result = writeBlockerPlaceholder("research-slice", "M001/S01", base, "test reason");
-    // Since the slice dir doesn't exist, resolveExpectedArtifactPath returns null
-    assert.deepStrictEqual(result, null, "returns null when directory structure doesn't exist");
+    assert.ok(result !== null, "should return a diagnosis string when the dir is missing (creates it)");
   } finally {
     cleanup(base);
   }