gsd-pi 2.77.0 → 2.78.0-dev.aeeb2ca00

package/src/resources/extensions/gsd/tests/orphaned-worktree-audit.test.ts

@@ -107,7 +107,8 @@ describe("auditOrphanedMilestoneBranches", () => {
     assert.ok(branches.includes("milestone/M001"), "unmerged branch must be preserved");
   });
 
-  test("skips active (non-complete) milestone branches", () => {
+  test("skips active milestone branch with no commits ahead of main (nothing to recover)", () => {
+    // Branch created from main with zero divergence — no live work, nothing to warn about.
     run("git branch milestone/M001", dir);
     insertMilestone({ id: "M001", title: "Test", status: "active" });
 
@@ -116,11 +117,67 @@ describe("auditOrphanedMilestoneBranches", () => {
     assert.deepStrictEqual(result.recovered, []);
     assert.deepStrictEqual(result.warnings, []);
 
-    // Branch should still exist
+    // Branch should still exist (data safety — user may intend to use it)
     const branches = run("git branch --list milestone/M001", dir);
     assert.ok(branches.includes("milestone/M001"), "active milestone branch should be preserved");
   });
 
+  test("#4762 — warns about in-progress milestone with unmerged commits ahead of main", () => {
+    // Simulates the primary #4761 scenario: auto-mode was interrupted mid-milestone.
+    // DB status = active/in_progress, branch has real work, main is behind.
+    run("git checkout -b milestone/M001", dir);
+    writeFileSync(join(dir, "feature.txt"), "in-progress work\n");
+    run("git add feature.txt", dir);
+    run("git commit -m \"in-progress work on M001\"", dir);
+    run("git checkout main", dir);
+
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    // Must NOT recover/delete (data safety — work is live)
+    assert.deepStrictEqual(result.recovered, [], "must not delete a branch with live in-progress work");
+
+    // Must surface a warning so the user knows the worktree holds uncollapsed work
+    assert.ok(result.warnings.length > 0, "should warn about in-progress orphan");
+    assert.ok(
+      result.warnings.some(w => w.includes("milestone/M001") && w.includes("in-progress")),
+      `warning should mention milestone/M001 and in-progress state; got: ${JSON.stringify(result.warnings)}`,
+    );
+
+    // Branch must still exist
+    const branches = run("git branch --list milestone/M001", dir);
+    assert.ok(branches.includes("milestone/M001"), "in-progress branch must be preserved");
+  });
+
+  test("#4762 — also surfaces worktree directory for in-progress orphan when present", () => {
+    // In-progress + unmerged + physical worktree directory — the full primary scenario.
+    run("git checkout -b milestone/M001", dir);
+    writeFileSync(join(dir, "feature.txt"), "in-progress work\n");
+    run("git add feature.txt", dir);
+    run("git commit -m \"in-progress work on M001\"", dir);
+    run("git checkout main", dir);
+
+    // Simulate a leftover worktree directory
+    const wtDir = join(dir, ".gsd", "worktrees", "M001");
+    mkdirSync(wtDir, { recursive: true });
+    writeFileSync(join(wtDir, ".git"), `gitdir: ${join(dir, ".git", "worktrees", "M001")}\n`);
+
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    const result = auditOrphanedMilestoneBranches(dir, "worktree");
+
+    // Must preserve everything for data safety
+    assert.deepStrictEqual(result.recovered, [], "must not touch worktree or branch with live work");
+    assert.ok(existsSync(wtDir), "worktree directory must be preserved");
+
+    // Warning should mention the worktree path so the user can find the work
+    assert.ok(
+      result.warnings.some(w => w.includes(".gsd/worktrees/M001") || w.includes("worktree")),
+      `warning should reference the worktree location; got: ${JSON.stringify(result.warnings)}`,
+    );
+  });
+
   test("cleans up orphaned worktree directory for merged milestone", () => {
     // Create milestone branch (merged — same as main)
     run("git branch milestone/M001", dir);

package/src/resources/extensions/gsd/tests/parallel-commit-scope.test.ts

@@ -45,6 +45,11 @@ function initTempRepo(): string {
   gitRun(["init", "-b", "main"], dir);
   gitRun(["config", "user.name", "Test"], dir);
   gitRun(["config", "user.email", "test@test.com"], dir);
+  // Disable commit/tag signing so the test is hermetic in environments where
+  // the user's global git config enables GPG/SSH signing (e.g. Claude Code
+  // sandboxes that proxy signing through an external service).
+  gitRun(["config", "commit.gpgsign", "false"], dir);
+  gitRun(["config", "tag.gpgsign", "false"], dir);
   createFile(dir, ".gitkeep", "");
   gitRun(["add", "-A"], dir);
   gitRun(["commit", "-m", "init"], dir);

package/src/resources/extensions/gsd/tests/parallel-research-dispatch.test.ts

@@ -1,165 +1,308 @@
 /**
- * Parallel research slices dispatch — structural tests.
+ * parallel-research-dispatch.test.ts — behaviour tests for the
+ * "planning (multiple slices need research) → parallel-research-slices"
+ * dispatch rule and its prompt builder.
  *
- * Verifies the dispatch rule and prompt builder exist with correct structure.
+ * These tests invoke the real functions (resolveDispatch,
+ * buildParallelResearchSlicesPrompt) against on-disk fixtures. They do
+ * not read source files and string-match identifiers.
+ *
+ * See #4784 for why the previous source-grep version of this file was
+ * replaced.
  */
 
-import test, { afterEach } from "node:test";
+import { describe, test, beforeEach, afterEach, after } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
 import { tmpdir } from "node:os";
-import { fileURLToPath } from "node:url";
 
-import { resolveDispatch } from "../auto-dispatch.ts";
+// Point GSD_HOME at a throwaway directory *before* the prompt-loader
+// module is imported (via the dynamic imports below) so templates
+// resolve from the in-tree prompts/ directory instead of a developer's
+// ~/.gsd/ copy (which may be a stale cached version from a prior
+// install — see #4784 fallout). Static imports above are hoisted, so
+// `tmpdir` and `join` are already available at this point; the dynamic
+// imports below observe the value we set here. The previous value is
+// captured and restored in an after() hook to avoid leaking module-scope
+// env mutation into other suites if the runner ever moves to a shared
+// process model.
+const previousGsdHome = process.env.GSD_HOME;
+process.env.GSD_HOME = process.env.GSD_HOME_TEST_OVERRIDE
+  ?? join(tmpdir(), `gsd-test-home-${process.pid}-${Date.now()}`);
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
+after(() => {
+  if (previousGsdHome === undefined) {
+    delete process.env.GSD_HOME;
+  } else {
+    process.env.GSD_HOME = previousGsdHome;
+  }
+});
 
-const dispatchSrc = readFileSync(join(__dirname, "..", "auto-dispatch.ts"), "utf-8");
-const promptsSrc = readFileSync(join(__dirname, "..", "auto-prompts.ts"), "utf-8");
-const templatePath = join(__dirname, "..", "prompts", "parallel-research-slices.md");
-const templateSrc = readFileSync(templatePath, "utf-8");
+const { resolveDispatch } = await import("../auto-dispatch.ts");
+const { buildParallelResearchSlicesPrompt } = await import("../auto-prompts.ts");
 
-const tmpDirs: string[] = [];
+type DispatchState = Parameters<typeof resolveDispatch>[0]["state"];
 
-function makeTmpProject(): string {
-  const base = mkdtempSync(join(tmpdir(), "parallel-research-"));
-  tmpDirs.push(base);
-  const milestoneDir = join(base, ".gsd", "milestones", "M001");
+function writeRoadmap(
+  base: string,
+  mid: string,
+  slices: Array<{ id: string; title: string; done?: boolean; depends?: string[] }>,
+): void {
+  const milestoneDir = join(base, ".gsd", "milestones", mid);
   mkdirSync(milestoneDir, { recursive: true });
+  const lines = [
+    `# ${mid}: Parallel Research Milestone`,
+    "",
+    "**Vision:** Research-ready slices.",
+    "",
+    "**Success Criteria:**",
+    "- Research all slices",
+    "",
+    "## Slices",
+    "",
+  ];
+  for (const s of slices) {
+    const box = s.done ? "x" : " ";
+    const deps = s.depends ? `depends:[${s.depends.join(",")}]` : "depends:[]";
+    lines.push(`- [${box}] **${s.id}: ${s.title}** \`risk:low\` \`${deps}\``);
+  }
+  lines.push("", "## Boundary Map", "");
   writeFileSync(
-    join(milestoneDir, "M001-ROADMAP.md"),
-    [
-      "# M001: Parallel Research Milestone",
-      "",
-      "**Vision:** Research-ready slices.",
-      "",
-      "**Success Criteria:**",
-      "- Research both slices",
-      "",
-      "## Slices",
-      "",
-      "- [ ] **S01: Alpha** `risk:low` `depends:[]`",
-      "- [ ] **S02: Beta** `risk:low` `depends:[]`",
-      "",
-      "## Boundary Map",
-      "",
-    ].join("\n"),
+    join(milestoneDir, `${mid}-ROADMAP.md`),
+    lines.join("\n"),
     "utf-8",
   );
-  return base;
 }
 
-afterEach(() => {
-  for (const dir of tmpDirs) {
-    try {
-      rmSync(dir, { recursive: true, force: true });
-    } catch {
-      // Best-effort cleanup only.
-    }
+function assertNotParallelResearchDispatch(
+  action: Awaited<ReturnType<typeof resolveDispatch>>,
+  mid = "M001",
+): void {
+  if (action.action === "dispatch") {
+    assert.notEqual(action.unitId, `${mid}/parallel-research`);
   }
-  tmpDirs.length = 0;
-});
+}
 
-// ─── Dispatch rule ────────────────────────────────────────────────────────
+function baseState(activeSliceId = "S01", activeSliceTitle = "Alpha"): DispatchState {
+  return {
+    phase: "planning",
+    activeMilestone: { id: "M001", title: "Parallel Research Milestone", status: "active" },
+    activeSlice: { id: activeSliceId, title: activeSliceTitle },
+    activeTask: null,
+    registry: [],
+    blockers: [],
+  } as unknown as DispatchState;
+}
 
-test("dispatch: parallel-research-slices rule exists", () => {
-  assert.ok(
-    dispatchSrc.includes("parallel-research-slices"),
-    "dispatch table should have parallel-research-slices rule",
-  );
-});
+describe("parallel-research-slices dispatch rule", () => {
+  let base: string;
 
-test("dispatch: parallel-research-slices requires 2+ slices", () => {
-  assert.ok(
-    dispatchSrc.includes("researchReadySlices.length < 2"),
-    "rule should require at least 2 slices for parallel dispatch",
-  );
-});
+  beforeEach(() => {
+    base = mkdtempSync(join(tmpdir(), "parallel-research-"));
+  });
 
-test("dispatch: parallel-research-slices respects skip_research", () => {
-  const ruleIdx = dispatchSrc.indexOf("parallel-research-slices");
-  const ruleBlock = dispatchSrc.slice(ruleIdx, ruleIdx + 500);
-  assert.ok(
-    ruleBlock.includes("skip_research") || dispatchSrc.slice(ruleIdx - 300, ruleIdx).includes("skip_research"),
-    "rule should check skip_research preference",
-  );
-});
+  afterEach(() => {
+    rmSync(base, { recursive: true, force: true });
+  });
 
-// ─── Prompt builder ───────────────────────────────────────────────────────
+  test("dispatches parallel research when 2+ slices need research", async () => {
+    writeRoadmap(base, "M001", [
+      { id: "S01", title: "Alpha" },
+      { id: "S02", title: "Beta" },
+    ]);
 
-test("prompt: buildParallelResearchSlicesPrompt exported", () => {
-  assert.ok(
-    promptsSrc.includes("export async function buildParallelResearchSlicesPrompt"),
-    "buildParallelResearchSlicesPrompt should be exported",
-  );
-});
+    const action = await resolveDispatch({
+      basePath: base,
+      mid: "M001",
+      midTitle: "Parallel Research Milestone",
+      state: baseState(),
+      prefs: undefined,
+    });
 
-test("prompt: builds per-slice subagent prompts", () => {
-  assert.ok(
-    promptsSrc.includes("buildResearchSlicePrompt"),
-    "parallel prompt builder should delegate to per-slice research prompts",
-  );
-});
+    assert.equal(action.action, "dispatch");
+    if (action.action === "dispatch") {
+      assert.equal(action.unitType, "research-slice");
+      assert.equal(action.unitId, "M001/parallel-research");
+    }
+  });
 
-// ─── Template ─────────────────────────────────────────────────────────────
+  test("does not dispatch parallel research with only one ready slice", async () => {
+    writeRoadmap(base, "M001", [{ id: "S01", title: "Alpha" }]);
 
-test("template: parallel-research-slices.md has required variables", () => {
-  assert.ok(templateSrc.includes("{{sliceCount}}"), "template should use sliceCount");
-  assert.ok(templateSrc.includes("{{mid}}"), "template should use mid");
-  assert.ok(templateSrc.includes("{{subagentPrompts}}"), "template should use subagentPrompts");
-});
+    const action = await resolveDispatch({
+      basePath: base,
+      mid: "M001",
+      midTitle: "Parallel Research Milestone",
+      state: baseState(),
+      prefs: undefined,
+    });
 
-test("#4068: template: parallel-research-slices retry cap prevents infinite subagent loop", () => {
-  // The template must cap retries at 1 ("retry it once") and instruct the
-  // agent to write a BLOCKER note on the second failure rather than looping.
-  // Without this, a timing-out subagent causes the orchestrating agent to
-  // retry indefinitely (issue #4068 / #4355).
-  assert.ok(
-    templateSrc.includes("once") || templateSrc.includes("one retry") || templateSrc.match(/retry.{0,20}once/),
-    "template should cap subagent retries at one",
-  );
-  assert.ok(
-    templateSrc.toLowerCase().includes("blocker"),
-    "template should instruct writing a BLOCKER note instead of infinite retries",
-  );
-  assert.ok(
-    !templateSrc.match(/re-run it individually\s*\n/),
-    "template must not have unbounded re-run instruction without a retry cap",
-  );
-});
+    assertNotParallelResearchDispatch(action);
+  });
 
-// ─── Validate milestone prompt ────────────────────────────────────────────
+  test("does not dispatch parallel research when skip_research is set", async () => {
+    writeRoadmap(base, "M001", [
+      { id: "S01", title: "Alpha" },
+      { id: "S02", title: "Beta" },
+    ]);
 
-test("template: validate-milestone uses parallel reviewers", () => {
-  const validateSrc = readFileSync(join(__dirname, "..", "prompts", "validate-milestone.md"), "utf-8");
-  assert.ok(
-    validateSrc.includes("Reviewer A") && validateSrc.includes("Reviewer B") && validateSrc.includes("Reviewer C"),
-    "validate-milestone should dispatch 3 parallel reviewers",
-  );
+    const action = await resolveDispatch({
+      basePath: base,
+      mid: "M001",
+      midTitle: "Parallel Research Milestone",
+      state: baseState(),
+      prefs: { phases: { skip_research: true } } as Parameters<typeof resolveDispatch>[0]["prefs"],
+    });
+
+    assertNotParallelResearchDispatch(action);
+  });
+
+  test("does not dispatch parallel research when skip_slice_research is set", async () => {
+    writeRoadmap(base, "M001", [
+      { id: "S01", title: "Alpha" },
+      { id: "S02", title: "Beta" },
+    ]);
+
+    const action = await resolveDispatch({
+      basePath: base,
+      mid: "M001",
+      midTitle: "Parallel Research Milestone",
+      state: baseState(),
+      prefs: { phases: { skip_slice_research: true } } as Parameters<typeof resolveDispatch>[0]["prefs"],
+    });
+
+    assertNotParallelResearchDispatch(action);
+  });
+
+  test("does not dispatch when a PARALLEL-BLOCKER placeholder exists (#4414)", async () => {
+    writeRoadmap(base, "M001", [
+      { id: "S01", title: "Alpha" },
+      { id: "S02", title: "Beta" },
+    ]);
+    const milestoneDir = join(base, ".gsd", "milestones", "M001");
+    writeFileSync(
+      join(milestoneDir, "M001-PARALLEL-BLOCKER.md"),
+      "# Parallel research escalated\nPrevious dispatch failed; need per-slice fallback.\n",
+      "utf-8",
+    );
+
+    const action = await resolveDispatch({
+      basePath: base,
+      mid: "M001",
+      midTitle: "Parallel Research Milestone",
+      state: baseState(),
+      prefs: undefined,
+    });
+
+    assertNotParallelResearchDispatch(action);
+  });
+
+  test("excludes slices that already have a RESEARCH file (falls back to <2)", async () => {
+    writeRoadmap(base, "M001", [
+      { id: "S01", title: "Alpha" },
+      { id: "S02", title: "Beta" },
+    ]);
+    // S01 already has research → only S02 remains → <2 ready → no parallel dispatch
+    const s01Dir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    mkdirSync(s01Dir, { recursive: true });
+    writeFileSync(
+      join(s01Dir, "S01-RESEARCH.md"),
+      "# Research\n",
+      "utf-8",
+    );
+
+    const action = await resolveDispatch({
+      basePath: base,
+      mid: "M001",
+      midTitle: "Parallel Research Milestone",
+      state: baseState(),
+      prefs: undefined,
+    });
+
+    assertNotParallelResearchDispatch(action);
+  });
 });
 
-test("resolveDispatch prefers parallel research when multiple slices are ready", async () => {
-  const base = makeTmpProject();
-
-  const action = await resolveDispatch({
-    basePath: base,
-    mid: "M001",
-    midTitle: "Parallel Research Milestone",
-    state: {
-      phase: "planning",
-      activeMilestone: { id: "M001", title: "Parallel Research Milestone", status: "active" },
-      activeSlice: { id: "S01", title: "Alpha" },
-      activeTask: null,
-      registry: [],
-      blockers: [],
-    } as any,
-    prefs: undefined,
+describe("buildParallelResearchSlicesPrompt", () => {
+  let base: string;
+
+  beforeEach(() => {
+    base = mkdtempSync(join(tmpdir(), "parallel-research-prompt-"));
+    mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
   });
 
-  assert.equal(action.action, "dispatch");
-  if (action.action === "dispatch") {
-    assert.equal(action.unitType, "research-slice");
-    assert.equal(action.unitId, "M001/parallel-research");
-  }
+  afterEach(() => {
+    rmSync(base, { recursive: true, force: true });
+  });
+
+  test("renders slice count and every slice title into the prompt", async () => {
+    const prompt = await buildParallelResearchSlicesPrompt(
+      "M001",
+      "Parallel Research Milestone",
+      [
+        { id: "S01", title: "Alpha slice title" },
+        { id: "S02", title: "Beta slice title" },
+        { id: "S03", title: "Gamma slice title" },
+      ],
+      base,
+    );
+
+    assert.match(
+      prompt,
+      /\b3\b[^.\n]{0,40}\bslices?\b/i,
+      "prompt should include slice count 3 in slice context",
+    );
+    assert.match(prompt, /Alpha slice title/);
+    assert.match(prompt, /Beta slice title/);
+    assert.match(prompt, /Gamma slice title/);
+  });
+
+  test("#4068: prompt caps subagent retries at one and instructs writing a BLOCKER on second failure", async () => {
+    // Regression for infinite-retry loop (#4068 / #4355 / #4570). A correct
+    // fix must both cap retries AND instruct the agent to escalate to a
+    // BLOCKER note on the second failure.
+    const prompt = await buildParallelResearchSlicesPrompt(
+      "M001",
+      "Parallel Research Milestone",
+      [
+        { id: "S01", title: "Alpha" },
+        { id: "S02", title: "Beta" },
+      ],
+      base,
+    );
+
+    // Cap: the rendered prompt must bound retries. "once" alone is too
+    // permissive — the word appears for unrelated reasons across a ~10KB
+    // rendered prompt — so the pattern must require retry-context
+    // pairing: either "retry ... once" within 30 chars, or the phrase
+    // "one retry", or "retry it once".
+    assert.match(
+      prompt,
+      /\bone retry\b|retry[^.?!]{0,30}\bonce\b|retry it \*{0,2}once/i,
+      "rendered prompt should cap retries to one",
+    );
+
+    // Escalation: on second failure the agent must write a BLOCKER
+    // rather than loop. Bare /blocker/i is too permissive — require
+    // retry/failure context within the same sentence so a stray
+    // "blocker" elsewhere in the ~10KB prompt cannot satisfy the
+    // assertion.
+    assert.match(
+      prompt,
+      /blocker[^.?!]{0,100}(second|retry|fail)|(second|retry|fail)[^.?!]{0,100}blocker/i,
+      "rendered prompt should instruct writing a BLOCKER on repeated failure",
+    );
+
+    // Anti-pattern: the unbounded "re-run it individually" instruction
+    // that caused the original infinite loop must not appear on its own.
+    // The negative lookahead is bounded to the surrounding 100
+    // characters so a later unrelated "once" elsewhere in the prompt
+    // cannot falsely satisfy the "paired with a retry bound" exception.
+    assert.doesNotMatch(
+      prompt,
+      /re-run it individually(?![\s\S]{0,100}\bonce\b)/i,
+      "rendered prompt must not contain the unbounded re-run instruction",
+    );
+  });
 });