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

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

@@ -0,0 +1,120 @@
+// Project/App: gsd-pi
+// File Purpose: End-to-end integration test for the upstream issue #876
+// fix — exercises the actual verdict-resolution code paths against a real
+// on-disk flat-phase project fixture, with no LLM or smoke required.
+//
+// Counterpart to flat-phase-validation-path.test.ts (which tests the
+// path helpers in isolation). This file tests the integrated readers
+// that auto-verification, commands-verdict, and milestone-validation-verdict
+// rely on.
+
+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 { loadFile } from "../files.ts";
+import { resolveMilestoneValidationVerdict } from "../milestone-validation-verdict.ts";
+import { relMilestoneFile } from "../paths.ts";
+
+function makeFlatPhaseFixtureWithPassVerdict(): {
+  basePath: string;
+  cleanup: () => void;
+} {
+  const basePath = mkdtempSync(join(tmpdir(), "flat-phase-validation-int-"));
+  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, all acceptance criteria met.",
+      "",
+    ].join("\n"),
+    "utf-8",
+  );
+  return {
+    basePath,
+    cleanup: () => rmSync(basePath, { recursive: true, force: true }),
+  };
+}
+
+test("flat-phase integration: auto-verification reader path loads the on-disk VALIDATION.md (#876)", async () => {
+  // Simulates the exact path construction at auto-verification.ts:264-266
+  // after the Task 2 fix: join(basePath, relMilestoneFile(basePath, mid, "VALIDATION")).
+  // This is the load-bearing reader that was permanently null-returning on
+  // flat-phase projects before the fix.
+  const { basePath, cleanup } = makeFlatPhaseFixtureWithPassVerdict();
+  try {
+    const validationFile = join(
+      basePath,
+      relMilestoneFile(basePath, "M001", "VALIDATION"),
+    );
+    const content = await loadFile(validationFile);
+    assert.ok(
+      content && content.includes("verdict: pass"),
+      "auto-verification reader path must load the flat-phase VALIDATION.md content; received: " +
+        JSON.stringify(content),
+    );
+  } finally {
+    cleanup();
+  }
+});
+
+test("flat-phase integration: resolveMilestoneValidationVerdict returns 'pass' from disk (#876)", async () => {
+  // Exercises the full verdict-resolution waterfall in
+  // resolveMilestoneValidationVerdict: DB check first (returns undefined
+  // when no DB is open), then canonical/project-root file lookups, then
+  // the last-resort path Task 4 patched. With the fix, at least one of
+  // these branches finds the flat-phase VALIDATION.md and returns "pass".
+  // Pre-fix, the last-resort branch hardcoded milestones/MID/MID-VALIDATION.md
+  // and would miss the flat-phase file.
+  const { basePath, cleanup } = makeFlatPhaseFixtureWithPassVerdict();
+  try {
+    const verdict = await resolveMilestoneValidationVerdict(basePath, "M001");
+    assert.equal(
+      verdict,
+      "pass",
+      "resolveMilestoneValidationVerdict must read the verdict from the flat-phase VALIDATION.md on disk",
+    );
+  } finally {
+    cleanup();
+  }
+});
+
+test("flat-phase integration: pre-fix legacy hardcoded path would have missed this fixture", async () => {
+  // Documents what the bug looked like: the legacy hardcoded reader path
+  // (milestones/MID/MID-VALIDATION.md) does NOT exist in a flat-phase
+  // fixture, so loadFile on it returns null. This is the failure the fix
+  // closes.
+  const { basePath, cleanup } = makeFlatPhaseFixtureWithPassVerdict();
+  try {
+    const legacyHardcoded = join(
+      basePath,
+      ".gsd",
+      "milestones",
+      "M001",
+      "M001-VALIDATION.md",
+    );
+    assert.equal(
+      existsSync(legacyHardcoded),
+      false,
+      "fixture invariant: legacy path must not exist on flat-phase",
+    );
+    const content = await loadFile(legacyHardcoded);
+    assert.equal(
+      content,
+      null,
+      "loadFile on the pre-fix legacy hardcoded path must return null on a flat-phase fixture — this is the bug shape",
+    );
+  } finally {
+    cleanup();
+  }
+});

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/gate-state-canonicalization.test.ts

@@ -3,7 +3,7 @@
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 
@@ -18,6 +18,7 @@ import {
   insertSlice,
 } from "../gsd-db.ts";
 import type { GateVerdict } from "../types.ts";
