gsd-pi 2.79.0-dev.5c910bb05 → 2.79.0-dev.ece5fd8ba

package/src/resources/extensions/gsd/bootstrap/tests/write-gate-shouldblock-basepath.test.ts

@@ -0,0 +1,97 @@
+// GSD-2 write-gate bootstrap — regression tests for basePath threading on
+// shouldBlockContextWrite / shouldBlockPendingGate (R1).
+//
+// The underlying bug: readers defaulted to process.cwd() and so missed the
+// per-basePath state Map entry written by markDepthVerified(..., baseDirA)
+// when cwd had drifted to baseDirB. With basePath threaded explicitly to
+// the readers, the depth-gate sees the verified state regardless of cwd.
+
+import { test, describe, before, after } 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";
+
+import {
+  markDepthVerified,
+  setPendingGate,
+  shouldBlockContextWrite,
+  shouldBlockPendingGate,
+  clearDiscussionFlowState,
+} from "../write-gate.js";
+
+function makeTempDir(): string {
+  return mkdtempSync(join(tmpdir(), "wg-shouldblock-basepath-"));
+}
+
+let originalCwd: string;
+before(() => {
+  originalCwd = process.cwd();
+});
+after(() => {
+  if (process.cwd() !== originalCwd) {
+    process.chdir(originalCwd);
+  }
+});
+
+describe("write-gate shouldBlock readers respect explicit basePath", () => {
+  let baseDirA: string;
+  let baseDirB: string;
+  let prevPersist: string | undefined;
+
+  before(() => {
+    baseDirA = makeTempDir();
+    baseDirB = makeTempDir();
+    prevPersist = process.env.GSD_PERSIST_WRITE_GATE_STATE;
+    process.env.GSD_PERSIST_WRITE_GATE_STATE = "1";
+  });
+
+  after(() => {
+    process.chdir(originalCwd);
+    if (prevPersist === undefined) {
+      delete process.env.GSD_PERSIST_WRITE_GATE_STATE;
+    } else {
+      process.env.GSD_PERSIST_WRITE_GATE_STATE = prevPersist;
+    }
+    rmSync(baseDirA, { recursive: true, force: true });
+    rmSync(baseDirB, { recursive: true, force: true });
+  });
+
+  test("shouldBlockContextWrite with explicit basePath sees verified state after cwd drift", () => {
+    clearDiscussionFlowState(baseDirA);
+    clearDiscussionFlowState(baseDirB);
+
+    markDepthVerified("M001", baseDirA);
+    process.chdir(baseDirB);
+
+    const contextPath = join(baseDirA, ".gsd", "milestones", "M001", "M001-CONTEXT.md");
+    const result = shouldBlockContextWrite("write", contextPath, "M001", undefined, baseDirA);
+
+    assert.equal(result.block, false, "explicit basePath should resolve to baseDirA's verified state");
+  });
+
+  test("shouldBlockContextWrite without basePath defaults to cwd and misses verified state (bug repro)", () => {
+    clearDiscussionFlowState(baseDirA);
+    clearDiscussionFlowState(baseDirB);
+
+    markDepthVerified("M001", baseDirA);
+    process.chdir(baseDirB);
+
+    const contextPath = join(baseDirA, ".gsd", "milestones", "M001", "M001-CONTEXT.md");
+    const result = shouldBlockContextWrite("write", contextPath, "M001");
+
+    assert.equal(result.block, true, "default-to-cwd path resolves to baseDirB and misses baseDirA state");
+  });
+
+  test("shouldBlockPendingGate with explicit basePath sees pending gate after cwd drift", () => {
+    clearDiscussionFlowState(baseDirA);
+    clearDiscussionFlowState(baseDirB);
+
+    setPendingGate("depth_verification_M001_confirm", baseDirA);
+    process.chdir(baseDirB);
+
+    const result = shouldBlockPendingGate("write", "M001", false, baseDirA);
+
+    assert.equal(result.block, true, "explicit basePath should resolve to baseDirA's pending gate state");
+  });
+});

