gsd-pi 2.44.0-dev.848dd4c → 2.44.0

package/src/resources/extensions/gsd/tests/health-widget.test.ts

@@ -39,55 +39,61 @@ function activeData(overrides: Partial<HealthWidgetData> = {}): HealthWidgetData
   };
 }
 
-test("detectHealthWidgetProjectState: no .gsd returns none", (t) => {
+test("detectHealthWidgetProjectState: no .gsd returns none", () => {
   const dir = makeTempDir("none");
-  t.after(() => { cleanup(dir); });
-
-  assert.equal(detectHealthWidgetProjectState(dir), "none");
+  try {
+    assert.equal(detectHealthWidgetProjectState(dir), "none");
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectHealthWidgetProjectState: bootstrapped .gsd without milestones returns initialized", (t) => {
+test("detectHealthWidgetProjectState: bootstrapped .gsd without milestones returns initialized", () => {
   const dir = makeTempDir("initialized");
-  t.after(() => { cleanup(dir); });
-
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-  assert.equal(detectHealthWidgetProjectState(dir), "initialized");
+  try {
+    mkdirSync(join(dir, ".gsd"), { recursive: true });
+    assert.equal(detectHealthWidgetProjectState(dir), "initialized");
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("detectHealthWidgetProjectState: milestone without metrics returns active", (t) => {
+test("detectHealthWidgetProjectState: milestone without metrics returns active", () => {
   const dir = makeTempDir("active");
-  t.after(() => { cleanup(dir); });
-
-  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
-  assert.equal(detectHealthWidgetProjectState(dir), "active");
+  try {
+    mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+    assert.equal(detectHealthWidgetProjectState(dir), "active");
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("buildHealthLines: none state shows onboarding copy", (t) => {
+test("buildHealthLines: none state shows onboarding copy", () => {
   assert.deepEqual(buildHealthLines(activeData({ projectState: "none" })), [
     "  GSD  No project loaded — run /gsd to start",
   ]);
 });
 
-test("buildHealthLines: initialized state shows continue setup copy", (t) => {
+test("buildHealthLines: initialized state shows continue setup copy", () => {
   assert.deepEqual(buildHealthLines(activeData({ projectState: "initialized" })), [
     "  GSD  Project initialized — run /gsd to continue setup",
   ]);
 });
 
-test("buildHealthLines: active state with ledger-driven spend shows spent summary", (t) => {
+test("buildHealthLines: active state with ledger-driven spend shows spent summary", () => {
   const lines = buildHealthLines(activeData({ budgetSpent: 0.42 }));
   assert.equal(lines.length, 1);
   assert.match(lines[0]!, /● System OK/);
   assert.match(lines[0]!, /Spent: 42\.0¢/);
 });
 
-test("buildHealthLines: active state with budget ceiling shows percent summary", (t) => {
+test("buildHealthLines: active state with budget ceiling shows percent summary", () => {
   const lines = buildHealthLines(activeData({ budgetSpent: 2.5, budgetCeiling: 10 }));
   assert.equal(lines.length, 1);
   assert.match(lines[0]!, /Budget: \$2\.50\/\$10\.00 \(25%\)/);
 });
 
-test("buildHealthLines: active state with issues reports issue summary", (t) => {
+test("buildHealthLines: active state with issues reports issue summary", () => {
   const lines = buildHealthLines(activeData({
     providerIssue: "✗ OpenAI key missing",
     environmentErrorCount: 1,
@@ -98,15 +104,17 @@ test("buildHealthLines: active state with issues reports issue summary", (t) =>
   assert.match(lines[0]!, /Env: 1 error/);
 });
 
-test("detectHealthWidgetProjectState: metrics file alone does not imply project", (t) => {
+test("detectHealthWidgetProjectState: metrics file alone does not imply project", () => {
   const dir = makeTempDir("metrics-only");
-  t.after(() => { cleanup(dir); });
-
-  mkdirSync(join(dir, ".gsd"), { recursive: true });
-  writeFileSync(
-    join(dir, ".gsd", "metrics.json"),
-    JSON.stringify({ version: 1, projectStartedAt: Date.now(), units: [] }),
-    "utf-8",
-  );
-  assert.equal(detectHealthWidgetProjectState(dir), "initialized");
+  try {
+    mkdirSync(join(dir, ".gsd"), { recursive: true });
+    writeFileSync(
+      join(dir, ".gsd", "metrics.json"),
+      JSON.stringify({ version: 1, projectStartedAt: Date.now(), units: [] }),
+      "utf-8",
+    );
+    assert.equal(detectHealthWidgetProjectState(dir), "initialized");
+  } finally {
+    cleanup(dir);
+  }
 });

package/src/resources/extensions/gsd/tests/idle-recovery.test.ts

@@ -8,9 +8,9 @@ import {
   verifyExpectedArtifact,
   buildLoopRemediationSteps,
 } from "../auto.ts";
-import { describe, test, beforeEach, afterEach } from 'node:test';
-import assert from 'node:assert/strict';
+import { createTestContext } from './test-helpers.ts';
 
+const { assertEq, assertTrue, report } = createTestContext();
 function createFixtureBase(): string {
   const base = mkdtempSync(join(tmpdir(), "gsd-idle-recovery-test-"));
   mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01", "tasks"), { recursive: true });
@@ -23,91 +23,99 @@ function cleanup(base: string): void {
 
 // ═══ resolveExpectedArtifactPath ═════════════════════════════════════════════
 
-test('resolveExpectedArtifactPath: research-milestone', () => {
+{
+  console.log("\n=== resolveExpectedArtifactPath: research-milestone ===");
   const base = createFixtureBase();
   try {
     const result = resolveExpectedArtifactPath("research-milestone", "M001", base);
-    assert.ok(result !== null, "should resolve a path");
-    assert.ok(result!.endsWith("M001-RESEARCH.md"), `path should end with M001-RESEARCH.md, got ${result}`);
+    assertTrue(result !== null, "should resolve a path");
+    assertTrue(result!.endsWith("M001-RESEARCH.md"), `path should end with M001-RESEARCH.md, got ${result}`);
   } finally {
     cleanup(base);
   }
-});
+}
 
-test('resolveExpectedArtifactPath: plan-milestone', () => {
+{
+  console.log("\n=== resolveExpectedArtifactPath: plan-milestone ===");
   const base = createFixtureBase();
   try {
     const result = resolveExpectedArtifactPath("plan-milestone", "M001", base);
-    assert.ok(result !== null, "should resolve a path");
-    assert.ok(result!.endsWith("M001-ROADMAP.md"), `path should end with M001-ROADMAP.md, got ${result}`);
+    assertTrue(result !== null, "should resolve a path");
+    assertTrue(result!.endsWith("M001-ROADMAP.md"), `path should end with M001-ROADMAP.md, got ${result}`);
   } finally {
     cleanup(base);
   }
-});
+}
 
-test('resolveExpectedArtifactPath: research-slice', () => {
+{
+  console.log("\n=== resolveExpectedArtifactPath: research-slice ===");
   const base = createFixtureBase();
   try {
     const result = resolveExpectedArtifactPath("research-slice", "M001/S01", base);
-    assert.ok(result !== null, "should resolve a path");
-    assert.ok(result!.endsWith("S01-RESEARCH.md"), `path should end with S01-RESEARCH.md, got ${result}`);
+    assertTrue(result !== null, "should resolve a path");
+    assertTrue(result!.endsWith("S01-RESEARCH.md"), `path should end with S01-RESEARCH.md, got ${result}`);
   } finally {
     cleanup(base);
   }
-});
+}
 
-test('resolveExpectedArtifactPath: plan-slice', () => {
+{
+  console.log("\n=== resolveExpectedArtifactPath: plan-slice ===");
   const base = createFixtureBase();
   try {
     const result = resolveExpectedArtifactPath("plan-slice", "M001/S01", base);
-    assert.ok(result !== null, "should resolve a path");
-    assert.ok(result!.endsWith("S01-PLAN.md"), `path should end with S01-PLAN.md, got ${result}`);
+    assertTrue(result !== null, "should resolve a path");
+    assertTrue(result!.endsWith("S01-PLAN.md"), `path should end with S01-PLAN.md, got ${result}`);
   } finally {
     cleanup(base);
   }
-});
+}
 
-test('resolveExpectedArtifactPath: complete-milestone', () => {
+{
+  console.log("\n=== resolveExpectedArtifactPath: complete-milestone ===");
   const base = createFixtureBase();
   try {
     const result = resolveExpectedArtifactPath("complete-milestone", "M001", base);
-    assert.ok(result !== null, "should resolve a path");
-    assert.ok(result!.endsWith("M001-SUMMARY.md"), `path should end with M001-SUMMARY.md, got ${result}`);
+    assertTrue(result !== null, "should resolve a path");
+    assertTrue(result!.endsWith("M001-SUMMARY.md"), `path should end with M001-SUMMARY.md, got ${result}`);
   } finally {
     cleanup(base);
   }
-});
+}
 
-test('resolveExpectedArtifactPath: unknown unit type → null', () => {
+{
+  console.log("\n=== resolveExpectedArtifactPath: unknown unit type → null ===");
   const base = createFixtureBase();
   try {
     const result = resolveExpectedArtifactPath("unknown-type", "M001/S01", base);
-    assert.deepStrictEqual(result, null, "unknown type returns null");
+    assertEq(result, null, "unknown type returns null");
   } finally {
     cleanup(base);
   }
-});
+}
 
 // ═══ writeBlockerPlaceholder ═════════════════════════════════════════════════
 
-test('writeBlockerPlaceholder: writes file for research-slice', () => {
+{
+  console.log("\n=== writeBlockerPlaceholder: writes file for research-slice ===");
   const base = createFixtureBase();
   try {
     const result = writeBlockerPlaceholder("research-slice", "M001/S01", base, "idle recovery exhausted 2 attempts");
-    assert.ok(result !== null, "should return relative path");
+    assertTrue(result !== null, "should return relative path");
     const absPath = resolveExpectedArtifactPath("research-slice", "M001/S01", base)!;
-    assert.ok(existsSync(absPath), "file should exist on disk");
+    assertTrue(existsSync(absPath), "file should exist on disk");
     const content = readFileSync(absPath, "utf-8");
-    assert.ok(content.includes("BLOCKER"), "should contain BLOCKER heading");
-    assert.ok(content.includes("idle recovery exhausted 2 attempts"), "should contain the reason");
-    assert.ok(content.includes("research-slice"), "should mention the unit type");
-    assert.ok(content.includes("M001/S01"), "should mention the unit ID");
+    assertTrue(content.includes("BLOCKER"), "should contain BLOCKER heading");
+    assertTrue(content.includes("idle recovery exhausted 2 attempts"), "should contain the reason");
+    assertTrue(content.includes("research-slice"), "should mention the unit type");
+    assertTrue(content.includes("M001/S01"), "should mention the unit ID");
   } finally {
     cleanup(base);
   }
-});
+}
 
-test('writeBlockerPlaceholder: creates directory if missing', () => {
+{
+  console.log("\n=== writeBlockerPlaceholder: creates directory if missing ===");
   const base = mkdtempSync(join(tmpdir(), "gsd-idle-recovery-test-"));
   try {
     // Only create milestone dir, not slice dir
@@ -115,36 +123,38 @@ test('writeBlockerPlaceholder: creates directory if missing', () => {
     // resolveSlicePath needs the slice dir to exist to resolve, so this should return null
     const result = writeBlockerPlaceholder("research-slice", "M001/S01", base, "test reason");
     // Since the slice dir doesn't exist, resolveExpectedArtifactPath returns null
-    assert.deepStrictEqual(result, null, "returns null when directory structure doesn't exist");
+    assertEq(result, null, "returns null when directory structure doesn't exist");
   } finally {
     cleanup(base);
   }
-});
+}
 
-test('writeBlockerPlaceholder: writes file for research-milestone', () => {
+{
+  console.log("\n=== writeBlockerPlaceholder: writes file for research-milestone ===");
   const base = createFixtureBase();
   try {
     const result = writeBlockerPlaceholder("research-milestone", "M001", base, "hard timeout");
-    assert.ok(result !== null, "should return relative path");
+    assertTrue(result !== null, "should return relative path");
     const absPath = resolveExpectedArtifactPath("research-milestone", "M001", base)!;
-    assert.ok(existsSync(absPath), "file should exist on disk");
+    assertTrue(existsSync(absPath), "file should exist on disk");
     const content = readFileSync(absPath, "utf-8");
-    assert.ok(content.includes("BLOCKER"), "should contain BLOCKER heading");
-    assert.ok(content.includes("hard timeout"), "should contain the reason");
+    assertTrue(content.includes("BLOCKER"), "should contain BLOCKER heading");
+    assertTrue(content.includes("hard timeout"), "should contain the reason");
   } finally {
     cleanup(base);
   }
-});
+}
 
-test('writeBlockerPlaceholder: unknown type → null', () => {
+{
+  console.log("\n=== writeBlockerPlaceholder: unknown type → null ===");
   const base = createFixtureBase();
   try {
     const result = writeBlockerPlaceholder("unknown-type", "M001/S01", base, "test");
-    assert.deepStrictEqual(result, null, "unknown type returns null");
+    assertEq(result, null, "unknown type returns null");
   } finally {
     cleanup(base);
   }
-});
+}
 
 // ═══ verifyExpectedArtifact: complete-slice roadmap check ════════════════════
 // Regression for #indefinite-hang: complete-slice must verify roadmap [x] or
@@ -167,7 +177,8 @@ const ROADMAP_COMPLETE = `# M001: Test Milestone
 > After this: something works
 `;
 
-test('verifyExpectedArtifact: complete-slice — all artifacts present + roadmap marked [x] returns true', () => {
+{
+  console.log("\n=== verifyExpectedArtifact: complete-slice — all artifacts present + roadmap marked [x] returns true ===");
   const base = createFixtureBase();
   try {
     const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
@@ -175,13 +186,14 @@ test('verifyExpectedArtifact: complete-slice — all artifacts present + roadmap
     writeFileSync(join(sliceDir, "S01-UAT.md"), "# UAT\n", "utf-8");
     writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), ROADMAP_COMPLETE, "utf-8");
     const result = verifyExpectedArtifact("complete-slice", "M001/S01", base);
-    assert.ok(result === true, "SUMMARY + UAT + roadmap [x] should verify as true");
+    assertTrue(result === true, "SUMMARY + UAT + roadmap [x] should verify as true");
   } finally {
     cleanup(base);
   }
-});
+}
 
-test('verifyExpectedArtifact: complete-slice — SUMMARY + UAT present but roadmap NOT marked [x] returns false', () => {
+{
+  console.log("\n=== verifyExpectedArtifact: complete-slice — SUMMARY + UAT present but roadmap NOT marked [x] returns false ===");
   const base = createFixtureBase();
   try {
     const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
@@ -189,13 +201,14 @@ test('verifyExpectedArtifact: complete-slice — SUMMARY + UAT present but roadm
     writeFileSync(join(sliceDir, "S01-UAT.md"), "# UAT\n", "utf-8");
     writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), ROADMAP_INCOMPLETE, "utf-8");
     const result = verifyExpectedArtifact("complete-slice", "M001/S01", base);
-    assert.ok(result === false, "roadmap not marked [x] should return false (crash recovery scenario)");
+    assertTrue(result === false, "roadmap not marked [x] should return false (crash recovery scenario)");
   } finally {
     cleanup(base);
   }
-});
+}
 
-test('verifyExpectedArtifact: complete-slice — SUMMARY present but UAT missing returns false', () => {
+{
+  console.log("\n=== verifyExpectedArtifact: complete-slice — SUMMARY present but UAT missing returns false ===");
   const base = createFixtureBase();
   try {
     const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
@@ -203,13 +216,14 @@ test('verifyExpectedArtifact: complete-slice — SUMMARY present but UAT missing
     // no UAT file
     writeFileSync(join(base, ".gsd", "milestones", "M001", "M001-ROADMAP.md"), ROADMAP_COMPLETE, "utf-8");
     const result = verifyExpectedArtifact("complete-slice", "M001/S01", base);
-    assert.ok(result === false, "missing UAT should return false");
+    assertTrue(result === false, "missing UAT should return false");
   } finally {
     cleanup(base);
   }
-});
+}
 
-test('verifyExpectedArtifact: complete-slice — no roadmap file present is lenient (returns true)', () => {
+{
+  console.log("\n=== verifyExpectedArtifact: complete-slice — no roadmap file present is lenient (returns true) ===");
   const base = createFixtureBase();
   try {
     const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
@@ -217,80 +231,87 @@ test('verifyExpectedArtifact: complete-slice — no roadmap file present is leni
     writeFileSync(join(sliceDir, "S01-UAT.md"), "# UAT\n", "utf-8");
     // no roadmap file
     const result = verifyExpectedArtifact("complete-slice", "M001/S01", base);
-    assert.ok(result === true, "missing roadmap file should be lenient and return true");
+    assertTrue(result === true, "missing roadmap file should be lenient and return true");
   } finally {
     cleanup(base);
   }
-});
+}
 
 // ═══ buildLoopRemediationSteps ═══════════════════════════════════════════════
 
-test('buildLoopRemediationSteps: execute-task returns concrete steps', () => {
+{
+  console.log("\n=== buildLoopRemediationSteps: execute-task returns concrete steps ===");
   const base = mkdtempSync(join(tmpdir(), "gsd-loop-remediation-test-"));
   try {
     mkdirSync(join(base, ".gsd", "milestones", "M002", "slices", "S03", "tasks"), { recursive: true });
     const result = buildLoopRemediationSteps("execute-task", "M002/S03/T01", base);
-    assert.ok(result !== null, "should return remediation steps");
-    assert.ok(result!.includes("gsd undo-task"), "steps include undo-task command");
-    assert.ok(result!.includes("T01"), "steps mention the task ID");
-    assert.ok(result!.includes("gsd undo-task"), "steps include gsd undo-task command");
+    assertTrue(result !== null, "should return remediation steps");
+    assertTrue(result!.includes("gsd undo-task"), "steps include undo-task command");
+    assertTrue(result!.includes("T01"), "steps mention the task ID");
+    assertTrue(result!.includes("gsd undo-task"), "steps include gsd undo-task command");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
-test('buildLoopRemediationSteps: plan-slice returns concrete steps', () => {
+{
+  console.log("\n=== buildLoopRemediationSteps: plan-slice returns concrete steps ===");
   const base = mkdtempSync(join(tmpdir(), "gsd-loop-remediation-test-"));
   try {
     mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
     const result = buildLoopRemediationSteps("plan-slice", "M001/S01", base);
-    assert.ok(result !== null, "should return remediation steps for plan-slice");
-    assert.ok(result!.includes("S01-PLAN.md"), "steps mention the slice plan file");
-    assert.ok(result!.includes("gsd recover"), "steps include gsd recover command");
+    assertTrue(result !== null, "should return remediation steps for plan-slice");
+    assertTrue(result!.includes("S01-PLAN.md"), "steps mention the slice plan file");
+    assertTrue(result!.includes("gsd recover"), "steps include gsd recover command");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
-test('buildLoopRemediationSteps: research-slice returns concrete steps', () => {
+{
+  console.log("\n=== buildLoopRemediationSteps: research-slice returns concrete steps ===");
   const base = mkdtempSync(join(tmpdir(), "gsd-loop-remediation-test-"));
   try {
     mkdirSync(join(base, ".gsd", "milestones", "M001", "slices", "S01"), { recursive: true });
     const result = buildLoopRemediationSteps("research-slice", "M001/S01", base);
-    assert.ok(result !== null, "should return remediation steps for research-slice");
-    assert.ok(result!.includes("S01-RESEARCH.md"), "steps mention the slice research file");
-    assert.ok(result!.includes("gsd recover"), "steps include gsd recover command");
+    assertTrue(result !== null, "should return remediation steps for research-slice");
+    assertTrue(result!.includes("S01-RESEARCH.md"), "steps mention the slice research file");
+    assertTrue(result!.includes("gsd recover"), "steps include gsd recover command");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
-test('buildLoopRemediationSteps: unknown type returns null', () => {
+{
+  console.log("\n=== buildLoopRemediationSteps: unknown type returns null ===");
   const base = mkdtempSync(join(tmpdir(), "gsd-loop-remediation-test-"));
   try {
     const result = buildLoopRemediationSteps("unknown-type", "M001/S01", base);
-    assert.deepStrictEqual(result, null, "unknown type returns null");
+    assertEq(result, null, "unknown type returns null");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
 // ═══ verifyExpectedArtifact: hook unit types ═════════════════════════════════
 
-test('verifyExpectedArtifact: hook types always return true', () => {
+console.log("\n=== verifyExpectedArtifact: hook types always return true ===");
+
+{
   const base = createFixtureBase();
   try {
     // Hook units don't have standard artifacts — they should always pass
     const result1 = verifyExpectedArtifact("hook/code-review", "M001/S01/T01", base);
-    assert.ok(result1, "hook/code-review should always return true");
+    assertTrue(result1, "hook/code-review should always return true");
 
     const result2 = verifyExpectedArtifact("hook/simplify", "M001/S01/T02", base);
-    assert.ok(result2, "hook/simplify should always return true");
+    assertTrue(result2, "hook/simplify should always return true");
 
     const result3 = verifyExpectedArtifact("hook/custom-hook", "M001/S01", base);
-    assert.ok(result3, "hook/custom-hook at slice level should return true");
+    assertTrue(result3, "hook/custom-hook at slice level should return true");
   } finally {
     rmSync(base, { recursive: true, force: true });
   }
-});
+}
 
+report();

package/src/resources/extensions/gsd/tests/init-wizard.test.ts

@@ -36,17 +36,19 @@ function cleanup(dir: string): void {
 
 // ─── Detection Integration Tests ────────────────────────────────────────────────
 
-test("init-wizard: clean folder detected as state=none", (t) => {
+test("init-wizard: clean folder detected as state=none", () => {
   const dir = makeTempDir("clean");
-  t.after(() => { cleanup(dir); });
-
-  const detection = detectProjectState(dir);
-  assert.equal(detection.state, "none");
-  assert.equal(detection.v1, undefined);
-  assert.equal(detection.v2, undefined);
+  try {
+    const detection = detectProjectState(dir);
+    assert.equal(detection.state, "none");
+    assert.equal(detection.v1, undefined);
+    assert.equal(detection.v2, undefined);
+  } finally {
+    cleanup(dir);
+  }
 });
 
-test("init-wizard: v1 .planning/ triggers v1-planning state", (t) => {
+test("init-wizard: v1 .planning/ triggers v1-planning state", () => {
   const dir = makeTempDir("v1");
   try {
     mkdirSync(join(dir, ".planning", "phases", "01"), { recursive: true });
@@ -63,7 +65,7 @@ test("init-wizard: v1 .planning/ triggers v1-planning state", (t) => {
   }
 });
 
-test("init-wizard: existing .gsd/ with milestones skips init", (t) => {
+test("init-wizard: existing .gsd/ with milestones skips init", () => {
   const dir = makeTempDir("existing");
   try {
     mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
@@ -78,7 +80,7 @@ test("init-wizard: existing .gsd/ with milestones skips init", (t) => {
   }
 });
 
-test("init-wizard: empty .gsd/ (no milestones) returns v2-gsd-empty", (t) => {
+test("init-wizard: empty .gsd/ (no milestones) returns v2-gsd-empty", () => {
   const dir = makeTempDir("empty-gsd");
   try {
     mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
@@ -92,7 +94,7 @@ test("init-wizard: empty .gsd/ (no milestones) returns v2-gsd-empty", (t) => {
   }
 });
 
-test("init-wizard: project signals populate from Node.js project", (t) => {
+test("init-wizard: project signals populate from Node.js project", () => {
   const dir = makeTempDir("node-project");
   try {
     writeFileSync(
@@ -119,7 +121,7 @@ test("init-wizard: project signals populate from Node.js project", (t) => {
   }
 });
 
-test("init-wizard: v2 .gsd/ preferences detected", (t) => {
+test("init-wizard: v2 .gsd/ preferences detected", () => {
   const dir = makeTempDir("prefs-detect");
   try {
     mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
@@ -133,7 +135,7 @@ test("init-wizard: v2 .gsd/ preferences detected", (t) => {
   }
 });
 
-test("init-wizard: v2 uppercase PREFERENCES.md also detected", (t) => {
+test("init-wizard: v2 uppercase PREFERENCES.md also detected", () => {
   const dir = makeTempDir("prefs-upper");
   try {
     mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
@@ -147,7 +149,7 @@ test("init-wizard: v2 uppercase PREFERENCES.md also detected", (t) => {
   }
 });
 
-test("init-wizard: CONTEXT.md detected in v2", (t) => {
+test("init-wizard: CONTEXT.md detected in v2", () => {
   const dir = makeTempDir("context");
   try {
     mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
@@ -161,7 +163,7 @@ test("init-wizard: CONTEXT.md detected in v2", (t) => {
   }
 });
 
-test("init-wizard: multiple project files detected together", (t) => {
+test("init-wizard: multiple project files detected together", () => {
   const dir = makeTempDir("multi-files");
   try {
     writeFileSync(join(dir, "package.json"), JSON.stringify({ name: "test" }), "utf-8");
@@ -178,7 +180,7 @@ test("init-wizard: multiple project files detected together", (t) => {
   }
 });
 
-test("init-wizard: v1 with both .planning/ and .gsd/ prioritizes v2", (t) => {
+test("init-wizard: v1 with both .planning/ and .gsd/ prioritizes v2", () => {
   const dir = makeTempDir("both-v1-v2");
   try {
     mkdirSync(join(dir, ".planning", "phases"), { recursive: true });