gsd-pi 2.79.0 → 2.80.0-dev.4ea7d80e7

package/src/resources/extensions/gsd/tests/auto-runtime-state.test.ts

@@ -0,0 +1,39 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { autoSession, getAutoRuntimeSnapshot } from "../auto-runtime-state.ts";
+
+test("getAutoRuntimeSnapshot includes orchestration phase when available", () => {
+  autoSession.reset();
+  autoSession.active = true;
+  autoSession.basePath = "/tmp/project";
+  autoSession.orchestration = {
+    async start() { return { kind: "advanced" as const }; },
+    async advance() { return { kind: "advanced" as const }; },
+    async resume() { return { kind: "advanced" as const }; },
+    async stop() { return { kind: "stopped" as const }; },
+    getStatus() {
+      return { phase: "running" as const, transitionCount: 3, lastTransitionAt: 123 };
+    },
+  };
+
+  const snap = getAutoRuntimeSnapshot();
+
+  assert.equal(snap.active, true);
+  assert.equal(snap.basePath, "/tmp/project");
+  assert.equal(snap.orchestrationPhase, "running");
+  assert.equal(snap.orchestrationTransitionCount, 3);
+  assert.equal(snap.orchestrationLastTransitionAt, 123);
+
+  autoSession.reset();
+});
+
+test("getAutoRuntimeSnapshot omits orchestration phase when seam not wired", () => {
+  autoSession.reset();
+
+  const snap = getAutoRuntimeSnapshot();
+
+  assert.equal(snap.orchestrationPhase, undefined);
+  assert.equal(snap.orchestrationTransitionCount, undefined);
+  assert.equal(snap.orchestrationLastTransitionAt, undefined);
+});

package/src/resources/extensions/gsd/tests/auto-session-encapsulation.test.ts

