gsd-pi 2.44.0 → 2.45.0

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/inherited-repo-home-dir.test.ts

@@ -0,0 +1,121 @@
+/**
+ * inherited-repo-home-dir.test.ts — Regression test for #2393.
+ *
+ * When the user's home directory IS a git repo (common with dotfile
+ * managers like yadm), isInheritedRepo() must not treat ~/.gsd (the
+ * global GSD state directory) as a project .gsd belonging to the home
+ * repo. Without the fix, isInheritedRepo() returns false for project
+ * subdirectories because it sees ~/.gsd and concludes the parent repo
+ * has already been initialised with GSD — causing the wrong project
+ * state to be loaded.
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import {
+  mkdtempSync,
+  mkdirSync,
+  rmSync,
+  writeFileSync,
+  realpathSync,
+  symlinkSync,
+} from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { isInheritedRepo } from "../repo-identity.ts";
+
+function run(cmd: string, args: string[], cwd: string): string {
+  return execFileSync(cmd, args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+  }).trim();
+}
+
+describe("isInheritedRepo when git root is HOME (#2393)", () => {
+  let fakeHome: string;
+  let stateDir: string;
+  let origGsdHome: string | undefined;
+  let origGsdStateDir: string | undefined;
+
+  beforeEach(() => {
+    // Create a fake HOME that is itself a git repo (dotfile manager scenario).
+    fakeHome = realpathSync(mkdtempSync(join(tmpdir(), "gsd-home-repo-")));
+    run("git", ["init", "-b", "main"], fakeHome);
+    run("git", ["config", "user.name", "Test"], fakeHome);
+    run("git", ["config", "user.email", "test@example.com"], fakeHome);
+    writeFileSync(join(fakeHome, ".bashrc"), "# dotfiles\n", "utf-8");
+    run("git", ["add", ".bashrc"], fakeHome);
+    run("git", ["commit", "-m", "init dotfiles"], fakeHome);
+
+    // Create a plain ~/.gsd directory at fakeHome — this simulates the
+    // global GSD home directory, NOT a project .gsd.
+    mkdirSync(join(fakeHome, ".gsd", "projects"), { recursive: true });
+
+    // Save and override env. Point GSD_HOME at fakeHome/.gsd so the
+    // function recognizes it as the global state directory.
+    origGsdHome = process.env.GSD_HOME;
+    origGsdStateDir = process.env.GSD_STATE_DIR;
+    process.env.GSD_HOME = join(fakeHome, ".gsd");
+    stateDir = mkdtempSync(join(tmpdir(), "gsd-state-"));
+    process.env.GSD_STATE_DIR = stateDir;
+  });
+
+  afterEach(() => {
+    if (origGsdHome !== undefined) process.env.GSD_HOME = origGsdHome;
+    else delete process.env.GSD_HOME;
+    if (origGsdStateDir !== undefined) process.env.GSD_STATE_DIR = origGsdStateDir;
+    else delete process.env.GSD_STATE_DIR;
+
+    rmSync(fakeHome, { recursive: true, force: true });
+    rmSync(stateDir, { recursive: true, force: true });
+  });
+
+  test("subdirectory of home-as-git-root is detected as inherited even when ~/.gsd exists", () => {
+    // Create a project directory inside fake HOME
+    const projectDir = join(fakeHome, "projects", "my-app");
+    mkdirSync(projectDir, { recursive: true });
+
+    // The bug: isInheritedRepo sees ~/.gsd and returns false, thinking
+    // the home repo is a legitimate GSD project. It should return true
+    // because ~/.gsd is the global state dir, not a project .gsd.
+    assert.strictEqual(
+      isInheritedRepo(projectDir),
+      true,
+      "project inside home-as-git-root must be detected as inherited repo, " +
+      "even when ~/.gsd (global state dir) exists",
+    );
+  });
+
+  test("subdirectory with a real project .gsd symlink at git root is NOT inherited", () => {
+    // Simulate a legitimately initialised GSD project at the home repo root:
+    // .gsd is a symlink to an external state directory.
+    const externalState = join(stateDir, "projects", "home-project");
+    mkdirSync(externalState, { recursive: true });
+    const gsdDir = join(fakeHome, ".gsd");
+
+    // Remove the plain directory and replace with a symlink (real project .gsd)
+    rmSync(gsdDir, { recursive: true, force: true });
+    symlinkSync(externalState, gsdDir);
+
+    const projectDir = join(fakeHome, "projects", "my-app");
+    mkdirSync(projectDir, { recursive: true });
+
+    // When .gsd at root IS a project symlink, subdirectories are legitimate children
+    assert.strictEqual(
+      isInheritedRepo(projectDir),
+      false,
+      "subdirectory of a legitimately-initialised GSD project should NOT be inherited",
+    );
+  });
+
+  test("home-as-git-root itself is never inherited", () => {
+    assert.strictEqual(
+      isInheritedRepo(fakeHome),
+      false,
+      "the git root itself is never inherited",
+    );
+  });
+});