gsd-pi 2.57.0 → 2.58.0-dev.778d6ac

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

@@ -0,0 +1,159 @@
+/**
+ * parallel-commit-scope.test.ts — Regression test for #1991.
+ *
+ * Parallel workers must only commit files belonging to their locked milestone.
+ * When GSD_MILESTONE_LOCK is set, smartStage() must exclude .gsd/milestones/<M>/
+ * directories for milestones other than the locked one.
+ *
+ * Without the fix, a worker for M033 can stage and commit fabricated artifacts
+ * under .gsd/milestones/M032/, causing cross-milestone pollution.
+ */
+
+import { describe, test, beforeEach, 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 { execFileSync } from "node:child_process";
+
+import {
+  GitServiceImpl,
+} from "../git-service.ts";
+
+function run(command: string, cwd: string): string {
+  const [cmd, ...args] = command.split(" ");
+  return execFileSync(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function gitRun(args: string[], cwd: string): string {
+  return execFileSync("git", args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+function createFile(base: string, relPath: string, content: string): void {
+  const full = join(base, relPath);
+  mkdirSync(join(full, ".."), { recursive: true });
+  writeFileSync(full, content, "utf-8");
+}
+
+function initTempRepo(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-parallel-scope-"));
+  gitRun(["init", "-b", "main"], dir);
+  gitRun(["config", "user.name", "Test"], dir);
+  gitRun(["config", "user.email", "test@test.com"], dir);
+  createFile(dir, ".gitkeep", "");
+  gitRun(["add", "-A"], dir);
+  gitRun(["commit", "-m", "init"], dir);
+  return dir;
+}
+
+describe("parallel commit scope (#1991)", () => {
+  const savedEnv: Record<string, string | undefined> = {};
+
+  beforeEach(() => {
+    savedEnv.GSD_MILESTONE_LOCK = process.env.GSD_MILESTONE_LOCK;
+    savedEnv.GSD_PARALLEL_WORKER = process.env.GSD_PARALLEL_WORKER;
+  });
+
+  afterEach(() => {
+    for (const key of ["GSD_MILESTONE_LOCK", "GSD_PARALLEL_WORKER"] as const) {
+      if (savedEnv[key] === undefined) {
+        delete process.env[key];
+      } else {
+        process.env[key] = savedEnv[key];
+      }
+    }
+  });
+
+  test("autoCommit excludes other milestone directories when GSD_MILESTONE_LOCK is set", () => {
+    const repo = initTempRepo();
+
+    // Set up parallel worker environment for M033
+    process.env.GSD_MILESTONE_LOCK = "M033";
+    process.env.GSD_PARALLEL_WORKER = "1";
+
+    // Create dirty files in BOTH milestones (simulates cross-milestone pollution)
+    createFile(repo, ".gsd/milestones/M032/M032-SUMMARY.md", "# M032 Summary\nFabricated by M033 worker");
+    createFile(repo, ".gsd/milestones/M032/M032-VALIDATION.md", "# M032 Validation\nFabricated");
+    createFile(repo, ".gsd/milestones/M032/slices/S01/S01-SUMMARY.md", "Fabricated S01 summary");
+    createFile(repo, ".gsd/milestones/M033/slices/S01/tasks/T01-SUMMARY.md", "Legit T01 summary");
+    createFile(repo, "src/feature.ts", "export const x = 1;");
+
+    const svc = new GitServiceImpl(repo);
+    const msg = svc.autoCommit("complete-milestone", "M033/complete");
+    assert.ok(msg !== null, "autoCommit should produce a commit");
+
+    const committed = gitRun(["show", "--name-only", "HEAD"], repo);
+
+    // Source files and own milestone files SHOULD be committed
+    assert.ok(committed.includes("src/feature.ts"), "source files are committed");
+    assert.ok(committed.includes(".gsd/milestones/M033/"), "own milestone files are committed");
+
+    // Other milestone files MUST NOT be committed
+    assert.ok(!committed.includes(".gsd/milestones/M032/"),
+      "M032 files must NOT be committed by M033 worker — cross-milestone pollution (#1991)");
+
+    // Verify M032 files are still dirty (unstaged) in the working tree
+    const status = gitRun(["status", "--porcelain"], repo);
+    assert.ok(status.includes("M032"), "M032 files remain as untracked/dirty in working tree");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test("autoCommit stages all milestones when GSD_MILESTONE_LOCK is NOT set (solo mode)", () => {
+    const repo = initTempRepo();
+
+    // No milestone lock — solo worker mode
+    delete process.env.GSD_MILESTONE_LOCK;
+    delete process.env.GSD_PARALLEL_WORKER;
+
+    createFile(repo, ".gsd/milestones/M032/M032-SUMMARY.md", "# M032 Summary");
+    createFile(repo, ".gsd/milestones/M033/slices/S01/tasks/T01-SUMMARY.md", "T01 summary");
+    createFile(repo, "src/feature.ts", "export const x = 1;");
+
+    const svc = new GitServiceImpl(repo);
+    const msg = svc.autoCommit("complete-milestone", "M032/complete");
+    assert.ok(msg !== null, "autoCommit should produce a commit");
+
+    const committed = gitRun(["show", "--name-only", "HEAD"], repo);
+
+    // In solo mode, ALL milestone files should be committed
+    assert.ok(committed.includes(".gsd/milestones/M032/"), "M032 files committed in solo mode");
+    assert.ok(committed.includes(".gsd/milestones/M033/"), "M033 files committed in solo mode");
+    assert.ok(committed.includes("src/feature.ts"), "source files committed in solo mode");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test("autoCommit scopes to locked milestone even with multiple foreign milestones", () => {
+    const repo = initTempRepo();
+
+    process.env.GSD_MILESTONE_LOCK = "M035";
+    process.env.GSD_PARALLEL_WORKER = "1";
+
+    // Create files across many milestones
+    createFile(repo, ".gsd/milestones/M032/M032-SUMMARY.md", "foreign");
+    createFile(repo, ".gsd/milestones/M033/M033-SUMMARY.md", "foreign");
+    createFile(repo, ".gsd/milestones/M034/M034-SUMMARY.md", "foreign");
+    createFile(repo, ".gsd/milestones/M035/slices/S01/tasks/T01-SUMMARY.md", "own work");
+    createFile(repo, "src/app.ts", "export const app = {};");
+
+    const svc = new GitServiceImpl(repo);
+    const msg = svc.autoCommit("execute-task", "M035/S01/T01");
+    assert.ok(msg !== null, "autoCommit should produce a commit");
+
+    const committed = gitRun(["show", "--name-only", "HEAD"], repo);
+
+    assert.ok(committed.includes(".gsd/milestones/M035/"), "own milestone committed");
+    assert.ok(committed.includes("src/app.ts"), "source files committed");
+    assert.ok(!committed.includes(".gsd/milestones/M032/"), "M032 excluded");
+    assert.ok(!committed.includes(".gsd/milestones/M033/"), "M033 excluded");
+    assert.ok(!committed.includes(".gsd/milestones/M034/"), "M034 excluded");
+
+    rmSync(repo, { recursive: true, force: true });
+  });
+});

package/src/resources/extensions/gsd/tests/parallel-eligibility-ghost.test.ts

@@ -0,0 +1,150 @@
+/**
+ * Tests for parallel eligibility edge cases:
+ * - Ghost milestones (no registry entry) must NOT appear eligible (#2501 Bug 2)
+ * - Milestones with failed worktree merge (SUMMARY only in worktree, DB still
+ *   "active") must NOT appear eligible (#2501 Bug 1 context)
+ */
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { analyzeParallelEligibility } from "../parallel-eligibility.ts";
+import { invalidateStateCache } from "../state.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  updateMilestoneStatus,
+} from "../gsd-db.ts";
+
+// ─── Fixture Helpers ───────────────────────────────────────────────────────
+
+function createFixtureBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-parallel-elig-"));
+  mkdirSync(join(base, ".gsd", "milestones"), { recursive: true });
+  return base;
+}
+
+function writeMilestoneFile(
+  base: string,
+  milestoneId: string,
+  filename: string,
+  content: string,
+): void {
+  const filePath = join(base, ".gsd", "milestones", milestoneId, filename);
+  mkdirSync(join(filePath, ".."), { recursive: true });
+  writeFileSync(filePath, content);
+}
+
+function makeMilestoneDir(base: string, milestoneId: string): void {
+  mkdirSync(join(base, ".gsd", "milestones", milestoneId), { recursive: true });
+}
+
+function cleanup(base: string): void {
+  rmSync(base, { recursive: true, force: true });
+}
+
+// ─── Tests ─────────────────────────────────────────────────────────────────
+
+describe("parallel-eligibility: ghost milestone ineligibility (#2501)", () => {
+  let base: string;
+
+  beforeEach(() => {
+    base = createFixtureBase();
+    openDatabase(":memory:");
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    cleanup(base);
+    invalidateStateCache();
+  });
+
+  test("ghost milestone (directory only, no planning files) is ineligible", async () => {
+    // Set up a real milestone M001 with proper planning data in DB
+    writeMilestoneFile(base, "M001", "M001-CONTEXT.md", "# M001: Real Milestone\n\nA real milestone.");
+    writeMilestoneFile(base, "M001", "M001-ROADMAP.md", "# M001: Real Milestone\n\n## Slices\n\n- [ ] **S01: First Slice** `risk:low` `depends:[]`\n  > Do something.\n");
+    writeMilestoneFile(base, "M001", "slices/S01/S01-PLAN.md", "# S01: First Slice\n\n**Goal:** Do it.\n**Demo:** Done.\n\n## Tasks\n\n- [ ] **T01: Task One** `est:10m`\n  Do the thing.\n");
+    insertMilestone({ id: "M001", title: "M001: Real Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First Slice", status: "active", risk: "low", depends: [] });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Task One", status: "pending" });
+
+    // Create ghost milestone M017 — directory with only slices/, no CONTEXT/ROADMAP/SUMMARY
+    makeMilestoneDir(base, "M017");
+    mkdirSync(join(base, ".gsd", "milestones", "M017", "slices"), { recursive: true });
+
+    invalidateStateCache();
+    const result = await analyzeParallelEligibility(base);
+
+    // M017 should NOT be in the eligible list
+    const ghostEligible = result.eligible.find(e => e.milestoneId === "M017");
+    assert.equal(
+      ghostEligible,
+      undefined,
+      "Ghost milestone M017 must NOT appear in eligible list — it has no planning data",
+    );
+
+    // M017 should be in the ineligible list with an appropriate reason
+    const ghostIneligible = result.ineligible.find(e => e.milestoneId === "M017");
+    assert.ok(
+      ghostIneligible,
+      "Ghost milestone M017 must appear in ineligible list",
+    );
+    assert.equal(ghostIneligible!.eligible, false);
+    assert.match(
+      ghostIneligible!.reason,
+      /no planning data|unknown|no registry/i,
+      "Reason should indicate the milestone has no planning data or is unknown",
+    );
+  });
+
+  test("milestone with DB status active and no SUMMARY on disk is not eligible when it has no slices", async () => {
+    // Simulate a milestone whose complete-milestone ran in a worktree, wrote
+    // SUMMARY there, but the squash-merge back to main failed.  The DB row
+    // was never updated (pre-fix scenario) and the SUMMARY file didn't reach
+    // the main project directory.
+    //
+    // In the current codebase, complete-milestone.ts already writes the DB
+    // status (Bug 1 was fixed). This test guards the fallback: even when the
+    // DB says "active" and the SUMMARY is missing from the main project dir,
+    // the milestone must NOT slip through as eligible.
+
+    // M012 — directory exists, CONTEXT exists (so it's not a ghost), but no
+    // SUMMARY on disk and DB says "active".  No slices in DB either (they
+    // lived only in the worktree DB copy).
+    writeMilestoneFile(base, "M012", "M012-CONTEXT.md", "# M012: Worktree Milestone\n\nThis ran in a worktree.");
+    insertMilestone({ id: "M012", title: "M012: Worktree Milestone", status: "active" });
+
+    // M001 — a normal pending milestone with proper planning
+    writeMilestoneFile(base, "M001", "M001-CONTEXT.md", "# M001: Normal Milestone\n\nNormal milestone.");
+    writeMilestoneFile(base, "M001", "M001-ROADMAP.md", "# M001: Normal Milestone\n\n## Slices\n\n- [ ] **S01: Slice** `risk:low` `depends:[]`\n  > Do it.\n");
+    writeMilestoneFile(base, "M001", "slices/S01/S01-PLAN.md", "# S01: Slice\n\n**Goal:** Do.\n**Demo:** Done.\n\n## Tasks\n\n- [ ] **T01: Task** `est:10m`\n  Do.\n");
+    insertMilestone({ id: "M001", title: "M001: Normal Milestone", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "Slice", status: "active", risk: "low", depends: [] });
+    insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", title: "Task", status: "pending" });
+
+    invalidateStateCache();
+    const result = await analyzeParallelEligibility(base);
+
+    // M001 should be eligible (it has proper planning and active status)
+    const m001 = result.eligible.find(e => e.milestoneId === "M001");
+    assert.ok(m001, "M001 with proper planning should be eligible");
+
+    // M012 should appear somewhere but must NOT be eligible.  It has no
+    // slices in the DB, context exists so it's not a ghost, but state
+    // derivation should classify it as active with no work items.  Even if
+    // it appears in registry as "active", it is eligible only if deps are
+    // satisfied — which they are (no deps).  The critical check: it must
+    // NOT cause a re-dispatch of work that is already done in the worktree.
+    //
+    // NOTE: This test documents the current behavior.  If the DB status is
+    // "active" and the milestone is in the registry, it WILL appear eligible
+    // (this is a separate fix path — Bug 1 is about writing DB status).
+    // We verify the fix path through Bug 2's ghost handling above.
+  });
+});

package/src/resources/extensions/gsd/tests/parallel-worker-monitoring.test.ts

@@ -131,14 +131,15 @@ describe("parallel-worker-monitoring", () => {
     assert.ok(!(5.01 < ceiling), "5.01 is over ceiling");
   });
 
-  it("worker spawn args include --mode json", () => {
-    // Verify the spawn command includes JSON mode for NDJSON output.
-    // We can't easily test the actual spawn, but we verify the args pattern.
-    const expectedArgs = ["--mode", "json", "--print", "/gsd auto"];
-    assert.ok(expectedArgs.includes("--mode"), "args include --mode");
-    assert.ok(expectedArgs.includes("json"), "args include json");
-    assert.ok(expectedArgs.indexOf("--mode") < expectedArgs.indexOf("json"),
-      "--mode comes before json");
+  it("worker spawn args use headless --json auto (#2792)", () => {
+    // Verify the spawn command uses headless mode (not --print which exits
+    // before auto-mode can run). See #2792.
+    const expectedArgs = ["headless", "--json", "auto"];
+    assert.ok(expectedArgs.includes("headless"), "args include headless");
+    assert.ok(expectedArgs.includes("--json"), "args include --json");
+    assert.ok(expectedArgs.includes("auto"), "args include auto");
+    assert.ok(expectedArgs.indexOf("headless") < expectedArgs.indexOf("auto"),
+      "headless comes before auto");
   });
 
   it("refreshWorkerStatuses restores persisted workers from disk", () => {

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

@@ -0,0 +1,70 @@
+/**
+ * Regression test for #2879: gsd_plan_milestone silently drops milestone title
+ * when the DB row pre-exists from state reconciliation.
+ *
+ * Scenario: state reconciliation inserts a milestone row with an empty title
+ * (INSERT OR IGNORE). When gsd_plan_milestone is called later with a title,
+ * the title must be persisted — not silently dropped.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  getMilestone,
+  upsertMilestonePlanning,
+} from "../gsd-db.ts";
+
+test("upsertMilestonePlanning updates title when DB row pre-exists with empty title (#2879)", () => {
+  try {
+    openDatabase(":memory:");
+
+    // Step 1: Simulate state reconciliation — inserts milestone with empty title
+    insertMilestone({ id: "M099", status: "active" });
+    const before = getMilestone("M099");
+    assert.ok(before, "milestone row should exist after insertMilestone");
+    assert.equal(before.title, "", "title should be empty after reconciliation insert");
+
+    // Step 2: Simulate gsd_plan_milestone — insertMilestone is called again
+    // with a title, but INSERT OR IGNORE skips it since the row exists.
+    insertMilestone({ id: "M099", title: "My Important Milestone", status: "active" });
+    const afterInsert = getMilestone("M099");
+    assert.ok(afterInsert);
+    // The INSERT OR IGNORE means title is still empty — this is the known limitation
+    assert.equal(afterInsert.title, "", "INSERT OR IGNORE does not update existing row");
+
+    // Step 3: upsertMilestonePlanning should update the title
+    upsertMilestonePlanning("M099", {
+      vision: "Test vision",
+    }, "My Important Milestone");
+    const afterUpsert = getMilestone("M099");
+    assert.ok(afterUpsert);
+    assert.equal(
+      afterUpsert.title,
+      "My Important Milestone",
+      "title must be updated by upsertMilestonePlanning when row pre-exists",
+    );
+  } finally {
+    closeDatabase();
+  }
+});
+
+test("upsertMilestonePlanning preserves existing title when no title argument provided", () => {
+  try {
+    openDatabase(":memory:");
+
+    // Insert milestone with a title
+    insertMilestone({ id: "M100", title: "Original Title", status: "active" });
+
+    // Call upsertMilestonePlanning without a title — should preserve existing
+    upsertMilestonePlanning("M100", { vision: "Updated vision" });
+    const after = getMilestone("M100");
+    assert.ok(after);
+    assert.equal(after.title, "Original Title", "existing title must be preserved when no title argument given");
+  } finally {
+    closeDatabase();
+  }
+});

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

@@ -4,7 +4,7 @@ import { mkdtempSync, mkdirSync, rmSync, readFileSync, existsSync, writeFileSync
 import { join } from 'node:path';
 import { tmpdir } from 'node:os';
 
-import { openDatabase, closeDatabase, getMilestone, getMilestoneSlices } from '../gsd-db.ts';
+import { openDatabase, closeDatabase, getMilestone, getMilestoneSlices, updateSliceStatus } from '../gsd-db.ts';
 import { handlePlanMilestone } from '../tools/plan-milestone.ts';
 import { parseRoadmap } from '../parsers-legacy.ts';
 
@@ -197,3 +197,35 @@ test('handlePlanMilestone reruns idempotently and updates existing planning stat
     cleanup(base);
   }
 });
+
+// Regression: #2960 — plan-milestone must refuse to overwrite completed slices
+test('handlePlanMilestone refuses to re-plan a milestone with completed slices (#2960)', async () => {
+  const base = makeTmpBase();
+  const dbPath = join(base, '.gsd', 'gsd.db');
+  openDatabase(dbPath);
+
+  try {
+    // First plan succeeds
+    const first = await handlePlanMilestone(validParams(), base);
+    assert.ok(!('error' in first), `initial plan should succeed: ${'error' in first ? first.error : ''}`);
+
+    // Mark S01 as complete
+    updateSliceStatus('M001', 'S01', 'complete');
+
+    // Second plan should fail — S01 is already complete
+    const second = await handlePlanMilestone({
+      ...validParams(),
+      vision: 'Should not overwrite',
+    }, base);
+    assert.ok('error' in second, 'should refuse to re-plan when slices are completed');
+    assert.match(second.error, /cannot re-plan/i);
+    assert.match(second.error, /S01/);
+
+    // Verify the completed slice was not overwritten
+    const slices = getMilestoneSlices('M001');
+    const s01 = slices.find(s => s.id === 'S01');
+    assert.equal(s01?.status, 'complete', 'S01 should still be complete');
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/preferences.test.ts

@@ -352,6 +352,40 @@ test("handles empty models config", () => {
   assert.equal(prefs!.models, undefined);
 });
 
+test("parses raw YAML blocks under headings", () => {
+  const content = `## Parallel
+enabled: true
+max_workers: 3
+`;
+  const prefs = parsePreferencesMarkdown(content);
+  assert.notEqual(prefs, null);
+  assert.equal(prefs!.parallel?.enabled, true);
+  assert.equal(prefs!.parallel?.max_workers, 3);
+});
+
+test("unwraps nested top-level preference key under descriptive headings", () => {
+  const content = `## Parallel Orchestration
+parallel:
+  enabled: true
+  max_workers: 3
+`;
+  const prefs = parsePreferencesMarkdown(content);
+  assert.notEqual(prefs, null);
+  assert.equal(prefs!.parallel?.enabled, true);
+  assert.equal(prefs!.parallel?.max_workers, 3);
+});
+
+test("preserves legacy heading list format", () => {
+  const content = `## Git
+- isolation: branch
+- auto_push: true
+`;
+  const prefs = parsePreferencesMarkdown(content);
+  assert.notEqual(prefs, null);
+  assert.equal(prefs!.git?.isolation, "branch");
+  assert.equal(prefs!.git?.auto_push, true);
+});
+
 // ── Warn-once for unrecognized format (#2373) ────────────────────────────────
 
 test("unrecognized format warning is emitted at most once (#2373)", () => {