gsd-pi 2.78.0-dev.aeeb2ca00 → 2.78.1-dev.84a383f51

package/src/resources/extensions/gsd/tests/discuss-queued-milestones.test.ts

@@ -16,11 +16,9 @@
 
 import { describe, test, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
-import { dirname } from "node:path";
 
 import { deriveState } from "../state.ts";
 import { invalidateAllCaches } from "../cache.ts";
@@ -57,12 +55,6 @@ function writeRoadmap(base: string, mid: string, content: string): void {
   writeFileSync(join(base, ".gsd", "milestones", mid, `${mid}-ROADMAP.md`), content);
 }
 
-function readGuidedFlowSource(): string {
-  const thisFile = fileURLToPath(import.meta.url);
-  const thisDir = dirname(thisFile);
-  return readFileSync(join(thisDir, "..", "guided-flow.ts"), "utf-8");
-}
-
 // ─── Tests ────────────────────────────────────────────────────────────────────
 
 describe("discuss-queued-milestones (#2307)", () => {
@@ -169,113 +161,10 @@ describe("discuss-queued-milestones (#2307)", () => {
     }
   });
 
-  test("6. guided-flow no longer hard-exits when no active milestone but pending exist", () => {
-    const source = readGuidedFlowSource();
-
-    // The old guard was a simple early-exit:
-    //   if (!state.activeMilestone) {
-    //     ctx.ui.notify("No active milestone. Run /gsd to create one first.", "warning");
-    //     return;
-    //   }
-    //
-    // The new guard should check for pending milestones and route instead.
-    const oldGuardPattern = /if\s*\(!state\.activeMilestone\)\s*\{\s*ctx\.ui\.notify\("No active milestone/;
-    assert.ok(
-      !oldGuardPattern.test(source),
-      "guided-flow must not unconditionally exit when activeMilestone is null",
-    );
-  });
-
-  test("7. showDiscussQueuedMilestone helper exists in guided-flow", () => {
-    const source = readGuidedFlowSource();
-    assert.ok(
-      source.includes("showDiscussQueuedMilestone"),
-      "guided-flow must export showDiscussQueuedMilestone helper",
-    );
-  });
-
-  test("8. dispatchDiscussForMilestone helper exists in guided-flow", () => {
-    const source = readGuidedFlowSource();
-    assert.ok(
-      source.includes("dispatchDiscussForMilestone"),
-      "guided-flow must export dispatchDiscussForMilestone helper",
-    );
-  });
-
-  test("9. dispatchDiscussForMilestone does not set pendingAutoStart", () => {
-    const source = readGuidedFlowSource();
-
-    // Extract the dispatchDiscussForMilestone function body
-    const fnMatch = source.match(
-      /async function dispatchDiscussForMilestone\s*\([^)]*\)[^{]*\{([\s\S]*?)\n\}/,
-    );
-    assert.ok(!!fnMatch, "dispatchDiscussForMilestone function body must be present");
-
-    if (fnMatch) {
-      assert.ok(
-        !fnMatch[1].includes("pendingAutoStart"),
-        "dispatchDiscussForMilestone must NOT set pendingAutoStart — discussing a queued milestone must not activate it",
-      );
-    }
-  });
-
-  test("10. slice picker includes queued milestone option when pending milestones exist", () => {
-    const source = readGuidedFlowSource();
-    assert.ok(
-      source.includes("discuss_queued_milestone"),
-      "slice picker must include a 'discuss_queued_milestone' action id for queued milestones",
-    );
-    assert.ok(
-      source.includes("Discuss a queued milestone"),
-      "slice picker must label the queued milestone action clearly",
-    );
-  });
-
-  test("11. queued milestone picker labels entries with [queued]", () => {
-    const source = readGuidedFlowSource();
-    assert.ok(
-      source.includes("[queued]"),
-      "queued milestone picker must label entries with [queued] to distinguish from active",
-    );
-  });
-
-  // ─── #3150: allDiscussed early-return must not block queued milestone discussion ──
-
-  test("12. allDiscussed path checks for pending milestones before returning (#3150)", () => {
-    const source = readGuidedFlowSource();
-
-    // Extract the allDiscussed block — the if (allDiscussed) { ... } body
-    const allDiscussedMatch = source.match(
-      /const allDiscussed = pendingSlices\.every\([\s\S]*?\n    if \(allDiscussed\) \{([\s\S]*?)\n    \}/,
-    );
-    assert.ok(!!allDiscussedMatch, "allDiscussed guard block must exist in showDiscuss()");
-
-    if (allDiscussedMatch) {
-      const body = allDiscussedMatch[1];
-      // The fix must check for pending milestones and route to showDiscussQueuedMilestone
-      assert.ok(
-        body.includes("pending") && body.includes("showDiscussQueuedMilestone"),
-        "allDiscussed block must check for pending milestones and call showDiscussQueuedMilestone before returning (#3150)",
-      );
-    }
-  });
-
-  test("13. pendingSlices.length===0 path checks for pending milestones before returning (#3150)", () => {
-    const source = readGuidedFlowSource();
-
-    // Find the pendingSlices.length === 0 guard block
-    const zeroSlicesMatch = source.match(
-      /if \(pendingSlices\.length === 0\) \{([\s\S]*?)\n  \}/,
-    );
-    assert.ok(!!zeroSlicesMatch, "pendingSlices.length === 0 guard block must exist in showDiscuss()");
-
-    if (zeroSlicesMatch) {
-      const body = zeroSlicesMatch[1];
-      // The fix must check for pending milestones and route to showDiscussQueuedMilestone
-      assert.ok(
-        body.includes("pending") && body.includes("showDiscussQueuedMilestone"),
-        "pendingSlices.length===0 block must check for pending milestones and call showDiscussQueuedMilestone before returning (#3150)",
-      );
-    }
-  });
+  // The earlier tests 6-13 source-grepped guided-flow.ts for identifier
+  // names (showDiscussQueuedMilestone, dispatchDiscussForMilestone),
+  // UI-copy strings ("[queued]", "Discuss a queued milestone"), and
+  // regex-on-function-body assertions for the #3150 routing — all
+  // structural rather than behavioural (Refs #4826). They were dropped
+  // when this file was tightened against handler-level assertions.
 });

package/src/resources/extensions/gsd/tests/discuss-tool-scope-leak.test.ts

@@ -1,77 +1,35 @@
-// GSD-2 — Regression test for #3616: discuss tool scoping must not leak into subsequent sessions
-// Copyright (c) 2026 Jeremy McSpadden <jeremy@fluxlabs.net>
-
-/**
- * Bug #3616: After a discuss session narrows the active tool set via
- * setActiveTools(), the narrowed list persisted into the next auto-mode
- * session because newSession() did not restore extension tools when cwd
- * was unchanged. This caused gsd_plan_slice and other DB tools to be
- * missing from plan-slice subagent sessions.
- *
- * This test verifies the structural properties that prevent the leak:
- *   1. guided-flow.ts narrows tools ONLY for discuss-* unit types
- *   2. The narrowed set explicitly excludes gsd_plan_slice (a HEAVY_TOOL)
- *   3. agent-session.ts:newSession() has an else-branch that restores
- *      all extension tools even when cwd hasn't changed
- */
+// GSD-2 — Behavioural regression test for #3616.
+//
+// Bug: After a discuss session narrows the active tool set via setActiveTools,
+// the narrowed list persisted into the next auto-mode session because newSession()
+// did not restore extension tools when cwd was unchanged. This caused
+// gsd_plan_slice and other DB tools to be missing from plan-slice subagent
+// sessions.
+//
+// The behavioural invariant we can pin without grepping source: gsd_plan_slice
+// (a heavy planning tool) is NOT inside the discuss allowlist. The remaining
+// guarantees (newSession including all extension tools in both branches) are
+// covered by agent-session.test.ts inside packages/pi-coding-agent.
+//
+// Refs #4826 (rewrite from source-grep on guided-flow.ts / agent-session.ts).
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 
 import { DISCUSS_TOOLS_ALLOWLIST } from "../constants.ts";
-import { extractSourceRegion } from "./test-helpers.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const guidedFlowSource = readFileSync(join(__dirname, "..", "guided-flow.ts"), "utf-8");
 
 describe("#3616 — discuss tool scoping must not leak across sessions", () => {
 	test("gsd_plan_slice is NOT in DISCUSS_TOOLS_ALLOWLIST", () => {
 		assert.ok(
 			!DISCUSS_TOOLS_ALLOWLIST.includes("gsd_plan_slice"),
-			"gsd_plan_slice should be excluded from discuss scope (it's a heavy planning tool)",
-		);
-	});
-
-	test("tool scoping only activates for discuss-* unit types", () => {
-		// The guard must be: if (unitType?.startsWith("discuss-"))
-		assert.ok(
-			guidedFlowSource.includes('unitType?.startsWith("discuss-")'),
-			"tool scoping should only trigger for discuss-* unit types",
+			`gsd_plan_slice (a heavy planning tool) must be excluded from the discuss scope; allowlist=${JSON.stringify(DISCUSS_TOOLS_ALLOWLIST)}`,
 		);
 	});
 
-	test("discuss tool scoping uses setActiveTools (not setTools) for reversibility", () => {
-		// setActiveTools changes the active subset but doesn't remove tools from
-		// the registry. newSession()'s _refreshToolRegistry can restore them.
-		assert.ok(
-			guidedFlowSource.includes("pi.setActiveTools(scopedTools)"),
-			"should use pi.setActiveTools to narrow tools (preserving registry)",
-		);
-	});
-
-	test("newSession() in agent-session.ts has defense against tool narrowing persistence", () => {
-		const agentSessionSource = readFileSync(
-			join(process.cwd(), "packages/pi-coding-agent/src/core/agent-session.ts"),
-			"utf-8",
-		);
-		const newSessionStart = agentSessionSource.indexOf("async newSession(options?:");
-		assert.ok(newSessionStart >= 0, "should find newSession");
-		const body = extractSourceRegion(agentSessionSource, "async newSession(options?:");
-
-		// Both branches (cwd-changed and cwd-unchanged) must include extension tools
-		assert.ok(
-			body.includes("includeAllExtensionTools: true"),
-			"newSession() must include all extension tools in both branches",
-		);
-
-		// Count occurrences — should be at least 2 (one per branch)
-		const matches = body.match(/includeAllExtensionTools:\s*true/g);
+	test("DISCUSS_TOOLS_ALLOWLIST is non-empty (sanity)", () => {
 		assert.ok(
-			matches && matches.length >= 2,
-			`expected >=2 includeAllExtensionTools:true in newSession(), got ${matches?.length ?? 0}`,
+			DISCUSS_TOOLS_ALLOWLIST.length > 0,
+			"discuss scope should include at least one tool — empty allowlist would break /gsd discuss",
 		);
 	});
 });

package/src/resources/extensions/gsd/tests/doctor-orphan-milestone-4996.test.ts

@@ -0,0 +1,100 @@
+// GSD Extension — Regression test for #4996: doctor orphan milestone dir check
+// Verifies that checkRuntimeHealth reports orphan_milestone_dir for empty stub
+// dirs with no DB row, does not report populated dirs, and does not report
+// legitimate in-flight worktree-only milestone dirs.
+
+import { describe, it, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { checkRuntimeHealth } from "../doctor-runtime-checks.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+} from "../gsd-db.ts";
+import { invalidateAllCaches } from "../cache.ts";
+import type { DoctorIssue, DoctorIssueCode } from "../doctor-types.ts";
+
+function makeBase(prefix = "gsd-doctor-orphan-"): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function stubDir(base: string, mid: string): void {
+  mkdirSync(join(base, ".gsd", "milestones", mid, "slices"), { recursive: true });
+}
+
+function populateDir(base: string, mid: string): void {
+  mkdirSync(join(base, ".gsd", "milestones", mid), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", mid, `${mid}-CONTEXT.md`), `# ${mid}\n`);
+}
+
+describe("gsd_doctor orphan milestone directory check (#4996)", () => {
+  let base: string;
+
+  afterEach(() => {
+    try { closeDatabase(); } catch { /* ignore */ }
+    try { invalidateAllCaches(); } catch { /* ignore */ }
+    try { rmSync(base, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it("(a) empty stub dir with no DB row is reported as orphan_milestone_dir", async () => {
+    base = makeBase();
+    stubDir(base, "M003");
+
+    const issues: DoctorIssue[] = [];
+    const fixes: string[] = [];
+    await checkRuntimeHealth(base, issues, fixes, () => false);
+
+    const orphan = issues.find(i => i.code === "orphan_milestone_dir" && i.unitId === "M003");
+    assert.ok(orphan, "should report orphan_milestone_dir for empty stub");
+    assert.equal(orphan?.severity, "warning");
+    assert.equal(orphan?.fixable, true);
+    assert.ok(orphan?.message.includes("M003"), "message should name the milestone");
+  });
+
+  it("(b) populated milestone dir is NOT reported", async () => {
+    base = makeBase();
+    populateDir(base, "M001");
+
+    const issues: DoctorIssue[] = [];
+    const fixes: string[] = [];
+    await checkRuntimeHealth(base, issues, fixes, () => false);
+
+    const orphan = issues.find(i => i.code === "orphan_milestone_dir" && i.unitId === "M001");
+    assert.ok(!orphan, "populated milestone dir must not be reported as orphan");
+  });
+
+  it("(c) worktree-only milestone (no content files, no DB row, but worktree exists) is NOT reported", async () => {
+    base = makeBase();
+    stubDir(base, "M003");
+    // Simulate a legitimate in-flight worktree
+    mkdirSync(join(base, ".gsd", "worktrees", "M003"), { recursive: true });
+
+    const issues: DoctorIssue[] = [];
+    const fixes: string[] = [];
+    await checkRuntimeHealth(base, issues, fixes, () => false);
+
+    const orphan = issues.find(i => i.code === "orphan_milestone_dir" && i.unitId === "M003");
+    assert.ok(!orphan, "milestone with a worktree must not be reported as orphan");
+  });
+
+  it("(d) queued DB row (in-flight ID) is NOT reported as orphan", async () => {
+    base = makeBase();
+    stubDir(base, "M003");
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M003", status: "queued" });
+
+    const issues: DoctorIssue[] = [];
+    const fixes: string[] = [];
+    await checkRuntimeHealth(base, issues, fixes, () => false);
+
+    const orphan = issues.find(i => i.code === "orphan_milestone_dir" && i.unitId === "M003");
+    assert.ok(!orphan, "queued DB row must block orphan report (in-flight race protection)");
+  });
+});

package/src/resources/extensions/gsd/tests/double-merge-guard.test.ts

@@ -1,82 +1,20 @@
+/**
+ * Behavioural regression test for #2645 — double mergeAndExit guard.
+ *
+ * AutoSession.milestoneMergedInPhases is the producer-side flag set by the
+ * "complete" / "all-milestones-complete" branches in phases.ts after they
+ * call mergeAndExit. stopAuto reads it to skip the redundant Step-4 merge
+ * (which previously failed because the branch was already deleted).
+ *
+ * Refs #4829 (rewrite from positional source-grep on phases.ts/auto.ts).
+ */
+
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
 import { AutoSession } from "../auto/session.ts";
-import { extractSourceRegion } from "./test-helpers.ts";
-
-const __dirname = dirname(fileURLToPath(import.meta.url));
-
-describe("double mergeAndExit guard (#2645)", () => {
-  test("phases.ts sets milestoneMergedInPhases after mergeAndExit in milestone-complete path", () => {
-    // Source audit: the "complete" phase path must set the guard flag
-    // after calling mergeAndExit so that stopAuto skips the second merge.
-    const phasesSrc = readFileSync(
-      join(__dirname, "..", "auto", "phases.ts"),
-      "utf-8",
-    );
-
-    // Find the "complete" phase block
-    const completeIdx = phasesSrc.indexOf('state.phase === "complete"');
-    assert.ok(completeIdx > 0, "phases.ts should have a 'complete' phase check");
-
-    const afterComplete = extractSourceRegion(phasesSrc, 'state.phase === "complete"');
-    const mergeIdx = afterComplete.indexOf("deps.resolver.mergeAndExit");
-    const flagIdx = afterComplete.indexOf("s.milestoneMergedInPhases = true");
-
-    assert.ok(mergeIdx > 0, "complete path should call mergeAndExit");
-    assert.ok(flagIdx > 0, "complete path should set milestoneMergedInPhases");
-    assert.ok(
-      flagIdx > mergeIdx,
-      "milestoneMergedInPhases must be set AFTER mergeAndExit (not before)",
-    );
-  });
-
-  test("phases.ts sets milestoneMergedInPhases after mergeAndExit in all-milestones-complete path", () => {
-    const phasesSrc = readFileSync(
-      join(__dirname, "..", "auto", "phases.ts"),
-      "utf-8",
-    );
-
-    // The "all milestones complete" block checks incomplete.length === 0
-    const allCompleteIdx = phasesSrc.indexOf("incomplete.length === 0");
-    assert.ok(allCompleteIdx > 0, "phases.ts should have an all-milestones-complete check");
-
-    const afterAllComplete = extractSourceRegion(phasesSrc, "incomplete.length === 0");
-    const mergeIdx = afterAllComplete.indexOf("deps.resolver.mergeAndExit");
-    const flagIdx = afterAllComplete.indexOf("s.milestoneMergedInPhases = true");
-
-    assert.ok(mergeIdx > 0, "all-complete path should call mergeAndExit");
-    assert.ok(flagIdx > 0, "all-complete path should set milestoneMergedInPhases");
-    assert.ok(
-      flagIdx > mergeIdx,
-      "milestoneMergedInPhases must be set AFTER mergeAndExit (not before)",
-    );
-  });
-
-  test("stopAuto checks milestoneMergedInPhases before calling mergeAndExit", () => {
-    const autoSrc = readFileSync(
-      join(__dirname, "..", "auto.ts"),
-      "utf-8",
-    );
-
-    // The Step 4 worktree exit block must check the guard flag
-    const step4Idx = autoSrc.indexOf("Step 4: Auto-worktree exit");
-    assert.ok(step4Idx > 0, "auto.ts should have Step 4 worktree exit");
-
-    const step4Block = extractSourceRegion(autoSrc, "Step 4: Auto-worktree exit");
-    assert.ok(
-      step4Block.includes("milestoneMergedInPhases"),
-      "stopAuto Step 4 must check milestoneMergedInPhases before merging",
-    );
-    assert.ok(
-      step4Block.includes("!s.milestoneMergedInPhases"),
-      "stopAuto should skip merge when milestoneMergedInPhases is true",
-    );
-  });
 
-  test("AutoSession.milestoneMergedInPhases defaults to false", () => {
+describe("AutoSession.milestoneMergedInPhases (#2645)", () => {
+  test("defaults to false on a fresh session", () => {
     const session = new AutoSession();
     assert.equal(
       session.milestoneMergedInPhases,
@@ -85,7 +23,7 @@ describe("double mergeAndExit guard (#2645)", () => {
     );
   });
 
-  test("AutoSession.reset() clears milestoneMergedInPhases", () => {
+  test("reset() clears the flag back to false", () => {
     const session = new AutoSession();
     session.milestoneMergedInPhases = true;
     session.reset();

package/src/resources/extensions/gsd/tests/ensure-preconditions-guard-4996.test.ts

@@ -0,0 +1,93 @@
+// GSD Extension — Regression test for #4996: ensurePreconditions phantom dir guard
+// Verifies that ensurePreconditions does not create milestone directories for
+// forward-referenced slice unit IDs when the milestone has no DB row.
+
+import { describe, it, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { ensurePreconditions } from "../auto.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+} from "../gsd-db.ts";
+
+import type { GSDState } from "../types.ts";
+
+function makeBase(prefix = "gsd-precond-"): string {
+  const base = mkdtempSync(join(tmpdir(), prefix));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function makeMinimalState(): GSDState {
+  return {
+    activeMilestone: null,
+    activeSlice: null,
+    activeTask: null,
+    phase: "planning",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry: [],
+  };
+}
+
+describe("ensurePreconditions phantom-dir guard (#4996)", () => {
+  let base: string;
+
+  afterEach(() => {
+    try { closeDatabase(); } catch { /* ignore */ }
+    try { rmSync(base, { recursive: true, force: true }); } catch { /* ignore */ }
+  });
+
+  it("(a) slice unit ID for unknown milestone does NOT create dirs when no DB row exists", () => {
+    base = makeBase();
+    const state = makeMinimalState();
+
+    ensurePreconditions("execute-task", "M003/S01", base, state);
+
+    const milestoneDir = join(base, ".gsd", "milestones", "M003");
+    assert.ok(!existsSync(milestoneDir), "M003 dir must not be created for phantom slice dispatch");
+  });
+
+  it("(b) slice unit ID for milestone with DB row DOES create dirs", () => {
+    base = makeBase();
+    const dbPath = join(base, ".gsd", "gsd.db");
+    openDatabase(dbPath);
+    insertMilestone({ id: "M003", status: "active" });
+    const state = makeMinimalState();
+
+    ensurePreconditions("execute-task", "M003/S01", base, state);
+
+    const milestoneDir = join(base, ".gsd", "milestones", "M003");
+    assert.ok(existsSync(milestoneDir), "M003 dir must be created when DB row exists");
+  });
+
+  it("(c) slice unit ID for existing milestone dir with CONTEXT.md content file uses normal scaffolding", () => {
+    base = makeBase();
+    const mid = "M003";
+    const milestoneDir = join(base, ".gsd", "milestones", mid);
+    mkdirSync(milestoneDir, { recursive: true });
+    writeFileSync(join(milestoneDir, `${mid}-CONTEXT.md`), "# Context\n");
+    const state = makeMinimalState();
+
+    ensurePreconditions("execute-task", "M003/S01", base, state);
+
+    const slicesDir = join(milestoneDir, "slices");
+    assert.ok(existsSync(slicesDir), "existing milestone dir should allow slice scaffolding");
+  });
+
+  it("(d) milestone-only unit ID (no slice) still creates dir even with no DB row", () => {
+    base = makeBase();
+    const state = makeMinimalState();
+
+    ensurePreconditions("discuss-milestone", "M003", base, state);
+
+    const milestoneDir = join(base, ".gsd", "milestones", "M003");
+    assert.ok(existsSync(milestoneDir), "M003 dir must be created for milestone-only dispatch");
+  });
+});