@@ -201,6 +201,9 @@ test("AutoSession.toJSON() includes key diagnostic properties", () => {
     "basePath",
     "currentMilestoneId",
     "currentUnit",
+    "orchestrationPhase",
+    "orchestrationTransitionCount",
+    "orchestrationLastTransitionAt",
   ];
 
   const missing = requiredDiagnostics.filter(prop => !toJSONBody.includes(prop));

package/src/resources/extensions/gsd/tests/bootstrap-derive-state-db-open.test.ts

@@ -31,9 +31,9 @@ describe("bootstrap deriveState DB guards (#3844)", () => {
     const compactIdx = registerHooksSrc.indexOf('pi.on("session_before_compact"');
     assert.ok(compactIdx > -1, "register-hooks should define session_before_compact");
     const compactSection = extractSourceRegion(registerHooksSrc, 'pi.on("session_before_compact"');
-    const ensureIdx = compactSection.indexOf("ensureDbOpen()");
+    const ensureIdx = compactSection.indexOf("ensureDbOpen(basePath)");
     const deriveIdx = compactSection.indexOf("deriveGsdState(basePath)");
-    assert.ok(ensureIdx > -1, "session_before_compact should call ensureDbOpen()");
+    assert.ok(ensureIdx > -1, "session_before_compact should call ensureDbOpen(basePath)");
     assert.ok(deriveIdx > -1, "session_before_compact should derive state");
     assert.ok(ensureIdx < deriveIdx, "session_before_compact should open DB before deriveState");
   });

package/src/resources/extensions/gsd/tests/check-auto-start-pending-gate.test.ts

@@ -0,0 +1,203 @@
+// GSD-2 + Regression tests for checkAutoStartAfterDiscuss Gate 1a (R2)
+//
+// When a depth-verification gate is still pending (the LLM emitted the
+// confirmation question via ask_user_questions or plain chat but the user has
+// not answered), checkAutoStartAfterDiscuss must NOT advance — even if
+// CONTEXT.md and STATE.md are present on disk. Otherwise the LLM can render
+// the question and the "Milestone M001 ready" phrase in the same turn and
+// race past the gate.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  checkAutoStartAfterDiscuss,
+  setPendingAutoStart,
+  clearPendingAutoStart,
+} from "../guided-flow.ts";
+import { drainLogs } from "../workflow-logger.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+} from "../gsd-db.ts";
+import {
+  setPendingGate,
+  clearPendingGate,
+  clearDiscussionFlowState,
+} from "../bootstrap/write-gate.ts";
+
+interface MockCapture {
+  notifies: Array<{ msg: string; level: string }>;
+  messages: Array<{ payload: any; options: any }>;
+}
+
+function mkCapture(): MockCapture {
+  return { notifies: [], messages: [] };
+}
+
+function mkCtx(cap: MockCapture): any {
+  return {
+    ui: {
+      notify: (msg: string, level: string) => {
+        cap.notifies.push({ msg, level });
+      },
+    },
+  };
+}
+
+function mkPi(cap: MockCapture): any {
+  return {
+    sendMessage: (payload: any, options: any) => {
+      cap.messages.push({ payload, options });
+    },
+    setActiveTools: () => undefined,
+    getActiveTools: () => [],
+  };
+}
+
+function mkBase(): string {
+  // realpathSync to normalize the macOS /var → /private/var symlink so the
+  // basePath we pass to setPendingGate matches what the workspace's
+  // realpath-normalized projectRoot will resolve to.
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-gate1a-pending-")));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  // CONTEXT.md (Gate 1) and STATE.md (Gate 2) both present so the only
+  // possible blocker in these tests is the new Gate 1a.
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001: Pending Gate Test\n\nContext.\n",
+  );
+  writeFileSync(
+    join(base, ".gsd", "STATE.md"),
+    "# State\n\nactive: M001\n",
+  );
+  return base;
+}
+
+describe("checkAutoStartAfterDiscuss Gate 1a (pending depth-verification gate)", () => {
+  let base: string;
+  let cap: MockCapture;
+
+  beforeEach(() => {
+    clearPendingAutoStart();
+    drainLogs();
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    clearPendingAutoStart();
+    if (base) {
+      try { clearDiscussionFlowState(base); } catch { /* */ }
+      try { clearPendingGate(base); } catch { /* */ }
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test("returns false while a depth_verification gate is pending for the same milestone", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+    // DB row present + active so Gate 1b is not the blocker
+    insertMilestone({ id: "M001", title: "Pending Gate Test", status: "active" });
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    // The depth-verification gate for THIS milestone is still pending.
+    setPendingGate("depth_verification_M001_confirm", base);
+
+    const result = checkAutoStartAfterDiscuss();
+    assert.equal(result, false, "must not advance while the milestone gate is pending");
+    // Must not have announced "ready" or kicked auto.
+    const readyNotify = cap.notifies.find((n) => /ready\.?$/i.test(n.msg) && n.level === "success");
+    assert.equal(readyNotify, undefined, "must not announce 'ready' while gate pending");
+  });
+
+  test("returns false while a depth_verification_project_confirm gate is pending (deep setup)", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Pending Gate Test", status: "active" });
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    // A project-level depth-verification gate (no milestone id encoded) is pending —
+    // deep-setup interview has not been confirmed yet.
+    setPendingGate("depth_verification_project_confirm", base);
+
+    const result = checkAutoStartAfterDiscuss();
+    assert.equal(result, false, "must not advance while a project-level gate is pending");
+  });
+
+  test("returns false while a depth_verification_requirements_confirm gate is pending", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Pending Gate Test", status: "active" });
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    setPendingGate("depth_verification_requirements_confirm", base);
+
+    const result = checkAutoStartAfterDiscuss();
+    assert.equal(result, false, "must not advance while the requirements gate is pending");
+  });
+
+  test("Gate 1a does NOT trip when the pending gate is for a DIFFERENT milestone", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+    // status: "queued" so that Gate 1b downstream of Gate 1a fires its
+    // recovery notify ("context file exists but milestone is still queued") —
+    // observing that notify proves we advanced past Gate 1a. If Gate 1a
+    // wrongly tripped on the M999 gate it would `return false` immediately
+    // and Gate 1b would never run, so the notify would be absent.
+    insertMilestone({ id: "M001", title: "Pending Gate Test", status: "queued" });
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    setPendingGate("depth_verification_M999_confirm", base);
+
+    const result = checkAutoStartAfterDiscuss();
+    assert.equal(result, false, "Gate 1b returns false (expected) — but only if Gate 1a let us through");
+
+    // Positive proof we passed Gate 1a: Gate 1b emitted its recovery notify
+    // about M001 (not M999 — the pending-gate milestone is irrelevant here).
+    const gate1bNotify = cap.notifies.find(n =>
+      n.level === "warning" && /M001.*context file exists but milestone is still queued/i.test(n.msg)
+    );
+    assert.ok(
+      gate1bNotify,
+      `expected Gate 1b warning notify about M001; got: ${JSON.stringify(cap.notifies)}`,
+    );
+
+    // Negative proof: no Gate 1a notification path exists in source today, but
+    // also assert no notify mentions M999 (the pending-gate milestone) — that
+    // would suggest Gate 1a is leaking the wrong milestone into messaging.
+    const m999Notify = cap.notifies.find(n => /M999/i.test(n.msg));
+    assert.equal(m999Notify, undefined, "no notify should reference M999 (the pending-gate milestone)");
+  });
+});

