gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/gitignore-tracked-gsd.test.ts

@@ -53,37 +53,43 @@ function cleanup(dir: string): void {
 
 // ─── hasGitTrackedGsdFiles ───────────────────────────────────────────
 
-test("hasGitTrackedGsdFiles returns false when .gsd/ does not exist", (t) => {
+test("hasGitTrackedGsdFiles returns false when .gsd/ does not exist", () => {
   const dir = makeTempRepo();
-  t.after(() => { cleanup(dir); });
-
-  assert.equal(hasGitTrackedGsdFiles(dir), false);
+  try {
+    assert.equal(hasGitTrackedGsdFiles(dir), false);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("hasGitTrackedGsdFiles returns true when .gsd/ has tracked files", (t) => {
+test("hasGitTrackedGsdFiles returns true when .gsd/ has tracked files", () => {
   const dir = makeTempRepo();
-  t.after(() => { cleanup(dir); });
-
-  mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
-  writeFileSync(join(dir, ".gsd", "PROJECT.md"), "# Test Project\n");
-  git(dir, "add", ".gsd/PROJECT.md");
-  git(dir, "commit", "-m", "add gsd");
-  assert.equal(hasGitTrackedGsdFiles(dir), true);
+  try {
+    mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+    writeFileSync(join(dir, ".gsd", "PROJECT.md"), "# Test Project\n");
+    git(dir, "add", ".gsd/PROJECT.md");
+    git(dir, "commit", "-m", "add gsd");
+    assert.equal(hasGitTrackedGsdFiles(dir), true);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("hasGitTrackedGsdFiles returns false when .gsd/ exists but is untracked", (t) => {
+test("hasGitTrackedGsdFiles returns false when .gsd/ exists but is untracked", () => {
   const dir = makeTempRepo();
-  t.after(() => { cleanup(dir); });
-
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-  writeFileSync(join(dir, ".gsd", "STATE.md"), "state\n");
-  // Not git-added — should return false
-  assert.equal(hasGitTrackedGsdFiles(dir), false);
+  try {
+    mkdirSync(join(dir, ".gsd"), { recursive: true });
+    writeFileSync(join(dir, ".gsd", "STATE.md"), "state\n");
+    // Not git-added — should return false
+    assert.equal(hasGitTrackedGsdFiles(dir), false);
+  } finally {
+    cleanup(dir);
+  }
 });
 
 // ─── ensureGitignore — tracked .gsd/ protection ─────────────────────
 
-test("ensureGitignore does NOT add .gsd when .gsd/ has tracked files (#1364)", (t) => {
+test("ensureGitignore does NOT add .gsd when .gsd/ has tracked files (#1364)", () => {
   const dir = makeTempRepo();
   try {
     // Set up .gsd/ with tracked files
@@ -112,7 +118,7 @@ test("ensureGitignore does NOT add .gsd when .gsd/ has tracked files (#1364)", (
   }
 });
 
-test("ensureGitignore adds .gsd when .gsd/ has NO tracked files", (t) => {
+test("ensureGitignore adds .gsd when .gsd/ has NO tracked files", () => {
   const dir = makeTempRepo();
   try {
     // Run ensureGitignore (no .gsd/ at all)
@@ -130,18 +136,20 @@ test("ensureGitignore adds .gsd when .gsd/ has NO tracked files", (t) => {
   }
 });
 
-test("ensureGitignore respects manageGitignore: false", (t) => {
+test("ensureGitignore respects manageGitignore: false", () => {
   const dir = makeTempRepo();
-  t.after(() => { cleanup(dir); });
-
-  const result = ensureGitignore(dir, { manageGitignore: false });
-  assert.equal(result, false);
-  assert.ok(!existsSync(join(dir, ".gitignore")), "Should not create .gitignore");
+  try {
+    const result = ensureGitignore(dir, { manageGitignore: false });
+    assert.equal(result, false);
+    assert.ok(!existsSync(join(dir, ".gitignore")), "Should not create .gitignore");
+  } finally {
+    cleanup(dir);
+  }
 });
 
 // ─── ensureGitignore — verify no tracked files become invisible ─────
 
-test("ensureGitignore with tracked .gsd/ does not cause git to see files as deleted", (t) => {
+test("ensureGitignore with tracked .gsd/ does not cause git to see files as deleted", () => {
   const dir = makeTempRepo();
   try {
     // Create tracked .gsd/ files
@@ -175,7 +183,7 @@ test("ensureGitignore with tracked .gsd/ does not cause git to see files as dele
   }
 });
 
-test("hasGitTrackedGsdFiles returns true (fail-safe) when git is not available", (t) => {
+test("hasGitTrackedGsdFiles returns true (fail-safe) when git is not available", () => {
   const dir = makeTempRepo();
   try {
     // Create and track .gsd/ files
@@ -199,7 +207,7 @@ test("hasGitTrackedGsdFiles returns true (fail-safe) when git is not available",
 
 // ─── migrateToExternalState — tracked .gsd/ protection ──────────────
 
-test("migrateToExternalState aborts when .gsd/ has tracked files (#1364)", (t) => {
+test("migrateToExternalState aborts when .gsd/ has tracked files (#1364)", () => {
   const dir = makeTempRepo();
   try {
     // Create tracked .gsd/ files
@@ -227,7 +235,7 @@ test("migrateToExternalState aborts when .gsd/ has tracked files (#1364)", (t) =
   }
 });
 
-test("migrateToExternalState cleans git index so tracked files don't show as deleted (#1364 path 2)", (t) => {
+test("migrateToExternalState cleans git index so tracked files don't show as deleted (#1364 path 2)", () => {
   const dir = makeTempRepo();
   try {
     // Track .gsd/ files, then untrack them so migration proceeds

package/src/resources/extensions/gsd/tests/graph-operations.test.ts

@@ -56,7 +56,7 @@ function makeStep(overrides: Partial<GraphStep> & { id: string }): GraphStep {
 // ─── writeGraph + readGraph round-trip ───────────────────────────────────
 
 describe("writeGraph + readGraph round-trip", () => {
-  it("preserves all fields including parentStepId and dependsOn", (t) => {
+  it("preserves all fields including parentStepId and dependsOn", () => {
     const dir = makeTmpDir();
     try {
       const graph = makeGraph([
@@ -89,7 +89,7 @@ describe("writeGraph + readGraph round-trip", () => {
     }
   });
 
-  it("preserves startedAt and finishedAt fields", (t) => {
+  it("preserves startedAt and finishedAt fields", () => {
     const dir = makeTmpDir();
     try {
       const graph = makeGraph([
@@ -110,7 +110,7 @@ describe("writeGraph + readGraph round-trip", () => {
     }
   });
 
-  it("creates directory if it does not exist", (t) => {
+  it("creates directory if it does not exist", () => {
     const base = makeTmpDir();
     const nested = join(base, "sub", "dir");
     try {
@@ -129,53 +129,59 @@ describe("writeGraph + readGraph round-trip", () => {
 // ─── readGraph error paths ───────────────────────────────────────────────
 
 describe("readGraph error paths", () => {
-  it("throws with descriptive error when file is missing", (t) => {
+  it("throws with descriptive error when file is missing", () => {
     const dir = makeTmpDir();
-    t.after(() => { cleanupDir(dir); });
-
-    assert.throws(
-      () => readGraph(dir),
-      (err: Error) => {
-        assert.ok(err.message.includes("GRAPH.yaml not found"));
-        assert.ok(err.message.includes(dir));
-        return true;
-      },
-    );
+    try {
+      assert.throws(
+        () => readGraph(dir),
+        (err: Error) => {
+          assert.ok(err.message.includes("GRAPH.yaml not found"));
+          assert.ok(err.message.includes(dir));
+          return true;
+        },
+      );
+    } finally {
+      cleanupDir(dir);
+    }
   });
 
-  it("throws with descriptive error when YAML is malformed (missing steps)", (t) => {
+  it("throws with descriptive error when YAML is malformed (missing steps)", () => {
     const dir = makeTmpDir();
-    t.after(() => { cleanupDir(dir); });
-
-    writeFileSync(join(dir, "GRAPH.yaml"), "metadata:\n  name: bad\n", "utf-8");
-    assert.throws(
-      () => readGraph(dir),
-      (err: Error) => {
-        assert.ok(err.message.includes("missing or invalid 'steps' array"));
-        return true;
-      },
-    );
+    try {
+      writeFileSync(join(dir, "GRAPH.yaml"), "metadata:\n  name: bad\n", "utf-8");
+      assert.throws(
+        () => readGraph(dir),
+        (err: Error) => {
+          assert.ok(err.message.includes("missing or invalid 'steps' array"));
+          return true;
+        },
+      );
+    } finally {
+      cleanupDir(dir);
+    }
   });
 
-  it("throws when steps is not an array", (t) => {
+  it("throws when steps is not an array", () => {
     const dir = makeTmpDir();
-    t.after(() => { cleanupDir(dir); });
-
-    writeFileSync(join(dir, "GRAPH.yaml"), "steps: not-an-array\nmetadata:\n  name: bad\n", "utf-8");
-    assert.throws(
-      () => readGraph(dir),
-      (err: Error) => {
-        assert.ok(err.message.includes("missing or invalid 'steps' array"));
-        return true;
-      },
-    );
+    try {
+      writeFileSync(join(dir, "GRAPH.yaml"), "steps: not-an-array\nmetadata:\n  name: bad\n", "utf-8");
+      assert.throws(
+        () => readGraph(dir),
+        (err: Error) => {
+          assert.ok(err.message.includes("missing or invalid 'steps' array"));
+          return true;
+        },
+      );
+    } finally {
+      cleanupDir(dir);
+    }
   });
 });
 
 // ─── getNextPendingStep ──────────────────────────────────────────────────
 
 describe("getNextPendingStep", () => {
-  it("returns first step with all deps complete", (t) => {
+  it("returns first step with all deps complete", () => {
     const graph = makeGraph([
       makeStep({ id: "a", status: "complete" }),
       makeStep({ id: "b", dependsOn: ["a"] }),
@@ -186,7 +192,7 @@ describe("getNextPendingStep", () => {
     assert.equal(next?.id, "b");
   });
 
-  it("skips steps with incomplete deps", (t) => {
+  it("skips steps with incomplete deps", () => {
     const graph = makeGraph([
       makeStep({ id: "a" }),
       makeStep({ id: "b", dependsOn: ["a"] }),
@@ -197,7 +203,7 @@ describe("getNextPendingStep", () => {
     assert.equal(next?.id, "a");
   });
 
-  it("returns null when all steps are complete", (t) => {
+  it("returns null when all steps are complete", () => {
     const graph = makeGraph([
       makeStep({ id: "a", status: "complete" }),
       makeStep({ id: "b", status: "complete" }),
@@ -206,7 +212,7 @@ describe("getNextPendingStep", () => {
     assert.equal(getNextPendingStep(graph), null);
   });
 
-  it("returns null when all pending steps are blocked", (t) => {
+  it("returns null when all pending steps are blocked", () => {
     const graph = makeGraph([
       makeStep({ id: "a", status: "active" }), // not complete
       makeStep({ id: "b", dependsOn: ["a"] }),  // blocked
@@ -215,7 +221,7 @@ describe("getNextPendingStep", () => {
     assert.equal(getNextPendingStep(graph), null);
   });
 
-  it("returns first pending step with no deps when root steps exist", (t) => {
+  it("returns first pending step with no deps when root steps exist", () => {
     const graph = makeGraph([
       makeStep({ id: "a" }),
       makeStep({ id: "b" }),
@@ -225,7 +231,7 @@ describe("getNextPendingStep", () => {
     assert.equal(next?.id, "a");
   });
 
-  it("skips expanded steps", (t) => {
+  it("skips expanded steps", () => {
     const graph = makeGraph([
       makeStep({ id: "a", status: "expanded" }),
       makeStep({ id: "b" }),
@@ -239,7 +245,7 @@ describe("getNextPendingStep", () => {
 // ─── markStepComplete ────────────────────────────────────────────────────
 
 describe("markStepComplete", () => {
-  it("returns new graph with step status 'complete' (original unchanged)", (t) => {
+  it("returns new graph with step status 'complete' (original unchanged)", () => {
     const original = makeGraph([
       makeStep({ id: "a" }),
       makeStep({ id: "b" }),
@@ -258,7 +264,7 @@ describe("markStepComplete", () => {
     assert.equal(updated.steps[1].status, "pending");
   });
 
-  it("sets finishedAt timestamp", (t) => {
+  it("sets finishedAt timestamp", () => {
     const graph = makeGraph([makeStep({ id: "a" })]);
     const updated = markStepComplete(graph, "a");
     assert.ok(updated.steps[0].finishedAt);
@@ -266,7 +272,7 @@ describe("markStepComplete", () => {
     assert.ok(!isNaN(Date.parse(updated.steps[0].finishedAt!)));
   });
 
-  it("throws for unknown step ID", (t) => {
+  it("throws for unknown step ID", () => {
     const graph = makeGraph([makeStep({ id: "a" })]);
     assert.throws(
       () => markStepComplete(graph, "nonexistent"),
@@ -278,7 +284,7 @@ describe("markStepComplete", () => {
     );
   });
 
-  it("preserves metadata in returned graph", (t) => {
+  it("preserves metadata in returned graph", () => {
     const graph = makeGraph([makeStep({ id: "a" })], "my-workflow");
     const updated = markStepComplete(graph, "a");
     assert.equal(updated.metadata.name, "my-workflow");
@@ -289,7 +295,7 @@ describe("markStepComplete", () => {
 // ─── expandIteration ─────────────────────────────────────────────────────
 
 describe("expandIteration", () => {
-  it("creates instance steps with correct IDs (stepId--001, stepId--002)", (t) => {
+  it("creates instance steps with correct IDs (stepId--001, stepId--002)", () => {
     const graph = makeGraph([
       makeStep({ id: "iter-step", title: "Process items" }),
       makeStep({ id: "final", dependsOn: ["iter-step"] }),
@@ -311,7 +317,7 @@ describe("expandIteration", () => {
     assert.equal(expanded.steps[3].id, "iter-step--003");
   });
 
-  it("marks parent step as 'expanded'", (t) => {
+  it("marks parent step as 'expanded'", () => {
     const graph = makeGraph([
       makeStep({ id: "iter", title: "Iterate" }),
     ]);
@@ -320,7 +326,7 @@ describe("expandIteration", () => {
     assert.equal(expanded.steps[0].status, "expanded");
   });
 
-  it("instance steps have correct titles, prompts, parentStepId, and deps", (t) => {
+  it("instance steps have correct titles, prompts, parentStepId, and deps", () => {
     const graph = makeGraph([
       makeStep({ id: "pre", status: "complete" }),
       makeStep({ id: "iter", title: "Process", dependsOn: ["pre"] }),
@@ -346,7 +352,7 @@ describe("expandIteration", () => {
     assert.equal(inst2.parentStepId, "iter");
   });
 
-  it("rewrites downstream deps from parent ID to all instance IDs", (t) => {
+  it("rewrites downstream deps from parent ID to all instance IDs", () => {
     const graph = makeGraph([
       makeStep({ id: "iter", title: "Iterate" }),
       makeStep({ id: "after", dependsOn: ["iter"] }),
@@ -364,7 +370,7 @@ describe("expandIteration", () => {
     assert.deepStrictEqual(afterStep.dependsOn, ["iter--001", "iter--002"]);
   });
 
-  it("preserves steps that don't depend on the parent", (t) => {
+  it("preserves steps that don't depend on the parent", () => {
     const graph = makeGraph([
       makeStep({ id: "unrelated" }),
       makeStep({ id: "iter", title: "Iterate" }),
@@ -376,7 +382,7 @@ describe("expandIteration", () => {
     assert.deepStrictEqual(unrelated.dependsOn, []);
   });
 
-  it("throws for non-pending parent step", (t) => {
+  it("throws for non-pending parent step", () => {
     const graph = makeGraph([
       makeStep({ id: "iter", status: "complete" }),
     ]);
@@ -391,7 +397,7 @@ describe("expandIteration", () => {
     );
   });
 
-  it("throws for unknown step ID", (t) => {
+  it("throws for unknown step ID", () => {
     const graph = makeGraph([makeStep({ id: "a" })]);
     assert.throws(
       () => expandIteration(graph, "nonexistent", ["a"], "{{item}}"),
@@ -403,7 +409,7 @@ describe("expandIteration", () => {
     );
   });
 
-  it("does not mutate the input graph", (t) => {
+  it("does not mutate the input graph", () => {
     const graph = makeGraph([
       makeStep({ id: "iter", title: "Iterate" }),
       makeStep({ id: "after", dependsOn: ["iter"] }),
@@ -424,7 +430,7 @@ describe("expandIteration", () => {
 // ─── initializeGraph ─────────────────────────────────────────────────────
 
 describe("initializeGraph", () => {
-  it("converts a valid 3-step definition to graph with all pending steps", (t) => {
+  it("converts a valid 3-step definition to graph with all pending steps", () => {
     const def: WorkflowDefinition = {
       version: 1,
       name: "test-workflow",
@@ -459,7 +465,7 @@ describe("initializeGraph", () => {
     assert.deepStrictEqual(graph.steps[2].dependsOn, ["s1", "s2"]);
   });
 
-  it("is also exported as graphFromDefinition (backward compat)", (t) => {
+  it("is also exported as graphFromDefinition (backward compat)", () => {
     assert.equal(graphFromDefinition, initializeGraph);
   });
 });
@@ -467,7 +473,7 @@ describe("initializeGraph", () => {
 // ─── Atomic write safety ─────────────────────────────────────────────────
 
 describe("atomic write safety", () => {
-  it("final file exists and .tmp file does not exist after write", (t) => {
+  it("final file exists and .tmp file does not exist after write", () => {
     const dir = makeTmpDir();
     try {
       const graph = makeGraph([makeStep({ id: "s1" })]);
@@ -480,7 +486,7 @@ describe("atomic write safety", () => {
     }
   });
 
-  it("YAML content is valid and parseable", (t) => {
+  it("YAML content is valid and parseable", () => {
     const dir = makeTmpDir();
     try {
       const graph = makeGraph([makeStep({ id: "s1" })]);
@@ -501,7 +507,7 @@ describe("atomic write safety", () => {
 // ─── YAML snake_case / camelCase boundary ────────────────────────────────
 
 describe("YAML snake_case / camelCase boundary", () => {
-  it("writes snake_case to disk and reads back as camelCase", (t) => {
+  it("writes snake_case to disk and reads back as camelCase", () => {
     const dir = makeTmpDir();
     try {
       const graph = makeGraph([
@@ -535,7 +541,7 @@ describe("YAML snake_case / camelCase boundary", () => {
     }
   });
 
-  it("omits optional fields from YAML when undefined", (t) => {
+  it("omits optional fields from YAML when undefined", () => {
     const dir = makeTmpDir();
     try {
       const graph = makeGraph([
@@ -559,7 +565,7 @@ describe("YAML snake_case / camelCase boundary", () => {
 // ─── Edge cases ──────────────────────────────────────────────────────────
 
 describe("edge cases", () => {
-  it("handles empty items array in expandIteration", (t) => {
+  it("handles empty items array in expandIteration", () => {
     const graph = makeGraph([
       makeStep({ id: "iter" }),
     ]);
@@ -570,7 +576,7 @@ describe("edge cases", () => {
     assert.equal(expanded.steps[0].status, "expanded");
   });
 
-  it("handles graph with single step", (t) => {
+  it("handles graph with single step", () => {
     const graph = makeGraph([makeStep({ id: "only" })]);
     const next = getNextPendingStep(graph);
     assert.equal(next?.id, "only");
@@ -579,7 +585,7 @@ describe("edge cases", () => {
     assert.equal(getNextPendingStep(completed), null);
   });
 
-  it("initializeGraph handles steps with empty requires", (t) => {
+  it("initializeGraph handles steps with empty requires", () => {
     const def: WorkflowDefinition = {
       version: 1,
       name: "empty-requires",