gsd-pi 2.44.0-dev.62b5d6c → 2.44.0-dev.73f2fd5

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

@@ -39,61 +39,55 @@ function activeData(overrides: Partial<HealthWidgetData> = {}): HealthWidgetData
   };
 }
 
-test("detectHealthWidgetProjectState: no .gsd returns none", () => {
+test("detectHealthWidgetProjectState: no .gsd returns none", (t) => {
   const dir = makeTempDir("none");
-  try {
-    assert.equal(detectHealthWidgetProjectState(dir), "none");
-  } finally {
-    cleanup(dir);
-  }
+  t.after(() => { cleanup(dir); });
+
+  assert.equal(detectHealthWidgetProjectState(dir), "none");
 });
 
-test("detectHealthWidgetProjectState: bootstrapped .gsd without milestones returns initialized", () => {
+test("detectHealthWidgetProjectState: bootstrapped .gsd without milestones returns initialized", (t) => {
   const dir = makeTempDir("initialized");
-  try {
-    mkdirSync(join(dir, ".gsd"), { recursive: true });
-    assert.equal(detectHealthWidgetProjectState(dir), "initialized");
-  } finally {
-    cleanup(dir);
-  }
+  t.after(() => { cleanup(dir); });
+
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  assert.equal(detectHealthWidgetProjectState(dir), "initialized");
 });
 
-test("detectHealthWidgetProjectState: milestone without metrics returns active", () => {
+test("detectHealthWidgetProjectState: milestone without metrics returns active", (t) => {
   const dir = makeTempDir("active");
-  try {
-    mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
-    assert.equal(detectHealthWidgetProjectState(dir), "active");
-  } finally {
-    cleanup(dir);
-  }
+  t.after(() => { cleanup(dir); });
+
+  mkdirSync(join(dir, ".gsd", "milestones", "M001"), { recursive: true });
+  assert.equal(detectHealthWidgetProjectState(dir), "active");
 });
 
-test("buildHealthLines: none state shows onboarding copy", () => {
+test("buildHealthLines: none state shows onboarding copy", (t) => {
   assert.deepEqual(buildHealthLines(activeData({ projectState: "none" })), [
     "  GSD  No project loaded — run /gsd to start",
   ]);
 });
 
-test("buildHealthLines: initialized state shows continue setup copy", () => {
+test("buildHealthLines: initialized state shows continue setup copy", (t) => {
   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", () => {
+test("buildHealthLines: active state with ledger-driven spend shows spent summary", (t) => {
   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", () => {
+test("buildHealthLines: active state with budget ceiling shows percent summary", (t) => {
   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", () => {
+test("buildHealthLines: active state with issues reports issue summary", (t) => {
   const lines = buildHealthLines(activeData({
     providerIssue: "✗ OpenAI key missing",
     environmentErrorCount: 1,
@@ -104,17 +98,15 @@ test("buildHealthLines: active state with issues reports issue summary", () => {
   assert.match(lines[0]!, /Env: 1 error/);
 });
 
-test("detectHealthWidgetProjectState: metrics file alone does not imply project", () => {
+test("detectHealthWidgetProjectState: metrics file alone does not imply project", (t) => {
   const dir = makeTempDir("metrics-only");
-  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);
-  }
+  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");
 });

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

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

package/src/resources/extensions/gsd/tests/infra-error.test.ts

@@ -7,10 +7,13 @@ import { isInfrastructureError, INFRA_ERROR_CODES } from "../auto/infra-errors.j
 // ── INFRA_ERROR_CODES constant ───────────────────────────────────────────────
 
 test("INFRA_ERROR_CODES contains the expected codes", () => {
-  for (const code of ["ENOSPC", "ENOMEM", "EROFS", "EDQUOT", "EMFILE", "ENFILE"]) {
+  for (const code of [
+    "ENOSPC", "ENOMEM", "EROFS", "EDQUOT", "EMFILE", "ENFILE",
+    "ECONNREFUSED", "ENOTFOUND", "ENETUNREACH",
+  ]) {
     assert.ok(INFRA_ERROR_CODES.has(code), `missing ${code}`);
   }
-  assert.equal(INFRA_ERROR_CODES.size, 6, "unexpected extra codes");
+  assert.equal(INFRA_ERROR_CODES.size, 9, "unexpected extra codes");
 });
 
 // ── isInfrastructureError: code property detection ───────────────────────────
@@ -45,6 +48,21 @@ test("detects ENFILE via code property", () => {
   assert.equal(isInfrastructureError(err), "ENFILE");
 });
 
+test("detects ECONNREFUSED via code property", () => {
+  const err = Object.assign(new Error("connect ECONNREFUSED 127.0.0.1:3000"), { code: "ECONNREFUSED" });
+  assert.equal(isInfrastructureError(err), "ECONNREFUSED");
+});
+
+test("detects ENOTFOUND via code property", () => {
+  const err = Object.assign(new Error("getaddrinfo ENOTFOUND api.example.com"), { code: "ENOTFOUND" });
+  assert.equal(isInfrastructureError(err), "ENOTFOUND");
+});
+
+test("detects ENETUNREACH via code property", () => {
+  const err = Object.assign(new Error("connect ENETUNREACH 2607:f8b0:4004::"), { code: "ENETUNREACH" });
+  assert.equal(isInfrastructureError(err), "ENETUNREACH");
+});
+
 // ── isInfrastructureError: message fallback ──────────────────────────────────
 
 test("falls back to message scanning when no code property", () => {

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

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