gsd-pi 2.49.0 → 2.50.0-dev.d210a87

package/src/resources/extensions/gsd/tests/quality-gates.test.ts

@@ -0,0 +1,347 @@
+import { readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { extractSection } from "../files.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const templatesDir = join(__dirname, "..", "templates");
+const promptsDir = join(__dirname, "..", "prompts");
+
+const { assertTrue, report } = createTestContext();
+
+function loadTemplate(name: string): string {
+  return readFileSync(join(templatesDir, `${name}.md`), "utf-8");
+}
+
+function loadPrompt(name: string): string {
+  return readFileSync(join(promptsDir, `${name}.md`), "utf-8");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Level 1: Templates contain quality gate headings
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Level 1: Templates contain quality gate headings ===");
+{
+  const plan = loadTemplate("plan");
+  assertTrue(plan.includes("## Threat Surface"), "plan.md contains ## Threat Surface");
+  assertTrue(plan.includes("## Requirement Impact"), "plan.md contains ## Requirement Impact");
+
+  const taskPlan = loadTemplate("task-plan");
+  assertTrue(taskPlan.includes("## Failure Modes"), "task-plan.md contains ## Failure Modes");
+  assertTrue(taskPlan.includes("## Load Profile"), "task-plan.md contains ## Load Profile");
+  assertTrue(taskPlan.includes("## Negative Tests"), "task-plan.md contains ## Negative Tests");
+
+  const sliceSummary = loadTemplate("slice-summary");
+  assertTrue(sliceSummary.includes("## Operational Readiness"), "slice-summary.md contains ## Operational Readiness");
+
+  const roadmap = loadTemplate("roadmap");
+  assertTrue(roadmap.includes("## Horizontal Checklist"), "roadmap.md contains ## Horizontal Checklist");
+
+  const milestoneSummary = loadTemplate("milestone-summary");
+  assertTrue(milestoneSummary.includes("## Decision Re-evaluation"), "milestone-summary.md contains ## Decision Re-evaluation");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Level 2: Prompts reference quality gates
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Level 2: Prompts reference quality gates ===");
+{
+  const planSlice = loadPrompt("plan-slice");
+  assertTrue(planSlice.includes("Threat Surface"), "plan-slice.md mentions Threat Surface");
+  assertTrue(planSlice.includes("Requirement Impact"), "plan-slice.md mentions Requirement Impact");
+  assertTrue(planSlice.toLowerCase().includes("quality gate"), "plan-slice.md mentions quality gate");
+
+  const guidedPlanSlice = loadPrompt("guided-plan-slice");
+  assertTrue(
+    guidedPlanSlice.includes("Threat Surface") || guidedPlanSlice.includes("Q3"),
+    "guided-plan-slice.md mentions Threat Surface or Q3"
+  );
+
+  const executeTask = loadPrompt("execute-task");
+  assertTrue(executeTask.includes("Failure Modes"), "execute-task.md mentions Failure Modes");
+  assertTrue(executeTask.includes("Load Profile"), "execute-task.md mentions Load Profile");
+  assertTrue(executeTask.includes("Negative Tests"), "execute-task.md mentions Negative Tests");
+
+  const guidedExecuteTask = loadPrompt("guided-execute-task");
+  assertTrue(
+    guidedExecuteTask.includes("Failure Modes") || guidedExecuteTask.includes("Q5"),
+    "guided-execute-task.md mentions Failure Modes or Q5"
+  );
+
+  const completeSlice = loadPrompt("complete-slice");
+  assertTrue(completeSlice.includes("Operational Readiness"), "complete-slice.md mentions Operational Readiness");
+
+  const guidedCompleteSlice = loadPrompt("guided-complete-slice");
+  assertTrue(
+    guidedCompleteSlice.includes("Operational Readiness") || guidedCompleteSlice.includes("Q8"),
+    "guided-complete-slice.md mentions Operational Readiness or Q8"
+  );
+
+  const completeMilestone = loadPrompt("complete-milestone");
+  assertTrue(completeMilestone.includes("Horizontal Checklist"), "complete-milestone.md mentions Horizontal Checklist");
+  assertTrue(completeMilestone.includes("Decision Re-evaluation"), "complete-milestone.md mentions Decision Re-evaluation");
+
+  const planMilestone = loadPrompt("plan-milestone");
+  assertTrue(planMilestone.toLowerCase().includes("horizontal checklist"), "plan-milestone.md mentions horizontal checklist");
+
+  const guidedPlanMilestone = loadPrompt("guided-plan-milestone");
+  assertTrue(guidedPlanMilestone.includes("Horizontal Checklist"), "guided-plan-milestone.md mentions Horizontal Checklist");
+
+  const reassess = loadPrompt("reassess-roadmap");
+  assertTrue(reassess.includes("Threat Surface"), "reassess-roadmap.md mentions Threat Surface");
+  assertTrue(reassess.includes("Operational Readiness"), "reassess-roadmap.md mentions Operational Readiness");
+  assertTrue(reassess.includes("Horizontal Checklist"), "reassess-roadmap.md mentions Horizontal Checklist");
+
+  const replan = loadPrompt("replan-slice");
+  assertTrue(replan.includes("Threat Surface"), "replan-slice.md mentions Threat Surface");
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Level 3: Parser backward compatibility — extractSection handles new headings
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Level 3: extractSection backward compatibility ===");
+{
+  // Old-style slice plan (no quality gate sections)
+  const oldPlan = `# S01: Auth Flow
+
+**Goal:** Build login
+**Demo:** User can log in
+
+## Must-Haves
+
+- Login form works
+- Session persists
+
+## Proof Level
+
+- This slice proves: integration
+
+## Tasks
+
+- [ ] **T01: Build login** \`est:1h\`
+`;
+
+  // New-style slice plan (with quality gate sections)
+  const newPlan = `# S01: Auth Flow
+
+**Goal:** Build login
+**Demo:** User can log in
+
+## Must-Haves
+
+- Login form works
+- Session persists
+
+## Threat Surface
+
+- **Abuse**: Credential stuffing, brute force login attempts
+- **Data exposure**: Session tokens in cookies, password in request body
+- **Input trust**: Username/password from form input reaching DB query
+
+## Requirement Impact
+
+- **Requirements touched**: R001, R003
+- **Re-verify**: Login flow, session management
+- **Decisions revisited**: D002
+
+## Proof Level
+
+- This slice proves: integration
+
+## Tasks
+
+- [ ] **T01: Build login** \`est:1h\`
+`;
+
+  // Old plan: quality gate sections return null (not found)
+  assertTrue(
+    extractSection(oldPlan, "Threat Surface") === null,
+    "extractSection returns null for Threat Surface on old plan"
+  );
+  assertTrue(
+    extractSection(oldPlan, "Requirement Impact") === null,
+    "extractSection returns null for Requirement Impact on old plan"
+  );
+
+  // Old plan: core sections still parse correctly
+  const oldMustHaves = extractSection(oldPlan, "Must-Haves");
+  assertTrue(
+    oldMustHaves !== null && oldMustHaves.includes("Login form works"),
+    "extractSection still parses Must-Haves on old plan"
+  );
+
+  // New plan: quality gate sections are extracted
+  const threatSurface = extractSection(newPlan, "Threat Surface");
+  assertTrue(
+    threatSurface !== null && threatSurface.includes("Credential stuffing"),
+    "extractSection extracts Threat Surface content from new plan"
+  );
+
+  const reqImpact = extractSection(newPlan, "Requirement Impact");
+  assertTrue(
+    reqImpact !== null && reqImpact.includes("R001"),
+    "extractSection extracts Requirement Impact content from new plan"
+  );
+
+  // New plan: core sections still parse correctly
+  const newMustHaves = extractSection(newPlan, "Must-Haves");
+  assertTrue(
+    newMustHaves !== null && newMustHaves.includes("Login form works"),
+    "extractSection still parses Must-Haves on new plan"
+  );
+
+  // Task plan: Failure Modes
+  const oldTaskPlan = `# T01: Build Login
+
+## Description
+
+Build the login endpoint.
+
+## Steps
+
+1. Create route
+`;
+
+  const newTaskPlan = `# T01: Build Login
+
+## Description
+
+Build the login endpoint.
+
+## Failure Modes
+
+| Dependency | On error | On timeout | On malformed response |
+|------------|----------|-----------|----------------------|
+| Auth DB | Return 500 | 3s timeout, retry once | Reject, log warning |
+
+## Steps
+
+1. Create route
+`;
+
+  assertTrue(
+    extractSection(oldTaskPlan, "Failure Modes") === null,
+    "extractSection returns null for Failure Modes on old task plan"
+  );
+
+  const failureModes = extractSection(newTaskPlan, "Failure Modes");
+  assertTrue(
+    failureModes !== null && failureModes.includes("Auth DB"),
+    "extractSection extracts Failure Modes content from new task plan"
+  );
+
+  // Slice summary: Operational Readiness
+  const oldSummary = `# S01: Auth Flow
+
+**Built login with session management**
+
+## Verification
+
+All tests pass.
+
+## Deviations
+
+None.
+`;
+
+  const newSummary = `# S01: Auth Flow
+
+**Built login with session management**
+
+## Verification
+
+All tests pass.
+
+## Operational Readiness
+
+- **Health signal**: /health endpoint returns 200 with session count
+- **Failure signal**: Auth error rate > 5% triggers alert
+- **Recovery**: Stateless — restart clears nothing
+- **Monitoring gaps**: None
+
+## Deviations
+
+None.
+`;
+
+  assertTrue(
+    extractSection(oldSummary, "Operational Readiness") === null,
+    "extractSection returns null for Operational Readiness on old summary"
+  );
+
+  const opReadiness = extractSection(newSummary, "Operational Readiness");
+  assertTrue(
+    opReadiness !== null && opReadiness.includes("/health endpoint"),
+    "extractSection extracts Operational Readiness content from new summary"
+  );
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Level 4: Template section ordering is correct
+// ═══════════════════════════════════════════════════════════════════════════
+
+console.log("\n=== Level 4: Template section ordering ===");
+{
+  const plan = loadTemplate("plan");
+  const mustHavesIdx = plan.indexOf("## Must-Haves");
+  const threatIdx = plan.indexOf("## Threat Surface");
+  const proofIdx = plan.indexOf("## Proof Level");
+  assertTrue(
+    mustHavesIdx < threatIdx && threatIdx < proofIdx,
+    "plan.md: Threat Surface is between Must-Haves and Proof Level"
+  );
+
+  const reqImpactIdx = plan.indexOf("## Requirement Impact");
+  assertTrue(
+    threatIdx < reqImpactIdx && reqImpactIdx < proofIdx,
+    "plan.md: Requirement Impact is between Threat Surface and Proof Level"
+  );
+
+  const taskPlan = loadTemplate("task-plan");
+  const descIdx = taskPlan.indexOf("## Description");
+  const failIdx = taskPlan.indexOf("## Failure Modes");
+  const stepsIdx = taskPlan.indexOf("## Steps");
+  assertTrue(
+    descIdx < failIdx && failIdx < stepsIdx,
+    "task-plan.md: Failure Modes is between Description and Steps"
+  );
+
+  const loadIdx = taskPlan.indexOf("## Load Profile");
+  const negIdx = taskPlan.indexOf("## Negative Tests");
+  assertTrue(
+    failIdx < loadIdx && loadIdx < negIdx && negIdx < stepsIdx,
+    "task-plan.md: Failure Modes < Load Profile < Negative Tests < Steps"
+  );
+
+  const sliceSummary = loadTemplate("slice-summary");
+  const reqInvalidIdx = sliceSummary.indexOf("## Requirements Invalidated");
+  const opIdx = sliceSummary.indexOf("## Operational Readiness");
+  const devIdx = sliceSummary.indexOf("## Deviations");
+  assertTrue(
+    reqInvalidIdx < opIdx && opIdx < devIdx,
+    "slice-summary.md: Operational Readiness is between Requirements Invalidated and Deviations"
+  );
+
+  const roadmap = loadTemplate("roadmap");
+  const horizIdx = roadmap.indexOf("## Horizontal Checklist");
+  const boundaryIdx = roadmap.indexOf("## Boundary Map");
+  assertTrue(
+    horizIdx > 0 && horizIdx < boundaryIdx,
+    "roadmap.md: Horizontal Checklist is before Boundary Map"
+  );
+
+  const milestoneSummary = loadTemplate("milestone-summary");
+  const reqChangesIdx = milestoneSummary.indexOf("## Requirement Changes");
+  const decRevalIdx = milestoneSummary.indexOf("## Decision Re-evaluation");
+  const fwdIntelIdx = milestoneSummary.indexOf("## Forward Intelligence");
+  assertTrue(
+    reqChangesIdx < decRevalIdx && decRevalIdx < fwdIntelIdx,
+    "milestone-summary.md: Decision Re-evaluation is between Requirement Changes and Forward Intelligence"
+  );
+}
+
+report();

package/src/resources/extensions/gsd/tests/queue-completed-milestone-perf.test.ts

@@ -0,0 +1,155 @@
+/**
+ * Regression test for #2379: /gsd queue fails with 429 rate limit on projects
+ * with many completed milestones.
+ *
+ * The bug: buildExistingMilestonesContext iterates over ALL milestones
+ * (including completed ones) and calls loadFile for CONTEXT, SUMMARY,
+ * CONTEXT-DRAFT, and ROADMAP files on each — causing excessive I/O that
+ * triggers rate limits on large projects.
+ *
+ * The fix: completed milestones should emit a short summary line without
+ * loading their heavy artifact files (CONTEXT.md, SUMMARY.md, etc.).
+ */
+
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildExistingMilestonesContext } from "../guided-flow-queue.ts";
+import type { GSDState, MilestoneRegistryEntry } from "../types.ts";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, assertEq, report } = createTestContext();
+
+// ─── Fixture: project with many completed milestones ─────────────────────
+
+const tmpBase = mkdtempSync(join(tmpdir(), "gsd-queue-perf-"));
+const gsd = join(tmpBase, ".gsd");
+mkdirSync(join(gsd, "milestones"), { recursive: true });
+
+const COMPLETED_COUNT = 25;
+const ACTIVE_COUNT = 1;
+const PENDING_COUNT = 2;
+
+const allMilestoneIds: string[] = [];
+const registry: MilestoneRegistryEntry[] = [];
+
+// Create 25 completed milestones with CONTEXT.md and SUMMARY.md files
+for (let i = 1; i <= COMPLETED_COUNT; i++) {
+  const mid = `M${String(i).padStart(3, "0")}`;
+  allMilestoneIds.push(mid);
+  registry.push({ id: mid, title: `Completed milestone ${i}`, status: "complete" });
+  mkdirSync(join(gsd, "milestones", mid), { recursive: true });
+  writeFileSync(
+    join(gsd, "milestones", mid, `${mid}-CONTEXT.md`),
+    `# ${mid}: Completed milestone ${i}\n\nThis is a large context document for ${mid}.\n${"Lorem ipsum dolor sit amet. ".repeat(50)}\n`,
+  );
+  writeFileSync(
+    join(gsd, "milestones", mid, `${mid}-SUMMARY.md`),
+    `# ${mid} Summary\n\nDelivered feature ${i} successfully.\n`,
+  );
+}
+
+// Create 1 active milestone
+{
+  const mid = `M${String(COMPLETED_COUNT + 1).padStart(3, "0")}`;
+  allMilestoneIds.push(mid);
+  registry.push({ id: mid, title: "Active milestone", status: "active" });
+  mkdirSync(join(gsd, "milestones", mid), { recursive: true });
+  writeFileSync(
+    join(gsd, "milestones", mid, `${mid}-CONTEXT.md`),
+    `# ${mid}: Active milestone\n\nCurrently in progress.\n`,
+  );
+  writeFileSync(
+    join(gsd, "milestones", mid, `${mid}-ROADMAP.md`),
+    `# ${mid} Roadmap\n\nSlices planned.\n`,
+  );
+}
+
+// Create 2 pending milestones
+for (let i = 0; i < PENDING_COUNT; i++) {
+  const mid = `M${String(COMPLETED_COUNT + ACTIVE_COUNT + 1 + i).padStart(3, "0")}`;
+  allMilestoneIds.push(mid);
+  registry.push({ id: mid, title: `Pending milestone ${i + 1}`, status: "pending" });
+  mkdirSync(join(gsd, "milestones", mid), { recursive: true });
+  writeFileSync(
+    join(gsd, "milestones", mid, `${mid}-CONTEXT.md`),
+    `# ${mid}: Pending milestone ${i + 1}\n\nQueued work.\n`,
+  );
+}
+
+const state: GSDState = {
+  activeMilestone: { id: `M${String(COMPLETED_COUNT + 1).padStart(3, "0")}`, title: "Active milestone" },
+  activeSlice: null,
+  activeTask: null,
+  phase: "executing",
+  recentDecisions: [],
+  blockers: [],
+  nextAction: "",
+  registry,
+};
+
+// ─── Test: completed milestones should NOT have their files loaded ────────
+
+console.log("\n=== Queue completed milestone performance (#2379) ===");
+
+const context = await buildExistingMilestonesContext(tmpBase, allMilestoneIds, state);
+
+// Active and pending milestones SHOULD have full context loaded
+const activeMid = `M${String(COMPLETED_COUNT + 1).padStart(3, "0")}`;
+assertTrue(
+  context.includes("Currently in progress"),
+  "Active milestone context content should be loaded",
+);
+assertTrue(
+  context.includes("Slices planned"),
+  "Active milestone roadmap should be loaded",
+);
+
+for (let i = 0; i < PENDING_COUNT; i++) {
+  const mid = `M${String(COMPLETED_COUNT + ACTIVE_COUNT + 1 + i).padStart(3, "0")}`;
+  assertTrue(
+    context.includes(`Pending milestone ${i + 1}`),
+    `Pending milestone ${mid} context should be loaded`,
+  );
+}
+
+// Completed milestones should NOT have their CONTEXT.md body or SUMMARY.md
+// content loaded — only a status line
+for (let i = 1; i <= COMPLETED_COUNT; i++) {
+  const mid = `M${String(i).padStart(3, "0")}`;
+
+  // Should still mention the milestone ID and status
+  assertTrue(
+    context.includes(mid),
+    `Completed milestone ${mid} should still be referenced`,
+  );
+
+  // Should NOT contain the heavy context body text
+  assertTrue(
+    !context.includes(`This is a large context document for ${mid}`),
+    `Completed milestone ${mid} should NOT have its full CONTEXT.md body loaded`,
+  );
+
+  // Should NOT contain the summary body
+  assertTrue(
+    !context.includes(`Delivered feature ${i} successfully`),
+    `Completed milestone ${mid} should NOT have its SUMMARY.md body loaded`,
+  );
+}
+
+// ─── Test: the overall context should be reasonable in size ──────────────
+
+// With 25 completed milestones NOT loading files, the context should be
+// significantly smaller than if all files were loaded
+const contextLines = context.split("\n").length;
+assertTrue(
+  contextLines < 200,
+  `Context should be concise (got ${contextLines} lines); completed milestones should not inflate it`,
+);
+
+// ─── Cleanup ──────────────────────────────────────────────────────────────
+
+rmSync(tmpBase, { recursive: true, force: true });
+
+report();

package/src/resources/extensions/gsd/tests/queue-reorder-e2e.test.ts

@@ -292,4 +292,44 @@ test('E2E: depends_on inline format preserved after partial removal', () => {
   }
 });
 
+test('E2E: DB-backed path respects queue order (#2556)', async () => {
+    // Regression test for #2556: getActiveMilestoneId and deriveStateFromDb
+    // used lexicographic sort instead of queue order, causing a deadlock when
+    // the dispatch guard (which respects queue order) blocked completion.
+    const base = createFixtureBase();
+    try {
+      const { openDatabase, closeDatabase, insertMilestone, isDbAvailable } = await import('../gsd-db.ts');
+      const dbPath = join(base, '.gsd', 'gsd.db');
+
+      // Create milestone directories (required for findMilestoneIds)
+      writeMilestoneDir(base, 'M006');
+      writeContext(base, 'M006', '', 'Earlier milestone');
+      writeMilestoneDir(base, 'M008');
+      writeContext(base, 'M008', '', 'Later milestone');
+
+      // Open DB and insert milestones
+      openDatabase(dbPath);
+      try {
+        insertMilestone({ id: 'M006', title: 'Earlier', status: 'active' });
+        insertMilestone({ id: 'M008', title: 'Later', status: 'active' });
+
+        // Set queue order: M008 should come FIRST (user reordered via /gsd queue)
+        saveQueueOrder(base, ['M008', 'M006']);
+
+        // deriveState should pick M008 (queue-first), not M006 (ID-first)
+        invalidateStateCache();
+        const state = await deriveState(base);
+        assert.equal(
+          state.activeMilestone?.id,
+          'M008',
+          'DB-backed deriveState must respect queue order — M008 is queued first',
+        );
+      } finally {
+        if (isDbAvailable()) closeDatabase();
+      }
+    } finally {
+      cleanup(base);
+    }
+});
+
 });

