gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/tests/dev-engine-wrapper.test.ts

@@ -73,7 +73,7 @@ describe("DevWorkflowEngine", () => {
     assert.equal(engine.engineId, "dev");
   });
 
-  test("deriveState returns EngineState with expected fields", async () => {
+  test("deriveState returns EngineState with expected fields", async (t) => {
     const { DevWorkflowEngine } = await import("../dev-workflow-engine.ts");
     const engine = new DevWorkflowEngine();
 
@@ -81,31 +81,29 @@ describe("DevWorkflowEngine", () => {
     const tempDir = mkdtempSync(join(tmpdir(), "gsd-engine-test-"));
     mkdirSync(join(tempDir, ".gsd", "milestones"), { recursive: true });
 
-    try {
-      const state = await engine.deriveState(tempDir);
-
-      assert.equal(typeof state.phase, "string", "phase should be a string");
-      assert.ok(
-        "currentMilestoneId" in state,
-        "state should have currentMilestoneId",
-      );
-      assert.ok(
-        "activeSliceId" in state,
-        "state should have activeSliceId",
-      );
-      assert.ok(
-        "activeTaskId" in state,
-        "state should have activeTaskId",
-      );
-      assert.equal(
-        typeof state.isComplete,
-        "boolean",
-        "isComplete should be boolean",
-      );
-      assert.ok("raw" in state, "state should have raw field");
-    } finally {
-      rmSync(tempDir, { recursive: true, force: true });
-    }
+    t.after(() => rmSync(tempDir, { recursive: true, force: true }));
+
+    const state = await engine.deriveState(tempDir);
+
+    assert.equal(typeof state.phase, "string", "phase should be a string");
+    assert.ok(
+      "currentMilestoneId" in state,
+      "state should have currentMilestoneId",
+    );
+    assert.ok(
+      "activeSliceId" in state,
+      "state should have activeSliceId",
+    );
+    assert.ok(
+      "activeTaskId" in state,
+      "state should have activeTaskId",
+    );
+    assert.equal(
+      typeof state.isComplete,
+      "boolean",
+      "isComplete should be boolean",
+    );
+    assert.ok("raw" in state, "state should have raw field");
   });
 
   test("reconcile returns continue for non-complete state", async () => {
@@ -280,16 +278,14 @@ describe("Kill switch (GSD_ENGINE_BYPASS)", () => {
     }
   });
 
-  test("GSD_ENGINE_BYPASS=1 does not affect resolveEngine (bypass checked in autoLoop)", async () => {
+  test("GSD_ENGINE_BYPASS=1 does not affect resolveEngine (bypass checked in autoLoop)", async (t) => {
     const { resolveEngine } = await import("../engine-resolver.ts");
     process.env.GSD_ENGINE_BYPASS = "1";
-    try {
-      // resolveEngine should still resolve normally — bypass is checked in autoLoop
-      const { engine } = resolveEngine({ activeEngineId: null });
-      assert.ok(engine, "should return an engine even with bypass set");
-    } finally {
-      delete process.env.GSD_ENGINE_BYPASS;
-    }
+    t.after(() => delete process.env.GSD_ENGINE_BYPASS);
+
+    // resolveEngine should still resolve normally — bypass is checked in autoLoop
+    const { engine } = resolveEngine({ activeEngineId: null });
+    assert.ok(engine, "should return an engine even with bypass set");
   });
 });
 

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

@@ -4,184 +4,215 @@ import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { getPriorSliceCompletionBlocker } from "../dispatch-guard.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice } from "../gsd-db.ts";
 
-test("dispatch guard blocks when prior milestone has incomplete slices", () => {
+/** Helper: create temp dir and open an in-dir DB for dispatch-guard tests */
+function setupRepo(): string {
   const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
-  try {
-    mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
-    mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
-
-    writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
-      "# M002: Previous\n\n## Slices\n- [x] **S01: Done** `risk:low` `depends:[]`\n- [ ] **S02: Pending** `risk:low` `depends:[S01]`\n");
-    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"),
-      "# M003: Current\n\n## Slices\n- [ ] **S01: First** `risk:low` `depends:[]`\n- [ ] **S02: Second** `risk:low` `depends:[S01]`\n");
-
-    assert.equal(
-      getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M003/S01"),
-      "Cannot dispatch plan-slice M003/S01: earlier slice M002/S02 is not complete.",
-    );
-  } finally {
-    rmSync(repo, { recursive: true, force: true });
-  }
+  mkdirSync(join(repo, ".gsd"), { recursive: true });
+  openDatabase(join(repo, ".gsd", "gsd.db"));
+  return repo;
+}
+
+/** Helper: tear down repo (close DB then remove dir) */
+function teardownRepo(repo: string): void {
+  closeDatabase();
+  rmSync(repo, { recursive: true, force: true });
+}
+
+test("dispatch guard blocks when prior milestone has incomplete slices", (t) => {
+  const repo = setupRepo();
+  t.after(() => teardownRepo(repo));
+
+  mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
+  mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
+
+  // Seed DB: M002 with S01 complete, S02 pending
+  insertMilestone({ id: "M002", title: "Previous" });
+  insertSlice({ id: "S01", milestoneId: "M002", title: "Done", status: "complete", depends: [], sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M002", title: "Pending", status: "pending", depends: ["S01"], sequence: 2 });
+
+  // M003 with two pending slices
+  insertMilestone({ id: "M003", title: "Current" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "First", status: "pending", depends: [], sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M003", title: "Second", status: "pending", depends: ["S01"], sequence: 2 });
+
+  // Need ROADMAP files for milestone discovery (findMilestoneIds reads disk)
+  writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), "# M002\n");
+  writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"), "# M003\n");
+
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M003/S01"),
+    "Cannot dispatch plan-slice M003/S01: earlier slice M002/S02 is not complete.",
+  );
 });
 
-test("dispatch guard blocks later slice in same milestone when earlier incomplete", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
-  try {
-    mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
-    mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
-
-    writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
-      "# M002: Previous\n\n## Slices\n- [x] **S01: Done** `risk:low` `depends:[]`\n- [x] **S02: Done** `risk:low` `depends:[S01]`\n");
-    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"),
-      "# M003: Current\n\n## Slices\n- [ ] **S01: First** `risk:low` `depends:[]`\n- [ ] **S02: Second** `risk:low` `depends:[S01]`\n");
-
-    assert.equal(
-      getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M003/S02/T01"),
-      "Cannot dispatch execute-task M003/S02/T01: dependency slice M003/S01 is not complete.",
-    );
-  } finally {
-    rmSync(repo, { recursive: true, force: true });
-  }
+test("dispatch guard blocks later slice in same milestone when earlier incomplete", (t) => {
+  const repo = setupRepo();
+  t.after(() => teardownRepo(repo));
+
+  mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
+  mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
+
+  insertMilestone({ id: "M002", title: "Previous" });
+  insertSlice({ id: "S01", milestoneId: "M002", title: "Done", status: "complete", depends: [], sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M002", title: "Done", status: "complete", depends: ["S01"], sequence: 2 });
+
+  insertMilestone({ id: "M003", title: "Current" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "First", status: "pending", depends: [], sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M003", title: "Second", status: "pending", depends: ["S01"], sequence: 2 });
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), "# M002\n");
+  writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"), "# M003\n");
+
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M003/S02/T01"),
+    "Cannot dispatch execute-task M003/S02/T01: dependency slice M003/S01 is not complete.",
+  );
 });
 
-test("dispatch guard allows dispatch when all earlier slices complete", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
-  try {
-    mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"),
-      "# M003: Current\n\n## Slices\n- [x] **S01: First** `risk:low` `depends:[]`\n- [ ] **S02: Second** `risk:low` `depends:[S01]`\n");
-
-    assert.equal(getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M003/S02/T01"), null);
-    assert.equal(getPriorSliceCompletionBlocker(repo, "main", "plan-milestone", "M003"), null);
-  } finally {
-    rmSync(repo, { recursive: true, force: true });
-  }
+test("dispatch guard allows dispatch when all earlier slices complete", (t) => {
+  const repo = setupRepo();
+  t.after(() => teardownRepo(repo));
+
+  mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
+
+  insertMilestone({ id: "M003", title: "Current" });
+  insertSlice({ id: "S01", milestoneId: "M003", title: "First", status: "complete", depends: [], sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M003", title: "Second", status: "pending", depends: ["S01"], sequence: 2 });
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M003", "M003-ROADMAP.md"), "# M003\n");
+
+  assert.equal(getPriorSliceCompletionBlocker(repo, "main", "execute-task", "M003/S02/T01"), null);
+  assert.equal(getPriorSliceCompletionBlocker(repo, "main", "plan-milestone", "M003"), null);
 });
 
-test("dispatch guard unblocks slice when positionally-earlier slice depends on it (#1638)", () => {
+test("dispatch guard unblocks slice when positionally-earlier slice depends on it (#1638)", (t) => {
   // S05 depends on S06, but S05 appears first positionally.
   // Old behavior: S06 blocked because S05 (positionally earlier) is incomplete.
   // Fixed behavior: S06 has no unmet dependencies, so it can dispatch.
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
-  try {
-    mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-      "# M001: Test\n\n## Slices\n" +
-      "- [x] **S01: Setup** `risk:low` `depends:[]`\n" +
-      "- [x] **S02: Core** `risk:low` `depends:[S01]`\n" +
-      "- [x] **S03: API** `risk:low` `depends:[S02]`\n" +
-      "- [x] **S04: Auth** `risk:low` `depends:[S03]`\n" +
-      "- [ ] **S05: Integration** `risk:high` `depends:[S04,S06]`\n" +
-      "- [ ] **S06: Data Layer** `risk:medium` `depends:[S04]`\n");
-
-    // S06 depends only on S04 (complete) — should be unblocked
-    assert.equal(
-      getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S06"),
-      null,
-    );
-
-    // S05 depends on S04 (complete) and S06 (incomplete) — should be blocked
-    assert.equal(
-      getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S05"),
-      "Cannot dispatch plan-slice M001/S05: dependency slice M001/S06 is not complete.",
-    );
-  } finally {
-    rmSync(repo, { recursive: true, force: true });
-  }
+  const repo = setupRepo();
+  t.after(() => teardownRepo(repo));
+
+  mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+
+  insertMilestone({ id: "M001", title: "Test" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Setup", status: "complete", depends: [], sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M001", title: "Core", status: "complete", depends: ["S01"], sequence: 2 });
+  insertSlice({ id: "S03", milestoneId: "M001", title: "API", status: "complete", depends: ["S02"], sequence: 3 });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Auth", status: "complete", depends: ["S03"], sequence: 4 });
+  insertSlice({ id: "S05", milestoneId: "M001", title: "Integration", status: "pending", depends: ["S04", "S06"], sequence: 5 });
+  insertSlice({ id: "S06", milestoneId: "M001", title: "Data Layer", status: "pending", depends: ["S04"], sequence: 6 });
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
+
+  // S06 depends only on S04 (complete) — should be unblocked
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S06"),
+    null,
+  );
+
+  // S05 depends on S04 (complete) and S06 (incomplete) — should be blocked
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S05"),
+    "Cannot dispatch plan-slice M001/S05: dependency slice M001/S06 is not complete.",
+  );
 });
 
-test("dispatch guard falls back to positional ordering when no dependencies declared", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
-  try {
-    mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-      "# M001: Test\n\n## Slices\n" +
-      "- [x] **S01: First** `risk:low` `depends:[]`\n" +
-      "- [ ] **S02: Second** `risk:low` `depends:[]`\n" +
-      "- [ ] **S03: Third** `risk:low` `depends:[]`\n");
-
-    // S03 has no dependencies — positional fallback blocks on S02
-    assert.equal(
-      getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S03"),
-      "Cannot dispatch plan-slice M001/S03: earlier slice M001/S02 is not complete.",
-    );
-
-    // S02 has no dependencies — positional fallback: S01 is done, so unblocked
-    assert.equal(
-      getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S02"),
-      null,
-    );
-  } finally {
-    rmSync(repo, { recursive: true, force: true });
-  }
+test("dispatch guard falls back to positional ordering when no dependencies declared", (t) => {
+  const repo = setupRepo();
+  t.after(() => teardownRepo(repo));
+
+  mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+
+  insertMilestone({ id: "M001", title: "Test" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "First", status: "complete", depends: [], sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M001", title: "Second", status: "pending", depends: [], sequence: 2 });
+  insertSlice({ id: "S03", milestoneId: "M001", title: "Third", status: "pending", depends: [], sequence: 3 });
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
+
+  // S03 has no dependencies — positional fallback blocks on S02
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S03"),
+    "Cannot dispatch plan-slice M001/S03: earlier slice M001/S02 is not complete.",
+  );
+
+  // S02 has no dependencies — positional fallback: S01 is done, so unblocked
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S02"),
+    null,
+  );
 });
 
-test("dispatch guard allows slice with all declared dependencies complete", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
-  try {
-    mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-      "# M001: Test\n\n## Slices\n" +
-      "- [x] **S01: Setup** `risk:low` `depends:[]`\n" +
-      "- [x] **S02: Core** `risk:low` `depends:[S01]`\n" +
-      "- [ ] **S03: Feature A** `risk:low` `depends:[S01,S02]`\n" +
-      "- [ ] **S04: Feature B** `risk:low` `depends:[S01]`\n");
-
-    // S03 depends on S01 (done) and S02 (done) — unblocked
-    assert.equal(
-      getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S03"),
-      null,
-    );
-
-    // S04 depends only on S01 (done) — unblocked even though S03 is incomplete
-    assert.equal(
-      getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S04"),
-      null,
-    );
-  } finally {
-    rmSync(repo, { recursive: true, force: true });
-  }
+test("dispatch guard allows slice with all declared dependencies complete", (t) => {
+  const repo = setupRepo();
+  t.after(() => teardownRepo(repo));
+
+  mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+
+  insertMilestone({ id: "M001", title: "Test" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Setup", status: "complete", depends: [], sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M001", title: "Core", status: "complete", depends: ["S01"], sequence: 2 });
+  insertSlice({ id: "S03", milestoneId: "M001", title: "Feature A", status: "pending", depends: ["S01", "S02"], sequence: 3 });
+  insertSlice({ id: "S04", milestoneId: "M001", title: "Feature B", status: "pending", depends: ["S01"], sequence: 4 });
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
+
+  // S03 depends on S01 (done) and S02 (done) — unblocked
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S03"),
+    null,
+  );
+
+  // S04 depends only on S01 (done) — unblocked even though S03 is incomplete
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S04"),
+    null,
+  );
 });
 
-test("dispatch guard skips completed milestone with SUMMARY even if it has unchecked remediation slices (#1716)", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-"));
-  try {
-    mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
-    mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
-
-    // M001 is complete (has SUMMARY) but has unchecked remediation slices
-    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-      "# M001: Previous\n\n## Slices\n" +
-      "- [x] **S01: Core** `risk:low` `depends:[]`\n" +
-      "- [x] **S02: Tests** `risk:low` `depends:[S01]`\n" +
-      "- [ ] **S03-R: Remediation** `risk:low` `depends:[S02]`\n" +
-      "- [ ] **S04-R: Remediation 2** `risk:low` `depends:[S02]`\n");
-    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-SUMMARY.md"),
-      "---\nstatus: complete\n---\n# M001 Summary\nDone.\n");
-
-    writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"),
-      "# M002: Current\n\n## Slices\n- [ ] **S01: Start** `risk:low` `depends:[]`\n");
-
-    // M001 has SUMMARY — should be skipped, not block M002/S01
-    assert.equal(
-      getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M002/S01"),
-      null,
-    );
-  } finally {
-    rmSync(repo, { recursive: true, force: true });
-  }
+test("dispatch guard skips completed milestone with SUMMARY even if it has unchecked remediation slices (#1716)", (t) => {
+  const repo = setupRepo();
+  t.after(() => teardownRepo(repo));
+
+  mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+  mkdirSync(join(repo, ".gsd", "milestones", "M002"), { recursive: true });
+
+  // M001 is complete (has SUMMARY) but has unchecked remediation slices in DB
+  insertMilestone({ id: "M001", title: "Previous" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Core", status: "complete", depends: [], sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M001", title: "Tests", status: "complete", depends: ["S01"], sequence: 2 });
+  insertSlice({ id: "S03-R", milestoneId: "M001", title: "Remediation", status: "pending", depends: ["S02"], sequence: 3 });
+  insertSlice({ id: "S04-R", milestoneId: "M001", title: "Remediation 2", status: "pending", depends: ["S02"], sequence: 4 });
+
+  insertMilestone({ id: "M002", title: "Current" });
+  insertSlice({ id: "S01", milestoneId: "M002", title: "Start", status: "pending", depends: [], sequence: 1 });
+
+  // M001 SUMMARY on disk triggers skip
+  writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
+  writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-SUMMARY.md"),
+    "---\nstatus: complete\n---\n# M001 Summary\nDone.\n");
+  writeFileSync(join(repo, ".gsd", "milestones", "M002", "M002-ROADMAP.md"), "# M002\n");
+
+  // M001 has SUMMARY — should be skipped, not block M002/S01
+  assert.equal(
+    getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M002/S01"),
+    null,
+  );
 });
 
-test("dispatch guard works without git repo", () => {
-  const repo = mkdtempSync(join(tmpdir(), "gsd-dispatch-guard-nogit-"));
-  try {
-    mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
-    writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
-      "# M001: Test\n\n## Slices\n- [x] **S01: Done** `risk:low` `depends:[]`\n- [ ] **S02: Pending** `risk:low` `depends:[S01]`\n");
-
-    assert.equal(getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S02"), null);
-  } finally {
-    rmSync(repo, { recursive: true, force: true });
-  }
+test("dispatch guard works without git repo", (t) => {
+  const repo = setupRepo();
+  t.after(() => teardownRepo(repo));
+
+  mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+
+  insertMilestone({ id: "M001", title: "Test" });
+  insertSlice({ id: "S01", milestoneId: "M001", title: "Done", status: "complete", depends: [], sequence: 1 });
+  insertSlice({ id: "S02", milestoneId: "M001", title: "Pending", status: "pending", depends: ["S01"], sequence: 2 });
+
+  writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
+
+  assert.equal(getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S02"), null);
 });

package/src/resources/extensions/gsd/tests/dispatch-missing-task-plans.test.ts

@@ -71,62 +71,56 @@ function scaffoldTaskPlan(basePath: string, mid: string, sid: string, tid: strin
 
 // ─── Tests ─────────────────────────────────────────────────────────────────
 
-test("dispatch: missing task plan triggers plan-slice (not stop) — issue #909", async () => {
+test("dispatch: missing task plan triggers plan-slice (not stop) — issue #909", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-909-"));
-  try {
-    // Slice plan exists with tasks, but tasks/ directory is empty
-    scaffoldSlicePlan(tmp, "M002", "S03");
-
-    const ctx = makeContext(tmp);
-    const result = await resolveDispatch(ctx);
-
-    assert.equal(result.action, "dispatch", "should dispatch, not stop");
-    assert.ok(result.action === "dispatch" && result.unitType === "plan-slice",
-      `unitType should be plan-slice, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
-    assert.ok(result.action === "dispatch" && result.unitId === "M002/S03",
-      `unitId should be M002/S03, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  // Slice plan exists with tasks, but tasks/ directory is empty
+  scaffoldSlicePlan(tmp, "M002", "S03");
+
+  const ctx = makeContext(tmp);
+  const result = await resolveDispatch(ctx);
+
+  assert.equal(result.action, "dispatch", "should dispatch, not stop");
+  assert.ok(result.action === "dispatch" && result.unitType === "plan-slice",
+    `unitType should be plan-slice, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+  assert.ok(result.action === "dispatch" && result.unitId === "M002/S03",
+    `unitId should be M002/S03, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
 });
 
-test("dispatch: present task plan proceeds to execute-task normally", async () => {
+test("dispatch: present task plan proceeds to execute-task normally", async (t) => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-909-ok-"));
-  try {
-    scaffoldSlicePlan(tmp, "M002", "S03");
-    scaffoldTaskPlan(tmp, "M002", "S03", "T01");
-
-    const ctx = makeContext(tmp);
-    const result = await resolveDispatch(ctx);
-
-    assert.equal(result.action, "dispatch");
-    assert.ok(result.action === "dispatch" && result.unitType === "execute-task",
-      `unitType should be execute-task, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
-    assert.ok(result.action === "dispatch" && result.unitId === "M002/S03/T01",
-      `unitId should be M002/S03/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldSlicePlan(tmp, "M002", "S03");
+  scaffoldTaskPlan(tmp, "M002", "S03", "T01");
+
+  const ctx = makeContext(tmp);
+  const result = await resolveDispatch(ctx);
+
+  assert.equal(result.action, "dispatch");
+  assert.ok(result.action === "dispatch" && result.unitType === "execute-task",
+    `unitType should be execute-task, got: ${result.action === "dispatch" ? result.unitType : "(stop)"}`);
+  assert.ok(result.action === "dispatch" && result.unitId === "M002/S03/T01",
+    `unitId should be M002/S03/T01, got: ${result.action === "dispatch" ? result.unitId : "(stop)"}`);
 });
 
-test("dispatch: plan-slice recovery loop — second call after plan-slice still recovers cleanly", async () => {
+test("dispatch: plan-slice recovery loop — second call after plan-slice still recovers cleanly", async (t) => {
   // Simulate: plan-slice ran but T01-PLAN.md is still missing (e.g. agent crashed mid-write).
   // Dispatch should still re-dispatch plan-slice, not hard-stop.
   const tmp = mkdtempSync(join(tmpdir(), "gsd-909-loop-"));
-  try {
-    scaffoldSlicePlan(tmp, "M002", "S03");
-
-    const ctx = makeContext(tmp);
-    const r1 = await resolveDispatch(ctx);
-    assert.equal(r1.action, "dispatch");
-    assert.ok(r1.action === "dispatch" && r1.unitType === "plan-slice");
-
-    // Still no task plan written — dispatch again
-    const r2 = await resolveDispatch(ctx);
-    assert.equal(r2.action, "dispatch");
-    assert.ok(r2.action === "dispatch" && r2.unitType === "plan-slice",
-      "should keep dispatching plan-slice until task plans appear");
-  } finally {
-    rmSync(tmp, { recursive: true, force: true });
-  }
+  t.after(() => rmSync(tmp, { recursive: true, force: true }));
+
+  scaffoldSlicePlan(tmp, "M002", "S03");
+
+  const ctx = makeContext(tmp);
+  const r1 = await resolveDispatch(ctx);
+  assert.equal(r1.action, "dispatch");
+  assert.ok(r1.action === "dispatch" && r1.unitType === "plan-slice");
+
+  // Still no task plan written — dispatch again
+  const r2 = await resolveDispatch(ctx);
+  assert.equal(r2.action, "dispatch");
+  assert.ok(r2.action === "dispatch" && r2.unitType === "plan-slice",
+    "should keep dispatching plan-slice until task plans appear");
 });