gsd-pi 2.51.0 → 2.52.0-dev.655ad8a

package/src/resources/extensions/gsd/tests/parallel-orchestrator-zombie-cleanup.test.ts

@@ -0,0 +1,277 @@
+/**
+ * Regression tests for zombie worker cleanup (#2736).
+ *
+ * Verifies that:
+ * 1. refreshWorkerStatuses() deactivates the orchestrator when all workers
+ *    are in terminal states (error/stopped).
+ * 2. restoreRuntimeState() (via getWorkerStatuses) returns empty when the
+ *    cached state has only dead workers.
+ */
+
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, writeFileSync, rmSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { randomUUID } from "node:crypto";
+
+import {
+  persistState,
+  resetOrchestrator,
+  refreshWorkerStatuses,
+  isParallelActive,
+  getOrchestratorState,
+  getWorkerStatuses,
+  type PersistedState,
+} from "../parallel-orchestrator.ts";
+
+function makeTmpBase(): string {
+  const base = join(tmpdir(), `gsd-test-zombie-${randomUUID()}`);
+  mkdirSync(join(base, ".gsd", "parallel"), { recursive: true });
+  return base;
+}
+
+function cleanup(base: string): void {
+  try {
+    rmSync(base, { recursive: true, force: true });
+  } catch { /* non-fatal */ }
+}
+
+/** Write a fake orchestrator.json to simulate persisted state. */
+function writePersistedState(basePath: string, data: PersistedState): void {
+  const dest = join(basePath, ".gsd", "orchestrator.json");
+  writeFileSync(dest, JSON.stringify(data, null, 2), "utf-8");
+}
+
+/** Write a fake session status file to .gsd/parallel/<milestoneId>.status.json */
+function writeSessionStatusFile(
+  basePath: string,
+  milestoneId: string,
+  state: "running" | "paused" | "stopped" | "error",
+  pid: number,
+): void {
+  const dest = join(basePath, ".gsd", "parallel", `${milestoneId}.status.json`);
+  writeFileSync(
+    dest,
+    JSON.stringify({
+      milestoneId,
+      pid,
+      state,
+      currentUnit: null,
+      completedUnits: 0,
+      cost: 0.5,
+      lastHeartbeat: Date.now(),
+      startedAt: Date.now() - 60_000,
+      worktreePath: join(basePath, "worktrees", milestoneId),
+    }),
+    "utf-8",
+  );
+}
+
+// Use a PID that is guaranteed dead — PID 1 is init/launchd and won't be
+// killable by this process, but 2147483647 is unlikely to exist.
+const DEAD_PID = 2147483647;
+
+// ─── refreshWorkerStatuses: deactivates when all workers dead ──────────
+
+test("#2736: refreshWorkerStatuses deactivates orchestrator when all workers are error/stopped", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    resetOrchestrator();
+    cleanup(base);
+  });
+
+  // Seed persisted state with two workers using current PID (alive) so
+  // restoreState() accepts them, then immediately mark them as error via
+  // session status files so refreshWorkerStatuses sees terminal states.
+  const persisted: PersistedState = {
+    active: true,
+    workers: [
+      {
+        milestoneId: "M001",
+        title: "Milestone 1",
+        pid: process.pid, // alive PID so restoreState accepts it
+        worktreePath: join(base, "worktrees", "M001"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 1.0,
+      },
+      {
+        milestoneId: "M002",
+        title: "Milestone 2",
+        pid: process.pid,
+        worktreePath: join(base, "worktrees", "M002"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 0.5,
+      },
+    ],
+    totalCost: 1.5,
+    startedAt: Date.now() - 60_000,
+    configSnapshot: { max_workers: 3 },
+  };
+  writePersistedState(base, persisted);
+
+  // First, restore the state into memory via getWorkerStatuses (triggers restoreIfNeeded)
+  const workers = getWorkerStatuses(base);
+  assert.equal(workers.length, 2, "should have 2 workers after restore");
+  assert.ok(isParallelActive(), "orchestrator should be active after restore");
+
+  // Now write session status files marking both workers as error
+  writeSessionStatusFile(base, "M001", "error", process.pid);
+  writeSessionStatusFile(base, "M002", "error", process.pid);
+
+  // Refresh — should detect all-dead and deactivate
+  refreshWorkerStatuses(base);
+
+  assert.equal(isParallelActive(), false, "orchestrator should be inactive after all workers died");
+  assert.equal(getOrchestratorState(), null, "state should be null after cleanup");
+});
+
+test("#2736: refreshWorkerStatuses keeps orchestrator active when some workers are still running", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    resetOrchestrator();
+    cleanup(base);
+  });
+
+  const persisted: PersistedState = {
+    active: true,
+    workers: [
+      {
+        milestoneId: "M001",
+        title: "Milestone 1",
+        pid: process.pid,
+        worktreePath: join(base, "worktrees", "M001"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 1.0,
+      },
+      {
+        milestoneId: "M002",
+        title: "Milestone 2",
+        pid: process.pid,
+        worktreePath: join(base, "worktrees", "M002"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 0.5,
+      },
+    ],
+    totalCost: 1.5,
+    startedAt: Date.now() - 60_000,
+    configSnapshot: { max_workers: 3 },
+  };
+  writePersistedState(base, persisted);
+
+  // Restore state
+  getWorkerStatuses(base);
+
+  // Mark M001 as error but keep M002 running
+  writeSessionStatusFile(base, "M001", "error", process.pid);
+  writeSessionStatusFile(base, "M002", "running", process.pid);
+
+  refreshWorkerStatuses(base);
+
+  assert.ok(isParallelActive(), "orchestrator should remain active with a running worker");
+  assert.ok(getOrchestratorState() !== null, "state should still exist");
+});
+
+// ─── restoreRuntimeState: returns false when cached state has only dead workers ─
+
+test("#2736: getWorkerStatuses returns empty when all cached workers are in error state", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    resetOrchestrator();
+    cleanup(base);
+  });
+
+  // First, set up active state with live workers
+  const persisted: PersistedState = {
+    active: true,
+    workers: [
+      {
+        milestoneId: "M001",
+        title: "Milestone 1",
+        pid: process.pid,
+        worktreePath: join(base, "worktrees", "M001"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 0.5,
+      },
+    ],
+    totalCost: 0.5,
+    startedAt: Date.now() - 60_000,
+    configSnapshot: { max_workers: 3 },
+  };
+  writePersistedState(base, persisted);
+
+  // Restore into memory
+  getWorkerStatuses(base);
+  assert.ok(isParallelActive(), "should be active initially");
+
+  // Simulate all workers dying: write error status then refresh to update
+  writeSessionStatusFile(base, "M001", "error", process.pid);
+  refreshWorkerStatuses(base);
+
+  // State should now be cleared
+  assert.equal(getOrchestratorState(), null, "state should be null after all workers error");
+
+  // Reset and try again — getWorkerStatuses with restoreIfNeeded should
+  // find no live workers on disk (orchestrator.json was cleaned up)
+  const workers = getWorkerStatuses(base);
+  assert.equal(workers.length, 0, "should return empty when no live workers exist");
+});
+
+test("#2736: restoreRuntimeState clears stale state when all workers are stopped", (t) => {
+  const base = makeTmpBase();
+  t.after(() => {
+    resetOrchestrator();
+    cleanup(base);
+  });
+
+  // Set up and restore state
+  const persisted: PersistedState = {
+    active: true,
+    workers: [
+      {
+        milestoneId: "M001",
+        title: "Milestone 1",
+        pid: process.pid,
+        worktreePath: join(base, "worktrees", "M001"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 0.3,
+      },
+      {
+        milestoneId: "M002",
+        title: "Milestone 2",
+        pid: process.pid,
+        worktreePath: join(base, "worktrees", "M002"),
+        startedAt: Date.now() - 60_000,
+        state: "running",
+        cost: 0.7,
+      },
+    ],
+    totalCost: 1.0,
+    startedAt: Date.now() - 60_000,
+    configSnapshot: { max_workers: 3 },
+  };
+  writePersistedState(base, persisted);
+
+  // Restore into memory
+  getWorkerStatuses(base);
+  assert.ok(isParallelActive(), "should be active initially");
+
+  // Mark all as stopped via session status, then refresh
+  writeSessionStatusFile(base, "M001", "stopped", process.pid);
+  writeSessionStatusFile(base, "M002", "stopped", process.pid);
+  refreshWorkerStatuses(base);
+
+  // Orchestrator should be deactivated and state cleaned
+  assert.equal(isParallelActive(), false, "should be inactive after all workers stopped");
+  assert.equal(getOrchestratorState(), null, "state should be null");
+
+  // Verify the state file was removed
+  const stateFile = join(base, ".gsd", "orchestrator.json");
+  assert.equal(existsSync(stateFile), false, "orchestrator.json should be removed");
+});

package/src/resources/extensions/gsd/tests/park-db-sync.test.ts

@@ -0,0 +1,85 @@
+/**
+ * Regression test for #2694: parkMilestone and unparkMilestone must
+ * update the DB milestone status alongside the filesystem marker.
+ *
+ * Without this, deriveStateFromDb skips unparked milestones because
+ * the DB still has status='parked', causing "All milestones complete".
+ */
+import { test } 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 { parkMilestone, unparkMilestone } from "../milestone-actions.ts";
+import {
+  openDatabase,
+  closeDatabase,
+  insertMilestone,
+  getMilestone,
+} from "../gsd-db.ts";
+
+function createBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-park-db-"));
+  mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
+    "# M001\n\nContext.",
+  );
+  return base;
+}
+
+test("parkMilestone updates DB status to 'parked' (#2694)", () => {
+  const base = createBase();
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    assert.equal(getMilestone("M001")!.status, "active", "starts active");
+
+    parkMilestone(base, "M001", "deprioritized");
+
+    assert.equal(getMilestone("M001")!.status, "parked", "DB status should be parked");
+
+    closeDatabase();
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("unparkMilestone updates DB status to 'active' (#2694)", () => {
+  const base = createBase();
+  try {
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test", status: "active" });
+
+    // Park first
+    parkMilestone(base, "M001", "deprioritized");
+    assert.equal(getMilestone("M001")!.status, "parked");
+
+    // Unpark
+    unparkMilestone(base, "M001");
+    assert.equal(getMilestone("M001")!.status, "active", "DB status should be active after unpark");
+
+    closeDatabase();
+  } finally {
+    closeDatabase();
+    rmSync(base, { recursive: true, force: true });
+  }
+});
+
+test("park/unpark are safe when DB is not available (#2694 guard)", () => {
+  const base = createBase();
+  try {
+    // No openDatabase — DB not available
+    // park/unpark should still work (filesystem-only, no throw)
+    const parked = parkMilestone(base, "M001", "test");
+    assert.ok(parked, "parkMilestone succeeds without DB");
+
+    const unparked = unparkMilestone(base, "M001");
+    assert.ok(unparked, "unparkMilestone succeeds without DB");
+  } finally {
+    rmSync(base, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/phases-merge-error-stops-auto.test.ts

@@ -0,0 +1,103 @@
+/**
+ * phases-merge-error-stops-auto.test.ts — Regression test for #2766.
+ *
+ * When mergeAndExit throws a non-MergeConflictError, the auto loop must
+ * stop instead of continuing with unmerged work. This test verifies that
+ * all catch blocks in auto/phases.ts that handle mergeAndExit errors
+ * call stopAuto and return { action: "break" } for non-conflict errors.
+ */
+
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import { createTestContext } from "./test-helpers.ts";
+
+const { assertTrue, report } = createTestContext();
+
+const phasesPath = join(import.meta.dirname, "..", "auto", "phases.ts");
+const phasesSrc = readFileSync(phasesPath, "utf-8");
+
+console.log("\n=== #2766: Non-MergeConflictError stops auto mode ===");
+
+// ── Test 1: phases.ts calls logError for non-conflict merge errors ──────
+
+assertTrue(
+  phasesPath.length > 0 && phasesPath.endsWith("phases.ts"),
+  "phases.ts file exists and is readable",
+);
+
+// Count all mergeAndExit catch blocks by finding "} catch (mergeErr)" patterns
+const mergeErrCatches = [...phasesPath.matchAll(/\} catch \(mergeErr\)/g)];
+// Use the source itself for matching
+const mergeErrCatchCount = [...phasesSrc.matchAll(/\} catch \(mergeErr\)/g)].length;
+assertTrue(
+  mergeErrCatchCount >= 3,
+  `all mergeAndExit call sites have catch (mergeErr) blocks (found ${mergeErrCatchCount}, expected >= 3)`,
+);
+
+// ── Test 2: Every mergeErr catch block handles non-MergeConflictError ───
+
+// Find each catch block and verify it has the non-conflict error handling pattern
+const catchPattern = /\} catch \(mergeErr\) \{/g;
+let match;
+let blocksWithNonConflictHandling = 0;
+let blocksTotal = 0;
+
+while ((match = catchPattern.exec(phasesSrc)) !== null) {
+  blocksTotal++;
+  // Look at the ~800 chars after the catch to find both the MergeConflictError
+  // instanceof check AND the non-conflict handling
+  const afterCatch = phasesSrc.slice(match.index, match.index + 1200);
+
+  const hasInstanceofCheck = afterCatch.includes("instanceof MergeConflictError");
+  const hasNonConflictStop = afterCatch.includes('reason: "merge-failed"');
+  const hasStopAuto = afterCatch.includes("stopAuto");
+  const hasLogError = afterCatch.includes("logError");
+
+  if (hasInstanceofCheck && hasNonConflictStop && hasStopAuto && hasLogError) {
+    blocksWithNonConflictHandling++;
+  }
+}
+
+assertTrue(
+  blocksWithNonConflictHandling === blocksTotal && blocksTotal >= 3,
+  `all ${blocksTotal} mergeAndExit catch blocks stop auto on non-conflict errors (${blocksWithNonConflictHandling}/${blocksTotal})`,
+);
+
+// ── Test 3: Non-conflict handler returns break (does not continue) ──────
+
+// Verify the pattern: after the MergeConflictError instanceof block,
+// the non-conflict path returns { action: "break", reason: "merge-failed" }
+const mergeFailedReasons = [...phasesSrc.matchAll(/reason: "merge-failed"/g)].length;
+assertTrue(
+  mergeFailedReasons >= 3,
+  `all catch blocks return reason: "merge-failed" (found ${mergeFailedReasons}, expected >= 3)`,
+);
+
+// ── Test 4: Non-conflict handler notifies user ──────────────────────────
+
+// Each non-conflict block should call ctx.ui.notify with error severity
+const notifyErrorPattern = /Merge failed:.*Resolve and run \/gsd auto to resume/g;
+const notifyCount = [...phasesSrc.matchAll(notifyErrorPattern)].length;
+assertTrue(
+  notifyCount >= 3,
+  `all catch blocks notify user about merge failure (found ${notifyCount}, expected >= 3)`,
+);
+
+// ── Test 5: logError replaces logWarning for non-conflict merge errors ──
+
+// The old code used logWarning — verify logError is used instead
+const logWarningMergePattern = /logWarning\(.*Milestone merge failed with non-conflict error/g;
+const logWarningCount = [...phasesSrc.matchAll(logWarningMergePattern)].length;
+assertTrue(
+  logWarningCount === 0,
+  "logWarning is no longer used for non-conflict merge errors (replaced by logError)",
+);
+
+const logErrorMergePattern = /logError\(.*Milestone merge failed with non-conflict error/g;
+const logErrorCount = [...phasesSrc.matchAll(logErrorMergePattern)].length;
+assertTrue(
+  logErrorCount >= 3,
+  `logError is used for non-conflict merge errors (found ${logErrorCount}, expected >= 3)`,
+);
+
+report();

package/src/resources/extensions/gsd/tests/preferences-worktree-sync.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Regression tests for #2684: preferences.md must be included in both
+ * ROOT_STATE_FILES (sync) and copyPlanningArtifacts (initial seed).
+ *
+ * Without this, post_unit_hooks and all preference-driven config silently
+ * stop working inside auto-mode worktrees.
+ */
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, mkdtempSync, mkdirSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+test("#2684: preferences.md is NOT in ROOT_STATE_FILES (forward-only sync)", () => {
+  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
+  const src = readFileSync(srcPath, "utf-8");
+
+  const constIdx = src.indexOf("ROOT_STATE_FILES");
+  assert.ok(constIdx !== -1, "ROOT_STATE_FILES constant exists");
+
+  const arrayStart = src.indexOf("[", constIdx);
+  const arrayEnd = src.indexOf("] as const", arrayStart);
+  const block = src.slice(arrayStart, arrayEnd);
+
+  // preferences.md must NOT be in ROOT_STATE_FILES — it is handled separately
+  // in syncGsdStateToWorktree() (forward-only, additive). Including it in
+  // ROOT_STATE_FILES would cause syncWorktreeStateBack() to overwrite the
+  // authoritative project root copy (#2684).
+  const entries = block.split("\n")
+    .map(l => l.trim())
+    .filter(l => l.startsWith('"') && l.includes(".md"));
+  const hasPrefs = entries.some(l => l.includes("preferences.md"));
+  assert.ok(
+    !hasPrefs,
+    "preferences.md must NOT be in ROOT_STATE_FILES (back-sync would overwrite root)",
+  );
+});
+
+test("#2684: copyPlanningArtifacts file list includes preferences.md", () => {
+  const srcPath = join(import.meta.dirname, "..", "auto-worktree.ts");
+  const src = readFileSync(srcPath, "utf-8");
+
+  // Find the copyPlanningArtifacts function body
+  const fnIdx = src.indexOf("function copyPlanningArtifacts");
+  assert.ok(fnIdx !== -1, "copyPlanningArtifacts function exists");
+
+  // Extract function body (up to the next top-level function)
+  const fnBody = src.slice(fnIdx, fnIdx + 1500);
+
+  assert.ok(
+    fnBody.includes('"preferences.md"'),
+    "preferences.md should be in copyPlanningArtifacts file list",
+  );
+});
+
+test("#2684: syncGsdStateToWorktree copies preferences.md", async () => {
+  // Functional test: create a mock source and destination, call the sync
+  const srcBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-src-"));
+  const dstBase = mkdtempSync(join(tmpdir(), "gsd-wt-prefs-dst-"));
+  const srcGsd = join(srcBase, ".gsd");
+  const dstGsd = join(dstBase, ".gsd");
+  mkdirSync(srcGsd, { recursive: true });
+  mkdirSync(dstGsd, { recursive: true });
+
+  try {
+    // Write a preferences.md in source
+    writeFileSync(
+      join(srcGsd, "preferences.md"),
+      "---\nversion: 1\n---\n\npost_unit_hooks:\n  - name: notify\n    command: echo done\n",
+    );
+
+    // Import and call syncGsdStateToWorktree
+    const { syncGsdStateToWorktree } = await import("../auto-worktree.ts");
+    syncGsdStateToWorktree(srcBase, dstBase);
+
+    // Verify preferences.md was copied
+    assert.ok(
+      existsSync(join(dstGsd, "preferences.md")),
+      "preferences.md should be copied to worktree",
+    );
+
+    const content = readFileSync(join(dstGsd, "preferences.md"), "utf-8");
+    assert.ok(
+      content.includes("post_unit_hooks"),
+      "copied preferences.md should contain the hooks config",
+    );
+  } finally {
+    rmSync(srcBase, { recursive: true, force: true });
+    rmSync(dstBase, { recursive: true, force: true });
+  }
+});

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

@@ -45,7 +45,7 @@ test("getIsolationMode defaults to none when preferences have no isolation setti
   // Validate the default via validatePreferences: when no isolation is set,
   // preferences.git.isolation is undefined, and getIsolationMode returns "none".
   // Default changed from "worktree" to "none" so GSD works out of the box
-  // without preferences.md (#2480).
+  // without PREFERENCES.md (#2480).
   const { preferences } = validatePreferences({});
   assert.equal(preferences.git?.isolation, undefined, "no isolation in empty prefs");
   const isolation = preferences.git?.isolation;
@@ -59,7 +59,7 @@ test("solo mode applies correct defaults", () => {
   const result = applyModeDefaults("solo", { mode: "solo" });
   assert.equal(result.git?.auto_push, true);
   assert.equal(result.git?.push_branches, false);
-  assert.equal(result.git?.pre_merge_check, false);
+  assert.equal(result.git?.pre_merge_check, "auto");
   assert.equal(result.git?.merge_strategy, "squash");
   assert.equal(result.git?.isolation, "none");
   assert.equal(result.unique_milestone_ids, false);