package/src/resources/extensions/gsd/tests/reactive-executor.test.ts

@@ -15,6 +15,7 @@ import {
 } from "../reactive-graph.ts";
 import { validatePreferences } from "../preferences-validation.ts";
 import type { ReactiveExecutionState } from "../types.ts";
+import { parseUnitId } from "../unit-id.ts";
 
 // ─── Preference Validation ────────────────────────────────────────────────
 
@@ -441,13 +442,12 @@ test("unitId batch encoding round-trips correctly", () => {
   const unitId = `${mid}/${sid}/reactive+${selected.join(",")}`;
 
   // Parse it back
-  const parts = unitId.split("/");
-  assert.equal(parts[0], "M001");
-  assert.equal(parts[1], "S01");
-  const batchPart = parts[2];
-  const plusIdx = batchPart.indexOf("+");
+  const { milestone, slice, task: batchPart } = parseUnitId(unitId);
+  assert.equal(milestone, "M001");
+  assert.equal(slice, "S01");
+  const plusIdx = batchPart!.indexOf("+");
   assert.ok(plusIdx > 0, "Should have + separator");
-  const batchIds = batchPart.slice(plusIdx + 1).split(",");
+  const batchIds = batchPart!.slice(plusIdx + 1).split(",");
   assert.deepEqual(batchIds, ["T02", "T03", "T05"]);
 });
 