+import { closeQualityGatesFromEvidence } from "../quality-gate-closure.ts";
 
 describe("gate-state canonicalization (#4950)", () => {
   let tmpDir: string;
@@ -99,4 +100,50 @@ describe("gate-state canonicalization (#4950)", () => {
       assert.notEqual(g.verdict, "", `gate ${g.gate_id} verdict must not be empty string`);
     }
   });
+
+  test("closeQualityGatesFromEvidence repairs pending gate from durable section", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    mkdirSync(join(tmpDir, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+    writeFileSync(
+      join(tmpDir, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md"),
+      [
+        "# S01",
+        "",
+        "## Threat Surface",
+        "",
+        "- Credential stuffing is rate-limited.",
+      ].join("\n"),
+    );
+
+    const result = closeQualityGatesFromEvidence("M001", { artifactBasePath: tmpDir });
+
+    assert.deepEqual(result.unresolved, []);
+    assert.deepEqual(result.repaired, [{ gateId: "Q3", sliceId: "S01", verdict: "pass" }]);
+    assert.equal(getPendingGates("M001", "S01").length, 0);
+    assert.equal(getGateResults("M001", "S01")[0].verdict, "pass");
+  });
+
+  test("closeQualityGatesFromEvidence omits stale pending gate after validation pass", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q4", scope: "slice" });
+
+    const result = closeQualityGatesFromEvidence("M001", {
+      artifactBasePath: tmpDir,
+      milestoneValidationPassed: true,
+    });
+
+    assert.deepEqual(result.unresolved, []);
+    assert.deepEqual(result.repaired, [{ gateId: "Q4", sliceId: "S01", verdict: "omitted" }]);
+    assert.equal(getGateResults("M001", "S01")[0].verdict, "omitted");
+  });
+
+  test("closeQualityGatesFromEvidence leaves pending gate unresolved without evidence", () => {
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+
+    const result = closeQualityGatesFromEvidence("M001", { artifactBasePath: tmpDir });
+
+    assert.deepEqual(result.repaired, []);
+    assert.equal(result.unresolved.length, 1);
+    assert.equal(result.unresolved[0].gate_id, "Q3");
+    assert.equal(getPendingGates("M001", "S01").length, 1);
+  });
 });

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

@@ -3,13 +3,26 @@
 
 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";
 
 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" },
@@ -118,6 +131,146 @@ test("/gsd home recommends start or configure after all milestones complete", ()
   assert.match(model.summary.join("\n"), /All milestones complete/);
 });
 
+test("/gsd home recommends fix or recover when milestone git residue is stranded", () => {
+  const model = buildGsdHomeModel(baseState({
+    activeMilestone: null,
+    activeSlice: null,
+    activeTask: null,
+    phase: "complete",
+    nextAction: "All milestones complete.",
+  }), {
+    strandedQuick: null,
+    unmergedMilestones: [],
+    idleResidueHint: {
+      milestoneIds: ["M008"],
+      message:
+        "Stranded milestone git residue detected (M008: worktree dir and/or milestone/* branch). " +
+        "Run /gsd dispatch complete-milestone M008 or /gsd status to recover closeout before starting new work.",
+    },
+  });
+
+  assert.equal(action(model, "fix_recover").recommended, true);
+  assert.equal(action(model, "fix_recover").enabled, true);
+  assert.match(model.summary[0], /Stranded milestone git residue/);
+  assert.equal(action(model, "continue_step").enabled, false);
+});
+
+test("detectIdleMilestoneResidueHint reports missing workflow database in a git repo", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-home-residue-"));
+  try {
+    execFileSync("git", ["init", "-b", "main"], { cwd: base, stdio: "ignore" });
+    const hint = detectIdleMilestoneResidueHint(base);
+    assert.ok(hint);
+    assert.match(hint!.message, /\.gsd\/gsd\.db/);
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("detectIdleMilestoneResidueHint matches unique-format milestone ids (M###-abc123)", () => {
+  const base = mkdtempSync(join(tmpdir(), "gsd-home-residue-unique-"));
+  try {
+    initGitRepo(base);
+    createWorktree(base, "M042-abc123");
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    try {
+      // 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");
+      assert.deepEqual(hint!.milestoneIds, ["M042-abc123"]);
+      assert.match(hint!.message, /M042-abc123/);
+    } finally {
+      closeDatabase();
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+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 {
+    initGitRepo(base);
+    createWorktree(base, "M001");
+    createWorktree(base, "M002-abc123");
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    try {
+      // Active and pending milestones must not be flagged as stranded residue.
+      insertMilestone({ id: "M001", title: "Active milestone", status: "active" });
+      insertMilestone({ id: "M002-abc123", title: "Pending milestone", status: "pending" });
+      const hint = detectIdleMilestoneResidueHint(base);
+      assert.equal(hint, null, "active/pending milestone worktrees must not be classified as residue");
+    } finally {
+      closeDatabase();
+    }
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("buildIdleMenuSummary surfaces idle residue hint even when phase is complete", () => {
+  const summary = buildIdleMenuSummary(
+    {
+      activeMilestone: null,
+      activeSlice: null,
+      activeTask: null,
+      phase: "complete",
+      recentDecisions: [],
+      blockers: [],
+      nextAction: "All milestones complete.",
+      lastCompletedMilestone: { id: "M001", title: "Menu Cleanup" },
+      registry: [{ id: "M001", title: "Menu Cleanup", status: "complete" }],
+      requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
+      progress: {
+        milestones: { done: 1, total: 1 },
+        slices: { done: 0, total: 0 },
+        tasks: { done: 0, total: 0 },
+      },
+    },
+    {
+      strandedQuick: null,
+      unmergedMilestones: [],
+      idleResidueHint: {
+        milestoneIds: ["M008"],
+        message:
+          "Stranded milestone git residue detected (M008: worktree dir and/or milestone/* branch). " +
+          "Run /gsd dispatch complete-milestone M008 or /gsd status to recover closeout before starting new work.",
+      },
+    },
+  );
+
+  assert.match(summary[0] ?? "", /Stranded milestone git residue/);
+  assert.doesNotMatch(summary.join("\n"), /All milestones complete/);
+});
+
 test("showGsdHome renders the five-slot home text without an interactive TUI", async () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-home-"));
   const notifications: Array<{ message: string; level: string }> = [];

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(", ")}`,
+    );
+  });
+});