package/src/resources/extensions/gsd/tests/check-auto-start-ready-guard.test.ts

@@ -0,0 +1,148 @@
+// GSD-2 + Regression tests for checkAutoStartAfterDiscuss "ready" notify guard (R3b)
+//
+// Belt-and-suspenders: even when CONTEXT.md and STATE.md exist on disk, the
+// "Milestone X ready." success notify must not fire when the milestone DB row
+// is absent. Otherwise the user sees "ready" and then /gsd reports
+// "No Active Milestone" because the milestone was never registered.
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import {
+  checkAutoStartAfterDiscuss,
+  setPendingAutoStart,
+  clearPendingAutoStart,
+} from "../guided-flow.ts";
+import { drainLogs } from "../workflow-logger.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+} from "../gsd-db.ts";
+import {
+  clearDiscussionFlowState,
+  clearPendingGate,
+} from "../bootstrap/write-gate.ts";
+
+interface MockCapture {
+  notifies: Array<{ msg: string; level: string }>;
+  messages: Array<{ payload: any; options: any }>;
+}
+
+function mkCapture(): MockCapture {
+  return { notifies: [], messages: [] };
+}
+
+function mkCtx(cap: MockCapture): any {
+  return {
+    ui: {
+      notify: (msg: string, level: string) => {
+        cap.notifies.push({ msg, level });
+      },
+    },
+  };
+}
+
+function mkPi(cap: MockCapture): any {
+  return {
+    sendMessage: (payload: any, options: any) => {
+      cap.messages.push({ payload, options });
+    },
+    setActiveTools: () => undefined,
+    getActiveTools: () => [],
+  };
+}
+
+function mkBase(): string {
+  // realpathSync to normalize the macOS /var → /private/var symlink so the
+  // basePath we pass matches what the workspace projectRoot resolves to.
+  const base = realpathSync(mkdtempSync(join(tmpdir(), "gsd-ready-guard-")));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001: Ready Guard Test\n\nContext.\n",
+  );
+  writeFileSync(
+    join(base, ".gsd", "STATE.md"),
+    "# State\n\nactive: M001\n",
+  );
+  return base;
+}
+
+describe("checkAutoStartAfterDiscuss ready-notify DB guard (R3b)", () => {
+  let base: string;
+  let cap: MockCapture;
+
+  beforeEach(() => {
+    clearPendingAutoStart();
+    drainLogs();
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    clearPendingAutoStart();
+    if (base) {
+      try { clearDiscussionFlowState(base); } catch { /* */ }
+      try { clearPendingGate(base); } catch { /* */ }
+      rmSync(base, { recursive: true, force: true });
+    }
+  });
+
+  test("does not announce 'ready' when the milestone DB row is absent", () => {
+    base = mkBase();
+    // Open a fresh in-memory DB but DO NOT insertMilestone for M001.
+    openDatabase(":memory:");
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    const result = checkAutoStartAfterDiscuss();
+    assert.equal(result, false, "must return false when DB row missing");
+
+    // No success "ready" notify
+    const successReady = cap.notifies.find(
+      (n) => n.level === "success" && /ready\.?$/i.test(n.msg),
+    );
+    assert.equal(successReady, undefined, "must not announce 'ready' when DB row missing");
+
+    // An error notify must explain the missing DB row
+    const errorNotify = cap.notifies.find((n) => n.level === "error");
+    assert.ok(errorNotify, "must emit an error notify when the DB row is missing");
+    assert.match(
+      errorNotify!.msg,
+      /no DB row exists/i,
+      "error notify must mention the missing DB row",
+    );
+    assert.match(errorNotify!.msg, /M001/, "error notify must mention the milestone id");
+  });
+
+  test("announces 'ready' when DB row exists", () => {
+    base = mkBase();
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Ready Guard Test", status: "active" });
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    const result = checkAutoStartAfterDiscuss();
+    assert.equal(result, true, "must return true on the happy path");
+
+    const successReady = cap.notifies.find(
+      (n) => n.level === "success" && /Milestone\s+M001\s+ready/i.test(n.msg),
+    );
+    assert.ok(successReady, "must announce 'Milestone M001 ready.' on success");
+  });
+});

