gsd-pi 2.80.0-dev.8b3a59f5c → 2.80.0-dev.b0acf17e9

package/src/resources/extensions/gsd/tests/deep-project-auto-loop.test.ts

@@ -20,6 +20,7 @@ import {
   clearPendingAutoStart,
   checkDeepProjectSetupAfterTurn,
   clearPendingDeepProjectSetup,
+  FOREGROUND_DEEP_SETUP_RULE_NAMES,
   showSmartEntry,
   startDeepProjectSetupForeground,
 } from "../guided-flow.ts";
@@ -1013,15 +1014,9 @@ test("deep project setup: same project advances when agent_end session id change
 });
 
 test("deep project setup: foreground dispatcher does not probe research-project rule", () => {
-  const source = readFileSync(new URL("../guided-flow.ts", import.meta.url), "utf-8");
-  const match = source.match(/const FOREGROUND_DEEP_SETUP_RULE_NAMES = new Set\(\[([\s\S]*?)\]\);/);
-  assert.ok(match, "foreground deep setup rule allowlist should be present");
-  assert.doesNotMatch(
-    match![1]!,
-    /research-project/,
-    "foreground setup must not evaluate research-project because that rule claims the inflight marker",
-  );
-  assert.match(source, /research-project have dispatch-time side effects/);
+  assert.equal(FOREGROUND_DEEP_SETUP_RULE_NAMES.has("deep: pre-planning (no PROJECT) → discuss-project"), true);
+  assert.equal(FOREGROUND_DEEP_SETUP_RULE_NAMES.has("deep: pre-planning (no research decision) → research-decision"), true);
+  assert.equal(FOREGROUND_DEEP_SETUP_RULE_NAMES.has("deep: pre-planning (no PROJECT research) → research-project"), false);
 });
 
 test("deep project setup: project-level units verify their real artifacts", () => {

package/src/resources/extensions/gsd/tests/deferred-milestone-dir-4996.test.ts

@@ -1,14 +1,10 @@
 // GSD Extension — Regression test for #4996: deferred milestone dir creation
-// Verifies that showHeadlessMilestoneCreation does not pre-create the milestone
-// directory before the discuss flow runs. The dir should only appear after a
-// writer (saveArtifactToDb / atomicWriteAsync) emits the first artifact.
 
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, existsSync, rmSync, readFileSync } from "node:fs";
-import { dirname, join } from "node:path";
+import { mkdtempSync, mkdirSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
 
 import { isReusableGhostMilestone } from "../state.ts";
 import { nextMilestoneIdReserved } from "../milestone-id-reservation.ts";
@@ -16,47 +12,12 @@ import { clearReservedMilestoneIds, findMilestoneIds } from "../milestone-ids.ts
 import { invalidateAllCaches } from "../cache.ts";
 import { closeDatabase, openDatabase } from "../gsd-db.ts";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const GUIDED_FLOW_PATH = join(__dirname, "..", "guided-flow.ts");
-
-function getShowHeadlessBody(): string {
-  const source = readFileSync(GUIDED_FLOW_PATH, "utf-8");
-  const fnStart = source.indexOf("export async function showHeadlessMilestoneCreation");
-  assert.ok(fnStart > -1, "showHeadlessMilestoneCreation must exist in guided-flow.ts");
-  const nextExport = source.indexOf("\nexport ", fnStart + 1);
-  return source.slice(fnStart, nextExport === -1 ? source.length : nextExport);
-}
-
 function makeBase(prefix = "gsd-deferred-dir-"): string {
   const base = mkdtempSync(join(tmpdir(), prefix));
   mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
   return base;
 }
 
-describe("showHeadlessMilestoneCreation source guard (#4996)", () => {
-  it("does not call mkdirSync in the headless milestone creation path", () => {
-    const body = getShowHeadlessBody();
-    assert.doesNotMatch(
-      body,
-      /\bmkdirSync\s*\(/,
-      "showHeadlessMilestoneCreation must not pre-create milestone directories",
-    );
-  });
-
-  it("does not call mkdir or mkdirp before dispatchWorkflow", () => {
-    const body = getShowHeadlessBody();
-    const dispatchIdx = body.indexOf("dispatchWorkflow");
-    assert.ok(dispatchIdx > -1, "dispatchWorkflow must be present");
-
-    const beforeDispatch = body.slice(0, dispatchIdx);
-    assert.doesNotMatch(
-      beforeDispatch,
-      /\b(?:mkdir|mkdirp)\s*\(/,
-      "showHeadlessMilestoneCreation must defer directory creation until artifact write",
-    );
-  });
-});
-
 describe("deferred milestone dir creation (#4996)", () => {
   let base: string;
 
@@ -74,43 +35,31 @@ describe("deferred milestone dir creation (#4996)", () => {
   it("(a) fresh project: milestones dir has no M001 entry before any discuss flow", () => {
     base = makeBase();
     const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M001", "reservation should choose M001 for a fresh project");
+    assert.equal(nextId, "M001");
 
     const ids = findMilestoneIds(base);
-    assert.equal(ids.length, 0, "no milestone dirs should exist before any discuss flow");
-
-    // And specifically M001 should not exist
-    const m001Dir = join(base, ".gsd", "milestones", "M001");
-    assert.ok(!existsSync(m001Dir), "M001 dir must not exist before the discuss flow runs");
+    assert.equal(ids.length, 0);
+    assert.ok(!existsSync(join(base, ".gsd", "milestones", "M001")));
   });
 
-  it("(b) abandoned discuss flow leaves no orphan: isReusableGhostMilestone returns false for non-existent dir", () => {
+  it("(b) abandoned discuss flow leaves no orphan", () => {
     base = makeBase();
     const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M001", "reservation should not require a pre-created directory");
+    assert.equal(nextId, "M001");
 
     const m001Dir = join(base, ".gsd", "milestones", "M001");
-    assert.ok(!existsSync(m001Dir), "no M001 dir should exist");
-    assert.equal(isReusableGhostMilestone(base, "M001"), false, "non-existent milestone should not be reusable");
-    // findMilestoneIds only returns dirs that exist
-    const ids = findMilestoneIds(base);
-    assert.ok(!ids.includes("M001"), "M001 should not appear in findMilestoneIds when no dir exists");
+    assert.ok(!existsSync(m001Dir));
+    assert.equal(isReusableGhostMilestone(base, "M001"), false);
+    assert.ok(!findMilestoneIds(base).includes("M001"));
   });
 
-  it("(c) a stub dir left from a previous bug IS reusable but a newly-generated ID with no dir is not in the ghost list", () => {
+  it("(c) a stub dir left from a previous bug is reusable", () => {
     base = makeBase();
     openDatabase(join(base, ".gsd", "gsd.db"));
-    // Create a stub to represent a pre-existing phantom
     mkdirSync(join(base, ".gsd", "milestones", "M001", "slices"), { recursive: true });
 
-    // isReusableGhostMilestone identifies the orphaned stub
-    assert.ok(isReusableGhostMilestone(base, "M001"), "pre-existing stub should be identified as reusable ghost");
-    const nextId = nextMilestoneIdReserved(findMilestoneIds(base), false, base);
-    assert.equal(nextId, "M001", "reservation should reuse the pre-existing ghost");
-
-    // The new ID (M002, which would be max+1 in this scenario but ghost reuse returns M001)
-    // should not have a dir
-    const m002Dir = join(base, ".gsd", "milestones", "M002");
-    assert.ok(!existsSync(m002Dir), "a freshly-requested ID should have no dir until first artifact write");
+    assert.equal(isReusableGhostMilestone(base, "M001"), true);
+    assert.equal(nextMilestoneIdReserved(findMilestoneIds(base), false, base), "M001");
+    assert.ok(!existsSync(join(base, ".gsd", "milestones", "M002")));
   });
 });

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

@@ -11,12 +11,14 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { execFileSync } from "node:child_process";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import {
   detectProjectState,
   detectV1Planning,
   detectProjectSignals,
+  classifyProject,
   scanProjectFiles,
 } from "../detection.ts";
 
@@ -37,6 +39,18 @@ function cleanup(dir: string): void {
   }
 }
 
+function git(dir: string, args: string[]): void {
+  execFileSync("git", args, { cwd: dir, stdio: "ignore" });
+}
+
+function makeGitRepo(prefix: string): string {
+  const dir = makeTempDir(prefix);
+  git(dir, ["init"]);
+  git(dir, ["config", "user.email", "test@example.com"]);
+  git(dir, ["config", "user.name", "Test User"]);
+  return dir;
+}
+
 // ─── detectProjectState ─────────────────────────────────────────────────────────
 
 test("detectProjectState: empty directory returns state=none", (t) => {
@@ -49,6 +63,132 @@ test("detectProjectState: empty directory returns state=none", (t) => {
   assert.equal(result.v2, undefined);
 });
 
+test("classifyProject: no git repo is invalid", (t) => {
+  const dir = makeTempDir("classify-invalid");
+  t.after(() => cleanup(dir));
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "invalid-repo");
+});
+
+test("classifyProject: empty git repo is greenfield", (t) => {
+  const dir = makeGitRepo("classify-greenfield");
+  t.after(() => cleanup(dir));
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "greenfield");
+});
+
+test("classifyProject: nested empty git repo does not inherit ancestor markers", (t) => {
+  const parent = makeGitRepo("classify-parent-marker");
+  t.after(() => cleanup(parent));
+
+  writeFileSync(join(parent, "package.json"), JSON.stringify({ name: "parent" }), "utf-8");
+  git(parent, ["add", "package.json"]);
+  git(parent, ["commit", "-m", "add parent marker"]);
+  const child = join(parent, "nested");
+  mkdirSync(child, { recursive: true });
+  git(child, ["init"]);
+  git(child, ["config", "user.email", "test@example.com"]);
+  git(child, ["config", "user.name", "Test User"]);
+
+  const classification = classifyProject(child);
+  assert.equal(classification.kind, "greenfield");
+});
+
+test("classifyProject: tracked static HTML is existing untyped content", (t) => {
+  const dir = makeGitRepo("classify-index");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, "index.html"), "<main></main>\n", "utf-8");
+  git(dir, ["add", "index.html"]);
+  git(dir, ["commit", "-m", "add static page"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+  assert.deepEqual(classification.contentFiles, ["index.html"]);
+});
+
+test("classifyProject: README-only repo is existing untyped content", (t) => {
+  const dir = makeGitRepo("classify-readme");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, "README.md"), "# docs\n", "utf-8");
+  git(dir, ["add", "README.md"]);
+  git(dir, ["commit", "-m", "add docs"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+});
+
+test("classifyProject: src-only content is untyped existing, not typed marker", (t) => {
+  const dir = makeGitRepo("classify-src-only");
+  t.after(() => cleanup(dir));
+
+  mkdirSync(join(dir, "src"), { recursive: true });
+  writeFileSync(join(dir, "src", "index.txt"), "content\n", "utf-8");
+  git(dir, ["add", "src/index.txt"]);
+  git(dir, ["commit", "-m", "add source content"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+  assert.deepEqual(classification.contentFiles, ["src/index.txt"]);
+});
+
+test("classifyProject: nested untracked files count as project content", (t) => {
+  const dir = makeGitRepo("classify-untracked-nested");
+  t.after(() => cleanup(dir));
+
+  mkdirSync(join(dir, "docs"), { recursive: true });
+  writeFileSync(join(dir, "docs", "index.html"), "<main></main>\n", "utf-8");
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "untyped-existing");
+  assert.deepEqual(classification.untrackedFiles, ["docs/index.html"]);
+});
+
+test("classifyProject: known markers produce typed existing project", (t) => {
+  const dir = makeGitRepo("classify-typed");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "typed" }), "utf-8");
+  git(dir, ["add", "package.json"]);
+  git(dir, ["commit", "-m", "add package"]);
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "typed-existing");
+  assert.ok(classification.markers.includes("package.json"));
+});
+
+test("classifyProject: ignored build/cache-only files do not count as content", (t) => {
+  const dir = makeGitRepo("classify-ignored");
+  t.after(() => cleanup(dir));
+
+  writeFileSync(join(dir, ".gitignore"), "dist/\n.cache/\n", "utf-8");
+  git(dir, ["add", ".gitignore"]);
+  git(dir, ["commit", "-m", "ignore generated files"]);
+  mkdirSync(join(dir, "dist"), { recursive: true });
+  writeFileSync(join(dir, "dist", "bundle.js"), "generated\n", "utf-8");
+  mkdirSync(join(dir, ".cache"), { recursive: true });
+  writeFileSync(join(dir, ".cache", "x"), "cache\n", "utf-8");
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "greenfield");
+});
+
+test("classifyProject: generated framework/cache dirs do not count as content", (t) => {
+  const dir = makeGitRepo("classify-generated-dirs");
+  t.after(() => cleanup(dir));
+
+  mkdirSync(join(dir, ".next", "server"), { recursive: true });
+  writeFileSync(join(dir, ".next", "server", "page.js"), "generated\n", "utf-8");
+  mkdirSync(join(dir, ".venv", "lib"), { recursive: true });
+  writeFileSync(join(dir, ".venv", "lib", "site.py"), "generated\n", "utf-8");
+
+  const classification = classifyProject(dir);
+  assert.equal(classification.kind, "greenfield");
+});
+
 test("detectProjectState: directory with .gsd/milestones/M001 returns v2-gsd", (t) => {
   const dir = makeTempDir("v2-gsd");
   t.after(() => cleanup(dir));

package/src/resources/extensions/gsd/tests/discuss-tool-scoping.test.ts

@@ -16,15 +16,12 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
 import { DISCUSS_TOOLS_ALLOWLIST } from "../constants.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const promptsDir = join(__dirname, "..", "prompts");
-const guidedFlowPath = join(__dirname, "..", "guided-flow.ts");
+import { _dispatchWorkflowForTest } from "../guided-flow.ts";
 
 // ─── Heavy tools that should NOT be in discuss scope ─────────────────────────
 
@@ -95,36 +92,46 @@ describe("discuss tool scoping (#2949)", () => {
     );
   });
 
-  test("guided-discuss-slice.md references gsd_summary_save", () => {
-    const prompt = readFileSync(join(promptsDir, "guided-discuss-slice.md"), "utf-8");
-    assert.ok(
-      prompt.includes("gsd_summary_save"),
-      "guided-discuss-slice.md should reference gsd_summary_save",
-    );
-  });
-
-  test("discuss.md references gsd_plan_milestone and gsd_decision_save", () => {
-    const prompt = readFileSync(join(promptsDir, "discuss.md"), "utf-8");
-    assert.ok(
-      prompt.includes("gsd_plan_milestone"),
-      "discuss.md should reference gsd_plan_milestone",
-    );
-    assert.ok(
-      prompt.includes("gsd_decision_save"),
-      "discuss.md should reference gsd_decision_save",
-    );
-  });
+  test("dispatchWorkflow scopes and restores tools for discuss unit types", async () => {
+    const originalWorkflowPath = process.env.GSD_WORKFLOW_PATH;
+    const tmp = mkdtempSync(join(tmpdir(), "gsd-discuss-tools-"));
+    const workflowPath = join(tmp, "GSD-WORKFLOW.md");
+    writeFileSync(workflowPath, "# Workflow\n");
+    const setCalls: string[][] = [];
+    const sent: unknown[] = [];
+    let sentTools: string[] = [];
+    let activeTools = ["gsd_summary_save", "gsd_complete_task", "bash"];
+    process.env.GSD_WORKFLOW_PATH = workflowPath;
+    try {
+      await _dispatchWorkflowForTest(
+        {
+          getActiveTools: () => [...activeTools],
+          setActiveTools: (tools: string[]) => {
+            setCalls.push([...tools]);
+            activeTools = [...tools];
+          },
+          sendMessage: (message: unknown) => {
+            sent.push(message);
+            sentTools = [...activeTools];
+          },
+        } as any,
+        "Discuss the project",
+        "gsd-run",
+        undefined,
+        "discuss-milestone",
+      );
+    } finally {
+      if (originalWorkflowPath === undefined) delete process.env.GSD_WORKFLOW_PATH;
+      else process.env.GSD_WORKFLOW_PATH = originalWorkflowPath;
+      rmSync(tmp, { recursive: true, force: true });
+    }
 
-  test("dispatchWorkflow source code scopes tools for discuss unit types", () => {
-    const source = readFileSync(guidedFlowPath, "utf-8");
-    // Verify that dispatchWorkflow references the allowlist for tool scoping
-    assert.ok(
-      source.includes("DISCUSS_TOOLS_ALLOWLIST"),
-      "guided-flow.ts should reference DISCUSS_TOOLS_ALLOWLIST for tool scoping",
-    );
-    assert.ok(
-      source.includes("setActiveTools"),
-      "guided-flow.ts should call setActiveTools to scope tools during discuss",
-    );
+    assert.deepEqual(setCalls[0], ["gsd_summary_save", "bash"]);
+    assert.deepEqual(setCalls.at(-1), ["gsd_summary_save", "gsd_complete_task", "bash"]);
+    assert.ok(sentTools.length > 0, "dispatch should queue a message");
+    assert.ok(sentTools.includes("gsd_summary_save"), "dispatch keeps the discuss save tool");
+    assert.ok(!sentTools.includes("gsd_complete_task"), "dispatch removes heavy completion tools");
+    assert.equal(sent.length, 1);
+    assert.match(String((sent[0] as { content?: unknown }).content), /Discuss the project/);
   });
 });

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

@@ -1,58 +1,76 @@
 /**
  * dispatch-complete-milestone-guard.test.ts — #4324
- *
- * Verify that the completing-milestone dispatch rule has a defense-in-depth
- * DB status guard. When the DB marks a milestone as closed, the rule must
- * return skip instead of dispatching a redundant complete-milestone unit.
- * This prevents silent data loss when the legacy filesystem state-derivation
- * path produces a stale completing-milestone phase.
  */
 
-import { describe, test } from "node:test";
+import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "auto-dispatch.ts");
+import { DISPATCH_RULES, type DispatchContext } from "../auto-dispatch.ts";
+import { closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
+
+function makeBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-complete-dispatch-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "ROADMAP.md"), "# M001\n\n## Slices\n\n- [x] **S01**: Done\n");
+  writeFileSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "SUMMARY.md"), "# Summary\n");
+  writeFileSync(join(base, "implementation.txt"), "done\n");
+  return base;
+}
+
+function buildDispatchCtx(basePath: string): DispatchContext {
+  return {
+    basePath,
+    mid: "M001",
+    midTitle: "Milestone One",
+    state: {
+      activeMilestone: { id: "M001", title: "Milestone One" },
+      activeSlice: null,
+      activeTask: null,
+      phase: "completing-milestone",
+      recentDecisions: [],
+      blockers: [],
+      nextAction: "",
+      registry: [{ id: "M001", title: "Milestone One", status: "active" }],
+      requirements: { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 },
+      progress: { milestones: { done: 0, total: 1 } },
+    },
+    prefs: undefined,
+  };
+}
 
 describe("completing-milestone dispatch guard (#4324)", () => {
-  const source = readFileSync(sourceFile, "utf-8");
+  let base = "";
+  const rule = DISPATCH_RULES.find((candidate) => candidate.name === "completing-milestone → complete-milestone");
+  assert.ok(rule, "complete-milestone dispatch rule should exist");
 
-  test("imports isClosedStatus from status-guards", () => {
-    assert.match(source, /import\s*\{[^}]*isClosedStatus[^}]*\}\s*from\s*["']\.\/status-guards/);
+  afterEach(() => {
+    try { closeDatabase(); } catch { /* ignore */ }
+    if (base) rmSync(base, { recursive: true, force: true });
+    base = "";
   });
 
-  test("checks DB milestone status before dispatching complete-milestone", () => {
-    assert.match(source, /isClosedStatus\(milestone\.status\)/);
-  });
+  test("skips complete-milestone dispatch when the DB milestone is already closed", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
 
-  test("isClosedStatus guard appears in the completing-milestone rule", () => {
-    // The completing-milestone phase check and the isClosedStatus guard
-    // must both appear in the same rule, with the guard before dispatch.
-    const phaseCheck = source.indexOf('phase !== "completing-milestone"');
-    assert.ok(phaseCheck > -1, "completing-milestone phase check should exist");
+    const result = await rule.match(buildDispatchCtx(base));
 
-    // Find the isClosedStatus guard after the phase check
-    const guardIdx = source.indexOf("isClosedStatus(milestone.status)", phaseCheck);
-    assert.ok(guardIdx > -1, "isClosedStatus guard should appear after the phase check");
+    assert.equal(result?.action, "skip");
+  });
 
-    // Find the skip return after the guard
-    const skipIdx = source.indexOf('action: "skip"', guardIdx);
-    assert.ok(skipIdx > -1, "skip action should follow the isClosedStatus guard");
+  test("dispatches complete-milestone when the DB milestone is still active", async () => {
+    base = makeBase();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
 
-    // The skip should come before the dispatch in this rule
-    const dispatchIdx = source.indexOf('unitType: "complete-milestone"', skipIdx);
-    assert.ok(dispatchIdx > -1, "complete-milestone dispatch should exist after the skip guard");
-  });
+    const result = await rule.match(buildDispatchCtx(base));
 
-  test("does not reconcile DB from SUMMARY.md projection (#4658 superseded)", () => {
-    const phaseCheck = source.indexOf('phase !== "completing-milestone"');
-    assert.ok(phaseCheck > -1, "completing-milestone phase check should exist");
-    const ruleTail = source.slice(phaseCheck, source.indexOf('name:', phaseCheck + 1));
-    assert.doesNotMatch(ruleTail, /resolveMilestoneFile\(basePath,\s*mid,\s*"SUMMARY"\)/);
-    assert.doesNotMatch(ruleTail, /classifyMilestoneSummaryContent/);
-    assert.doesNotMatch(ruleTail, /updateMilestoneStatus\(mid,\s*"complete"/);
+    assert.equal(result?.action, "dispatch");
+    assert.equal(result?.unitType, "complete-milestone");
+    assert.equal(result?.unitId, "M001");
   });
 });

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

@@ -1,33 +1,43 @@
 /**
  * dispatch-guard-closed-status.test.ts — #3653
  *
- * Verify that the dispatch guard uses isClosedStatus() instead of a raw
- * `status === "complete"` check when determining whether a slice is done.
+ * Verify that the dispatch guard treats all closed DB slice statuses as done.
  * Reconciled slices may carry statuses like "skipped" or "cancelled" which
  * are also closed — the raw check caused false dispatch blocks.
  */
 
-import { describe, test } from "node:test";
+import { afterEach, beforeEach, describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const sourceFile = join(__dirname, "..", "dispatch-guard.ts");
+import { getPriorSliceCompletionBlocker } from "../dispatch-guard.ts";
+import { closeDatabase, insertMilestone, insertSlice, openDatabase } from "../gsd-db.ts";
 
 describe("dispatch-guard isClosedStatus migration (#3653)", () => {
-  const source = readFileSync(sourceFile, "utf-8");
+  let base: string;
 
-  test("imports isClosedStatus from status-guards", () => {
-    assert.match(source, /import\s*\{[^}]*isClosedStatus[^}]*\}\s*from\s*["']\.\/status-guards/);
+  beforeEach(() => {
+    base = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-closed-"));
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(join(base, ".gsd", "milestones", "M001", "CONTEXT.md"), "# M001\n");
+    openDatabase(join(base, ".gsd", "gsd.db"));
   });
 
-  test("uses isClosedStatus() for slice done check instead of raw comparison", () => {
-    assert.match(source, /done:\s*isClosedStatus\(r\.status\)/);
+  afterEach(() => {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
   });
 
-  test("does not use raw status === 'complete' for DB slice rows", () => {
-    assert.doesNotMatch(source, /done:\s*r\.status\s*===\s*["']complete["']/);
+  test("skipped prior DB slices do not block later slice dispatch", () => {
+    insertMilestone({ id: "M001", title: "Milestone 1", status: "active", depends_on: [] });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Skipped Slice", status: "skipped", depends: [] });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Next Slice", status: "pending", depends: [] });
+
+    assert.equal(
+      getPriorSliceCompletionBlocker(base, "main", "execute-task", "M001-S02-T01"),
+      null,
+    );
   });
 });