package/src/resources/extensions/gsd/bootstrap/write-gate.ts

@@ -351,8 +351,9 @@ export function shouldBlockPendingGate(
   toolName: string,
   milestoneId: string | null,
   queuePhaseActive?: boolean,
+  basePath: string = process.cwd(),
 ): { block: boolean; reason?: string } {
-  return shouldBlockPendingGateInSnapshot(currentWriteGateSnapshot(), toolName, milestoneId, queuePhaseActive);
+  return shouldBlockPendingGateInSnapshot(currentWriteGateSnapshot(basePath), toolName, milestoneId, queuePhaseActive);
 }
 
 export function shouldBlockPendingGateInSnapshot(
@@ -386,8 +387,9 @@ export function shouldBlockPendingGateBash(
   command: string,
   milestoneId: string | null,
   queuePhaseActive?: boolean,
+  basePath: string = process.cwd(),
 ): { block: boolean; reason?: string } {
-  return shouldBlockPendingGateBashInSnapshot(currentWriteGateSnapshot(), command, milestoneId, queuePhaseActive);
+  return shouldBlockPendingGateBashInSnapshot(currentWriteGateSnapshot(basePath), command, milestoneId, queuePhaseActive);
 }
 
 export function shouldBlockPendingGateBashInSnapshot(
@@ -444,6 +446,7 @@ export function shouldBlockContextWrite(
   inputPath: string,
   milestoneId: string | null,
   _queuePhaseActive?: boolean,
+  basePath: string = process.cwd(),
 ): { block: boolean; reason?: string } {
   if (toolName !== "write") return { block: false };
   if (!MILESTONE_CONTEXT_RE.test(inputPath)) return { block: false };
@@ -460,7 +463,7 @@ export function shouldBlockContextWrite(
     };
   }
 
-  if (isMilestoneDepthVerified(targetMilestoneId)) return { block: false };
+  if (isMilestoneDepthVerified(targetMilestoneId, basePath)) return { block: false };
 
   return {
     block: true,
@@ -483,8 +486,9 @@ export function shouldBlockContextArtifactSave(
   artifactType: string,
   milestoneId: string | null,
   sliceId?: string | null,
+  basePath: string = process.cwd(),
 ): { block: boolean; reason?: string } {
-  return shouldBlockContextArtifactSaveInSnapshot(currentWriteGateSnapshot(), artifactType, milestoneId, sliceId);
+  return shouldBlockContextArtifactSaveInSnapshot(currentWriteGateSnapshot(basePath), artifactType, milestoneId, sliceId);
 }
 
 export function shouldBlockContextArtifactSaveInSnapshot(

package/src/resources/extensions/gsd/guided-flow.ts

@@ -70,6 +70,7 @@ import {
 } from "./preparation.js";
 import { verifyExpectedArtifact } from "./auto-recovery.js";
 import { createWorkspace, scopeMilestone, type MilestoneScope } from "./workspace.js";
+import { getPendingGate, extractDepthVerificationMilestoneId } from "./bootstrap/write-gate.js";
 
 // ─── Re-exports (preserve public API for existing importers) ────────────────
 export {
@@ -410,6 +411,15 @@ export async function checkDeepProjectSetupAfterTurn(
     }
   }
 
+  // R2: 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 approved yet. Returning false keeps the entry in the
+  // pendingDeepProjectSetupMap so the next user message can resume.
+  const pendingGateId = getPendingGate(entry.basePath);
+  if (pendingGateId) {
+    return false;
+  }
+
   return dispatchNextDeepProjectSetupStage(entry);
 }
 
@@ -494,6 +504,25 @@ export function checkAutoStartAfterDiscuss(): boolean {
   const roadmapFile = existsSync(roadmapFilePath) ? roadmapFilePath : null;
   if (!contextFile && !roadmapFile) return false; // neither artifact yet — keep waiting
 
+  // Gate 1a: a depth-verification gate is still pending for THIS milestone — the
+  // LLM emitted the confirmation question (via ask_user_questions or plain chat)
+  // but the user has not answered yet. Advancing now would skip the gate and
+  // race ahead with unverified context.
+  const basePathForGate = entry.scope.workspace.projectRoot;
+  const pendingGateId = getPendingGate(basePathForGate);
+  if (pendingGateId) {
+    const pendingMilestoneId = extractDepthVerificationMilestoneId(pendingGateId);
+    // Block advancement if the gate is for THIS milestone, OR if it's a
+    // project/requirements gate (no milestone id encoded) for the deep setup flow.
+    const isProjectGate =
+      pendingGateId === "depth_verification_project_confirm" ||
+      pendingGateId === "depth_verification_requirements_confirm" ||
+      pendingGateId === "depth_verification_research_decision_confirm";
+    if (pendingMilestoneId === milestoneId || isProjectGate) {
+      return false;
+    }
+  }
+
   // Gate 1b: Discriminate plan-blocked from discuss-incomplete when the DB row is queued.
   // If the DB is available and the row is still "queued" but CONTEXT.md already exists on
   // disk, the discuss phase completed but gsd_plan_milestone was hard-blocked by the
@@ -628,6 +657,24 @@ export function checkAutoStartAfterDiscuss(): boolean {
     try { unlinkSync(manifestPath); } catch (e) { logWarning("guided", `manifest unlink failed: ${(e as Error).message}`); }
   }
 
+  // R3b: belt-and-suspenders for silent registration failure. The discuss flow
+  // finished and STATE.md exists, but the milestone may never have landed in
+  // the DB. Without this guard, the user sees "Milestone M001 ready." and then
+  // /gsd reports "No Active Milestone".
+  if (isDbAvailable()) {
+    const milestoneRow = getMilestone(milestoneId);
+    if (!milestoneRow) {
+      ctx.ui.notify(
+        `Milestone ${milestoneId}: discuss artifacts on disk but no DB row exists. ` +
+        `PROJECT.md may have failed to register milestones. ` +
+        `Re-save PROJECT.md with canonical "- [ ] M001: Title — One-liner" lines, ` +
+        `then re-run /gsd to recover.`,
+        "error",
+      );
+      return false;
+    }
+  }
+
   pendingAutoStartMap.delete(basePath);
   ctx.ui.notify(`Milestone ${milestoneId} ready.`, "success");
   startAutoDetached(ctx, pi, basePath, false, { step });

package/src/resources/extensions/gsd/paths.ts

@@ -188,9 +188,14 @@ export function resolveDir(parentDir: string, idPrefix: string): string | null {
     // Exact match first (current convention: bare ID)
     const exact = entries.find(e => e.isDirectory() && e.name === idPrefix);
     if (exact) return exact.name;
+    const idLower = idPrefix.toLowerCase();
+    const exactCaseInsensitive = entries.find(
+      e => e.isDirectory() && e.name.toLowerCase() === idLower
+    );
+    if (exactCaseInsensitive) return exactCaseInsensitive.name;
     // Prefix match for legacy descriptor dirs: M001-SOMETHING
     const prefixed = entries.find(
-      e => e.isDirectory() && e.name.startsWith(idPrefix + "-")
+      e => e.isDirectory() && e.name.toLowerCase().startsWith(idLower + "-")
     );
     return prefixed ? prefixed.name : null;
   } catch {

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

@@ -7,7 +7,7 @@ import { randomUUID } from "node:crypto";
 
 import { verifyExpectedArtifact, hasImplementationArtifacts, resolveExpectedArtifactPath, diagnoseExpectedArtifact, buildLoopRemediationSteps, writeBlockerPlaceholder } from "../auto-recovery.ts";
 import { resolveMilestoneFile } from "../paths.ts";
-import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow } from "../gsd-db.ts";
+import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertGateRow, insertTask } from "../gsd-db.ts";
 import { clearParseCache } from "../files.ts";
 import { parseRoadmap } from "../parsers-legacy.ts";
 import { invalidateAllCaches } from "../cache.ts";
@@ -90,6 +90,46 @@ test("resolveExpectedArtifactPath returns correct path for plan-slice", () => {
   }
 });
 
+test("plan-slice artifact resolution handles lowercase unit IDs against uppercase paths", () => {
+  const base = makeTmpBase();
+  try {
+    const sliceDir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    const tasksDir = join(sliceDir, "tasks");
+    writeFileSync(join(sliceDir, "S01-PLAN.md"), [
+      "# S01: Test Slice",
+      "",
+      "## Tasks",
+      "",
+      "- [ ] **T01: Implement feature** `est:1h`",
+    ].join("\n"));
+    writeFileSync(join(tasksDir, "T01-PLAN.md"), "# T01 Plan");
+
+    const artifactPath = resolveExpectedArtifactPath("plan-slice", "m001/s01", base);
+    assert.ok(
+      artifactPath?.endsWith(".gsd/milestones/M001/slices/S01/S01-PLAN.md"),
+      "lowercase unit IDs should resolve to the existing uppercase artifact path",
+    );
+
+    const diagnostic = diagnoseExpectedArtifact("plan-slice", "m001/s01", base);
+    assert.ok(
+      diagnostic?.includes(".gsd/milestones/M001/slices/S01/S01-PLAN.md"),
+      "diagnostic should report the existing uppercase artifact path",
+    );
+    assert.ok(
+      diagnostic?.includes("task plans"),
+      "diagnostic should mention task plans because slice plan alone is insufficient",
+    );
+
+    assert.equal(
+      verifyExpectedArtifact("plan-slice", "m001/s01", base),
+      true,
+      "verification should pass when the uppercase slice plan and task plans exist",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("resolveExpectedArtifactPath returns null for unknown type", () => {
   const base = makeTmpBase();
   try {
@@ -764,6 +804,73 @@ test("hasImplementationArtifacts finds implementation commits when .gsd/ is giti
   }
 });
 
+test("hasImplementationArtifacts binds GSD-Task trailer to milestone via DB state when .gsd/ is gitignored", () => {
+  const base = makeGitBase();
+  try {
+    writeFileSync(join(base, ".git", "info", "exclude"), ".gsd/\n");
+    mkdirSync(join(base, ".gsd"), { recursive: true });
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Milestone One", status: "active" });
+    insertSlice({
+      id: "S01",
+      milestoneId: "M001",
+      title: "Slice One",
+      status: "complete",
+      risk: "low",
+      depends: [],
+    });
+    insertTask({
+      id: "T01",
+      sliceId: "S01",
+      milestoneId: "M001",
+      title: "Task One",
+      status: "complete",
+    });
+
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}\n");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync(
+      "git",
+      ["commit", "-m", "feat: add feature\n\nGSD-Task: S01/T01"],
+      { cwd: base, stdio: "ignore" },
+    );
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(
+      result,
+      "present",
+      "DB task ownership should bind S01/T01 implementation commits to M001 without explicit M001 text",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
+test("hasImplementationArtifacts does not bind GSD-Task trailer without milestone ownership evidence", () => {
+  const base = makeGitBase();
+  try {
+    writeFileSync(join(base, ".git", "info", "exclude"), ".gsd/\n");
+    mkdirSync(join(base, "src"), { recursive: true });
+    writeFileSync(join(base, "src", "feature.ts"), "export function feature() {}\n");
+    execFileSync("git", ["add", "."], { cwd: base, stdio: "ignore" });
+    execFileSync(
+      "git",
+      ["commit", "-m", "feat: add feature\n\nGSD-Task: S01/T01"],
+      { cwd: base, stdio: "ignore" },
+    );
+
+    const result = hasImplementationArtifacts(base, "M001");
+    assert.equal(
+      result,
+      "absent",
+      "S01/T01 shape alone must not bind an implementation commit to M001",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("hasImplementationArtifacts ignores malformed milestone IDs in commit-message fallback", () => {
   const base = makeGitBase();
   try {

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)");
+  });
+});