package/src/resources/extensions/gsd/tests/commands-eval-review.test.ts

@@ -9,7 +9,7 @@
 
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { mkdirSync, realpathSync, writeFileSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -462,7 +462,7 @@ describe("findEvalReviewFile", () => {
     const target = join(basePath, ".gsd", "milestones", "M001", "slices", "S07", "S07-EVAL-REVIEW.md");
     writeFileSync(target, "---\nschema: eval-review/v1\n---\n", "utf-8");
     const found = findEvalReviewFile(basePath, "M001", "S07");
-    assert.equal(found, target);
+    assert.equal(found, realpathSync(target));
   });
 });
 

package/src/resources/extensions/gsd/tests/commands-extract-learnings.test.ts

@@ -1,3 +1,4 @@
+// GSD2 commands-extract-learnings tests
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
@@ -484,6 +485,14 @@ describe("buildExtractionStepsBlock", () => {
     assert.ok(/skip/i.test(block));
   });
 
+  it("limits duplicate checks to one milestone-scoped memory query", () => {
+    const block = buildExtractionStepsBlock(ctx);
+    const memoryQueryMatches = block.match(/memory_query/g) ?? [];
+    assert.equal(memoryQueryMatches.length, 1);
+    assert.ok(block.includes("Do not re-read milestone artefacts or repeat memory queries category-by-category"));
+    assert.ok(!block.includes("Before each `capture_thought` call, optionally call `memory_query`"));
+  });
+
   it("instructs capture_thought as the sole persistence path for Patterns, Lessons, and Decisions (ADR-013 step 6 cutover)", () => {
     const block = buildExtractionStepsBlock(ctx);
     // Each of the three persistence steps must call capture_thought.

package/src/resources/extensions/gsd/tests/commands-ship-eval-warn.test.ts

@@ -12,7 +12,7 @@
 
 import { describe, it, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, rmSync, writeFileSync, unlinkSync } from "node:fs";
+import { mkdirSync, realpathSync, rmSync, writeFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -129,7 +129,8 @@ describe("checkSliceEvalReview", () => {
     // points to a missing file — exactly the race a prior existsSync +
     // readFileSync sequence panicked on.
     const resolved = resolveSliceFile(basePath, "M001", "S07", "EVAL-REVIEW");
-    assert.equal(resolved, path);
+    assert.ok(resolved);
+    assert.equal(realpathSync(resolved), realpathSync(path));
     unlinkSync(path);
     const result = await checkSliceEvalReview(basePath, "M001", "S07");
     assert.equal(result.kind, "absent");

package/src/resources/extensions/gsd/tests/complete-milestone-prompt-rendering.test.ts

@@ -0,0 +1,47 @@
+// Project/App: GSD-2
+// File Purpose: Verifies the complete milestone prompt renders required completion and verification guardrails.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+test("complete milestone prompt renders compact verification and completion guidance", async (t) => {
+  const previousGsdHome = process.env.GSD_HOME;
+  const providedGsdHome = process.env.GSD_TEST_HOME;
+  const isolatedHome = providedGsdHome ?? mkdtempSync(join(tmpdir(), "gsd-complete-milestone-render-"));
+  process.env.GSD_HOME = isolatedHome;
+  t.after(() => {
+    if (previousGsdHome === undefined) delete process.env.GSD_HOME;
+    else process.env.GSD_HOME = previousGsdHome;
+    if (!providedGsdHome) rmSync(isolatedHome, { recursive: true, force: true });
+  });
+
+  const { loadPrompt } = await import(`../prompt-loader.ts?test=${Date.now()}`);
+  const prompt = loadPrompt("complete-milestone", {
+    workingDirectory: process.env.GSD_TEST_WORKSPACE_ROOT ?? process.cwd(),
+    milestoneId: "M001",
+    milestoneTitle: "Baseline And Safety",
+    roadmapPath: ".gsd/milestones/M001/M001-ROADMAP.md",
+    milestoneSummaryPath: ".gsd/milestones/M001/M001-SUMMARY.md",
+    inlinedContext: "## Milestone Summary\n\n## Horizontal Checklist\n\n## Decision Re-evaluation",
+    extractLearningsSteps: "Write M001-LEARNINGS.md and call capture_thought.",
+  });
+
+  assert.match(prompt, /Complete Milestone M001/);
+  assert.match(prompt, /Verification Gate/);
+  assert.match(prompt, /Do NOT call `gsd_complete_milestone`/);
+  assert.match(prompt, /verification FAILED/);
+  assert.match(prompt, /gsd_requirement_update/);
+  assert.match(prompt, /gsd_complete_milestone/);
+  assert.match(prompt, /verificationPassed/);
+  assert.match(prompt, /gsd_milestone_status/);
+  assert.match(prompt, /Do NOT query.*\.gsd\/gsd\.db/i);
+  assert.match(prompt, /Horizontal Checklist/);
+  assert.match(prompt, /Decision Re-evaluation/);
+  assert.match(prompt, /self-diff/i);
+  assert.match(prompt, /GSD-(?:Task|Unit)/);
+  assert.match(prompt, /Milestone M001 complete/);
+  assert.doesNotMatch(prompt, /\{\{[a-zA-Z][a-zA-Z0-9_]*\}\}/);
+});

package/src/resources/extensions/gsd/tests/complete-milestone.test.ts

@@ -1,3 +1,4 @@
+// GSD2 complete-milestone tests
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync, existsSync } from "node:fs";
@@ -432,10 +433,9 @@ describe("complete-milestone", () => {
     }
   });
 
-  test("handleCompleteMilestone does not overwrite existing SUMMARY.md on re-dispatch (#4598)", async () => {
+  test("handleCompleteMilestone treats already-complete milestone as idempotent re-dispatch (#4598)", async () => {
     // This test verifies that when SUMMARY.md already exists (from a prior completion),
     // re-calling handleCompleteMilestone does not overwrite it.
-    // Before the fix this test FAILS because the handler unconditionally writes SUMMARY.md.
     const { handleCompleteMilestone } = await import("../tools/complete-milestone.ts");
     const base = createFixtureBase();
     const mid = "M001";
@@ -443,7 +443,7 @@ describe("complete-milestone", () => {
     try {
       // Set up DB with milestone and a complete slice + task
       openDatabase(dbPath);
-      insertMilestone({ id: mid, title: "Test Milestone", status: "active" });
+      insertMilestone({ id: mid, title: "Test Milestone", status: "complete" });
       insertSlice({ id: "S01", milestoneId: mid, title: "Slice One", status: "complete" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: mid, title: "Task One", status: "complete" });
 
@@ -472,15 +472,29 @@ describe("complete-milestone", () => {
       };
 
       const result = await handleCompleteMilestone(params, base);
+      assert.ok(!("error" in result), `already-complete re-dispatch should succeed: ${JSON.stringify(result)}`);
+      assert.equal(result.alreadyComplete, true);
 
-      // The call may return an error (milestone already complete) or success
-      // but in either case the SUMMARY.md must NOT be overwritten.
       const actualContent = readFileSync(summaryPath, "utf-8");
       assert.strictEqual(
         actualContent,
         originalContent,
         "existing SUMMARY.md must not be overwritten on re-dispatch (#4598)",
       );
+
+      // Repeated re-dispatch should also be idempotent.
+      const repeatResult = await handleCompleteMilestone(params, base);
+      assert.ok(!("error" in repeatResult), "repeated re-dispatch should also succeed");
+      assert.strictEqual(repeatResult.alreadyComplete, true, "repeated re-dispatch is identified as already-complete");
+      assert.ok(
+        repeatResult.summaryPath.endsWith(join(".gsd", "milestones", mid, `${mid}-SUMMARY.md`)),
+        "repeated re-dispatch returns the existing summary path",
+      );
+      assert.strictEqual(
+        readFileSync(summaryPath, "utf-8"),
+        originalContent,
+        "repeated re-dispatch must not overwrite SUMMARY.md",
+      );
     } finally {
       try { closeDatabase(); } catch { /* */ }
       clearPathCache();

package/src/resources/extensions/gsd/tests/component-loader.test.ts

@@ -1,12 +1,5 @@
-/**
- * Component Loader — Unit Tests
- *
- * Tests for multi-format component loading:
- * - New format (component.yaml)
- * - Legacy skill format (SKILL.md with frontmatter)
- * - Legacy agent format (.md with frontmatter)
- * - Directory scanning
- */
+// Project/App: GSD-2
+// File Purpose: Verifies component loading across modern and legacy formats.
 
 import { describe, it, beforeEach, afterEach } from 'node:test';
 import assert from 'node:assert/strict';

package/src/resources/extensions/gsd/tests/current-directory-root-homedir-fallback.test.ts

@@ -0,0 +1,63 @@
+/**
+ * Regression test — currentDirectoryRoot() uses os.homedir() as fallback
+ * when process.cwd() throws (e.g. worktree teardown deletes the cwd).
+ *
+ * Before the fix, the catch block used `process.env.HOME ?? "/"`. On
+ * Windows, HOME is typically unset so this resolved to "/", an invalid
+ * path. After the fix, os.homedir() is used — it checks USERPROFILE,
+ * HOMEDRIVE+HOMEPATH, etc., returning a valid path on all platforms.
+ *
+ * The test monkey-patches process.cwd() to throw ENOENT, simulating a
+ * deleted cwd. currentDirectoryRoot() must NOT propagate the raw error;
+ * instead it falls back to homedir(), which validateDirectory correctly
+ * rejects as "blocked", yielding GSDNoProjectError — the same controlled
+ * error path handlers already know how to catch.
+ *
+ * The error message is also asserted to match validateDirectory(homedir()),
+ * confirming the fallback resolved to homedir() specifically (not "/" or
+ * any other path).
+ */
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { homedir } from "node:os";
+
+import { currentDirectoryRoot, GSDNoProjectError } from "../commands/context.ts";
+import { validateDirectory } from "../validate-directory.ts";
+
+describe("currentDirectoryRoot() homedir() fallback on deleted cwd", () => {
+  const originalCwd = process.cwd.bind(process);
+
+  beforeEach(() => {
+    process.cwd = () => {
+      const err = new Error("ENOENT: no such file or directory, uv_cwd");
+      (err as NodeJS.ErrnoException).code = "ENOENT";
+      throw err;
+    };
+  });
+
+  afterEach(() => {
+    process.cwd = originalCwd;
+  });
+
+  test("does not propagate ENOENT — throws GSDNoProjectError via homedir() fallback", () => {
+    const expected = validateDirectory(homedir());
+    assert.equal(expected.severity, "blocked", "homedir() itself should be blocked");
+
+    assert.throws(
+      () => currentDirectoryRoot(),
+      (err: unknown) => {
+        assert.ok(
+          err instanceof GSDNoProjectError,
+          `expected GSDNoProjectError, got: ${err}`,
+        );
+        assert.equal(
+          (err as Error).message,
+          expected.reason ?? "GSD must be run inside a project directory.",
+          "error message must match validateDirectory(homedir()), confirming homedir() was the fallback",
+        );
+        return true;
+      },
+      "should throw GSDNoProjectError (homedir fallback validated), not raw ENOENT",
+    );
+  });
+});