package/src/resources/extensions/gsd/tests/replan-slice.test.ts

@@ -503,7 +503,8 @@ console.log('\n=== doctor: no blocker → no blocker_discovered_no_replan issue
 // Artifact Resolution: resolveExpectedArtifactPath for replan-slice (#858)
 // ═══════════════════════════════════════════════════════════════════════════
 
-import { resolveExpectedArtifactPath, verifyExpectedArtifact } from '../auto-recovery.ts';
+import { resolveExpectedArtifactPath } from '../auto-artifact-paths.ts';
+import { verifyExpectedArtifact } from '../auto-recovery.ts';
 
 
 describe('replan-slice', () => {

package/src/resources/extensions/gsd/tests/repo-identity-worktree.test.ts

@@ -184,6 +184,38 @@ test('subdirectory of parent repo gets unique identity after git init (#1639)',
       rmSync(parentRepo, { recursive: true, force: true });
 });
 
+test('ensureGsdSymlink from subdirectory does not create .gsd in subdir when git-root .gsd exists (#2380)', () => {
+    const repo = realpathSync(mkdtempSync(join(tmpdir(), "gsd-subdir-symlink-")));
+    run("git init -b main", repo);
+    run('git config user.name "Pi Test"', repo);
+    run('git config user.email "pi@example.com"', repo);
+    run('git remote add origin git@github.com:example/subdir-test.git', repo);
+    writeFileSync(join(repo, "README.md"), "# Subdir Test\n", "utf-8");
+    run("git add README.md", repo);
+    run('git commit -m "init"', repo);
+
+    // Set up .gsd symlink at the git root (normal project initialisation)
+    ensureGsdSymlink(repo);
+    assert.ok(existsSync(join(repo, ".gsd")), "root .gsd exists after ensureGsdSymlink");
+    assert.ok(lstatSync(join(repo, ".gsd")).isSymbolicLink(), "root .gsd is a symlink");
+
+    // Create a subdirectory and call ensureGsdSymlink from there
+    const subdir = join(repo, "src", "lib");
+    mkdirSync(subdir, { recursive: true });
+    ensureGsdSymlink(subdir);
+
+    // ensureGsdSymlink should NOT create a .gsd in the subdirectory
+    // because the git root already has a valid .gsd symlink.
+    assert.ok(!existsSync(join(subdir, ".gsd")), "no .gsd created in subdirectory when git-root .gsd exists (#2380)");
+    assert.ok(!existsSync(join(repo, "src", ".gsd")), "no .gsd created in intermediate directory");
+
+    // The root .gsd should still be intact
+    assert.ok(existsSync(join(repo, ".gsd")), "root .gsd still exists");
+    assert.ok(lstatSync(join(repo, ".gsd")).isSymbolicLink(), "root .gsd is still a symlink");
+
+    rmSync(repo, { recursive: true, force: true });
+});
+
 test('validateProjectId rejects invalid values', () => {
     for (const invalid of ["has spaces", "path/traversal", "dot..dot", "back\\slash"]) {
       assert.ok(!validateProjectId(invalid), `validateProjectId rejects invalid value: "${invalid}"`);