gsd-pi 2.44.0-dev.848dd4c → 2.44.0

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 (t) => {
+  test("deriveState returns EngineState with expected fields", async () => {
     const { DevWorkflowEngine } = await import("../dev-workflow-engine.ts");
     const engine = new DevWorkflowEngine();
 
@@ -81,29 +81,31 @@ describe("DevWorkflowEngine", () => {
     const tempDir = mkdtempSync(join(tmpdir(), "gsd-engine-test-"));
     mkdirSync(join(tempDir, ".gsd", "milestones"), { recursive: 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");
+    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 });
+    }
   });
 
   test("reconcile returns continue for non-complete state", async () => {
@@ -278,14 +280,16 @@ describe("Kill switch (GSD_ENGINE_BYPASS)", () => {
     }
   });
 
-  test("GSD_ENGINE_BYPASS=1 does not affect resolveEngine (bypass checked in autoLoop)", async (t) => {
+  test("GSD_ENGINE_BYPASS=1 does not affect resolveEngine (bypass checked in autoLoop)", async () => {
     const { resolveEngine } = await import("../engine-resolver.ts");
     process.env.GSD_ENGINE_BYPASS = "1";
-    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");
+    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;
+    }
   });
 });
 

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

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

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

@@ -71,56 +71,62 @@ function scaffoldTaskPlan(basePath: string, mid: string, sid: string, tid: strin
 
 // ─── Tests ─────────────────────────────────────────────────────────────────
 
-test("dispatch: missing task plan triggers plan-slice (not stop) — issue #909", async (t) => {
+test("dispatch: missing task plan triggers plan-slice (not stop) — issue #909", async () => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-909-"));
-  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)"}`);
+  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 });
+  }
 });
 
-test("dispatch: present task plan proceeds to execute-task normally", async (t) => {
+test("dispatch: present task plan proceeds to execute-task normally", async () => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-909-ok-"));
-  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)"}`);
+  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 });
+  }
 });
 
-test("dispatch: plan-slice recovery loop — second call after plan-slice still recovers cleanly", async (t) => {
+test("dispatch: plan-slice recovery loop — second call after plan-slice still recovers cleanly", async () => {
   // 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-"));
-  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");
+  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 });
+  }
 });