gsd-pi 2.44.0 → 2.45.0-dev.6b9da3e

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

@@ -20,215 +20,199 @@ function teardownRepo(repo: string): void {
   rmSync(repo, { recursive: true, force: true });
 }
 
-test("dispatch guard blocks when prior milestone has incomplete slices", () => {
+test("dispatch guard blocks when prior milestone has incomplete slices", (t) => {
   const repo = setupRepo();
-  try {
-    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.",
-    );
-  } finally {
-    teardownRepo(repo);
-  }
+  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", () => {
+test("dispatch guard blocks later slice in same milestone when earlier incomplete", (t) => {
   const repo = setupRepo();
-  try {
-    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.",
-    );
-  } finally {
-    teardownRepo(repo);
-  }
+  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", () => {
+test("dispatch guard allows dispatch when all earlier slices complete", (t) => {
   const repo = setupRepo();
-  try {
-    mkdirSync(join(repo, ".gsd", "milestones", "M003"), { recursive: true });
+  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 });
+  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");
+  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);
-  } finally {
-    teardownRepo(repo);
-  }
+  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 = setupRepo();
-  try {
-    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.",
-    );
-  } finally {
-    teardownRepo(repo);
-  }
+  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", () => {
+test("dispatch guard falls back to positional ordering when no dependencies declared", (t) => {
   const repo = setupRepo();
-  try {
-    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,
-    );
-  } finally {
-    teardownRepo(repo);
-  }
+  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", () => {
+test("dispatch guard allows slice with all declared dependencies complete", (t) => {
   const repo = setupRepo();
-  try {
-    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,
-    );
-  } finally {
-    teardownRepo(repo);
-  }
+  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)", () => {
+test("dispatch guard skips completed milestone with SUMMARY even if it has unchecked remediation slices (#1716)", (t) => {
   const repo = setupRepo();
-  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 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,
-    );
-  } finally {
-    teardownRepo(repo);
-  }
+  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", () => {
+test("dispatch guard works without git repo", (t) => {
   const repo = setupRepo();
-  try {
-    mkdirSync(join(repo, ".gsd", "milestones", "M001"), { recursive: true });
+  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 });
+  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");
+  writeFileSync(join(repo, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), "# M001\n");
 
-    assert.equal(getPriorSliceCompletionBlocker(repo, "main", "plan-slice", "M001/S02"), null);
-  } finally {
-    teardownRepo(repo);
-  }
+  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");
 });