gsd-pi 2.51.0 → 2.52.0-dev.655ad8a

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

@@ -36,6 +36,7 @@ import {
 
 import { findMilestoneIds } from './milestone-ids.js';
 import { loadQueueOrder, sortByQueueOrder } from './queue-order.js';
+import { isClosedStatus } from './status-guards.js';
 import { nativeBatchParseGsdFiles, type BatchParsedFile } from './native-parser-bridge.js';
 
 import { join, resolve } from 'path';
@@ -89,18 +90,13 @@ export function isMilestoneComplete(roadmap: Roadmap): boolean {
 }
 
 /**
- * Check whether a VALIDATION file's verdict is terminal (pass or needs-attention).
- * A non-terminal verdict (needs-remediation) means validation must re-run
- * after remediation slices are executed.
+ * Check whether a VALIDATION file's verdict is terminal.
+ * Any successfully extracted verdict (pass, needs-attention, needs-remediation,
+ * fail, etc.) means validation completed. Only return false when no verdict
+ * could be parsed — i.e. extractVerdict() returns undefined (#2769).
  */
 export function isValidationTerminal(validationContent: string): boolean {
-  const v = extractVerdict(validationContent);
-  if (!v) return false;
-  // 'pass' and 'needs-attention' are always terminal.
-  // 'needs-remediation' is treated as terminal to prevent infinite loops
-  // when no remediation slices exist in the roadmap (#832). The validation
-  // report is preserved on disk for manual review.
-  return v === 'pass' || v === 'needs-attention' || v === 'needs-remediation';
+  return extractVerdict(validationContent) != null;
 }
 
 // ─── State Derivation ──────────────────────────────────────────────────────
@@ -211,7 +207,24 @@ export async function deriveState(basePath: string): Promise<GSDState> {
 
   // Dual-path: try DB-backed derivation first when hierarchy tables are populated
   if (isDbAvailable()) {
-    const dbMilestones = getAllMilestones();
+    let dbMilestones = getAllMilestones();
+
+    // Disk→DB reconciliation (#2631): when the milestones table is empty
+    // (e.g. failed initial migration per #2529), the reconciliation code
+    // inside deriveStateFromDb is unreachable. Populate from disk here so
+    // the DB path activates correctly.
+    if (dbMilestones.length === 0) {
+      const diskIds = findMilestoneIds(basePath);
+      let synced = false;
+      for (const diskId of diskIds) {
+        if (!isGhostMilestone(basePath, diskId)) {
+          insertMilestone({ id: diskId, status: 'active' });
+          synced = true;
+        }
+      }
+      if (synced) dbMilestones = getAllMilestones();
+    }
+
     if (dbMilestones.length > 0) {
       const stopDbTimer = debugTime("derive-state-db");
       result = await deriveStateFromDb(basePath);
@@ -255,13 +268,6 @@ function extractContextTitle(content: string | null, fallback: string): string {
 
 // ─── DB-backed State Derivation ────────────────────────────────────────────
 
-/**
- * Helper: check if a DB status counts as "done" (handles K002 ambiguity).
- */
-function isStatusDone(status: string): boolean {
-  return status === 'complete' || status === 'done';
-}
-
 /**
  * Derive GSD state from the milestones/slices/tasks DB tables.
  * Flag files (PARKED, VALIDATION, CONTINUE, REPLAN, REPLAN-TRIGGER, CONTEXT-DRAFT)
@@ -351,7 +357,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
       continue;
     }
 
-    if (isStatusDone(m.status)) {
+    if (isClosedStatus(m.status)) {
       completeMilestoneIds.add(m.id);
       continue;
     }
@@ -365,7 +371,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
 
     // Check roadmap: all slices done means milestone is complete
     const slices = getMilestoneSlices(m.id);
-    if (slices.length > 0 && slices.every(s => isStatusDone(s.status))) {
+    if (slices.length > 0 && slices.every(s => isClosedStatus(s.status))) {
       // All slices done but no summary — still counts as complete for dep resolution
       // if a summary file exists
       // Note: without summary file, the milestone is in validating/completing state, not complete
@@ -387,7 +393,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
 
     // Ghost milestone check: no slices in DB AND no substantive files on disk
     const slices = getMilestoneSlices(m.id);
-    if (slices.length === 0 && !isStatusDone(m.status)) {
+    if (slices.length === 0 && !isClosedStatus(m.status)) {
       // Check disk for ghost detection
       if (isGhostMilestone(basePath, m.id)) continue;
     }
@@ -410,7 +416,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
     }
 
     // Not complete — determine if it should be active
-    const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
+    const allSlicesDone = slices.length > 0 && slices.every(s => isClosedStatus(s.status));
 
     // Get title — prefer DB, fall back to context file extraction
     let title = stripMilestonePrefix(m.title) || m.id;
@@ -562,7 +568,10 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   }
 
   // ── All slices done → validating/completing ─────────────────────────
-  const allSlicesDone = activeMilestoneSlices.every(s => isStatusDone(s.status));
+  // Guard: [].every() === true (vacuous truth). Without the length check,
+  // an empty slice array causes a premature phase transition to
+  // validating-milestone. See: https://github.com/gsd-build/gsd-2/issues/2667
+  const allSlicesDone = activeMilestoneSlices.length > 0 && activeMilestoneSlices.every(s => isClosedStatus(s.status));
   if (allSlicesDone) {
     const validationFile = resolveMilestoneFile(basePath, activeMilestone.id, "VALIDATION");
     const validationContent = validationFile ? await loadFile(validationFile) : null;
@@ -595,19 +604,19 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
 
   // ── Find active slice (first incomplete with deps satisfied) ─────────
   const sliceProgress = {
-    done: activeMilestoneSlices.filter(s => isStatusDone(s.status)).length,
+    done: activeMilestoneSlices.filter(s => isClosedStatus(s.status)).length,
     total: activeMilestoneSlices.length,
   };
 
   const doneSliceIds = new Set(
-    activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id)
+    activeMilestoneSlices.filter(s => isClosedStatus(s.status)).map(s => s.id)
   );
 
   let activeSlice: ActiveRef | null = null;
   let activeSliceRow: SliceRow | null = null;
 
   for (const s of activeMilestoneSlices) {
-    if (isStatusDone(s.status)) continue;
+    if (isClosedStatus(s.status)) continue;
     if (s.depends.every(dep => doneSliceIds.has(dep))) {
       activeSlice = { id: s.id, title: s.title };
       activeSliceRow = s;
@@ -650,7 +659,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   // causing the dispatcher to re-dispatch the same completed task forever.
   let reconciled = false;
   for (const t of tasks) {
-    if (isStatusDone(t.status)) continue;
+    if (isClosedStatus(t.status)) continue;
     const summaryPath = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, t.id, "SUMMARY");
     if (summaryPath && existsSync(summaryPath)) {
       try {
@@ -673,11 +682,11 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   }
 
   const taskProgress = {
-    done: tasks.filter(t => isStatusDone(t.status)).length,
+    done: tasks.filter(t => isClosedStatus(t.status)).length,
     total: tasks.length,
   };
 
-  const activeTaskRow = tasks.find(t => !isStatusDone(t.status));
+  const activeTaskRow = tasks.find(t => !isClosedStatus(t.status));
 
   if (!activeTaskRow && tasks.length > 0) {
     // All tasks done but slice not marked complete → summarizing
@@ -738,7 +747,7 @@ export async function deriveStateFromDb(basePath: string): Promise<GSDState> {
   }
 
   // ── Blocker detection: check completed tasks for blocker_discovered ──
-  const completedTasks = tasks.filter(t => isStatusDone(t.status));
+  const completedTasks = tasks.filter(t => isClosedStatus(t.status));
   let blockerTaskId: string | null = null;
   for (const ct of completedTasks) {
     if (ct.blocker_discovered) {

package/src/resources/extensions/gsd/status-guards.ts

@@ -0,0 +1,13 @@
+/**
+ * Status predicates for GSD state-machine guards.
+ *
+ * The DB stores status as free-form strings. Two values indicate
+ * "closed": "complete" (canonical) and "done" (legacy / alias).
+ * Every inline `status === "complete" || status === "done"` should
+ * use isClosedStatus() instead.
+ */
+
+/** Returns true when a milestone, slice, or task status indicates closure. */
+export function isClosedStatus(status: string): boolean {
+  return status === "complete" || status === "done";
+}

package/src/resources/extensions/gsd/tests/active-milestone-id-guard.test.ts

@@ -0,0 +1,91 @@
+/**
+ * Regression test for #2773 — activeMilestone.id guard
+ *
+ * When activeMilestone is a non-null object with `id: undefined` (corrupted
+ * state), the old `!state.activeMilestone` truthiness check passed through,
+ * causing a downstream crash when code assumed `.id` was a valid string.
+ *
+ * The fix uses optional chaining (`!state.activeMilestone?.id`) so all three
+ * "no usable milestone" shapes are caught:
+ *   1. activeMilestone === null
+ *   2. activeMilestone === undefined
+ *   3. activeMilestone === { id: undefined, title: "..." }
+ */
+
+import { describe, it } from 'node:test'
+import assert from 'node:assert/strict'
+
+import type { GSDState, ActiveRef } from '../types.ts'
+
+// ─── Guard Under Test ────────────────────────────────────────────────────────
+// Extracted guard logic identical to headless-query.ts (line 74) and
+// guided-flow.ts (lines 522, 1047).
+
+function activeMilestoneIsUsable(activeMilestone: ActiveRef | null | undefined): boolean {
+  return !!activeMilestone?.id
+}
+
+// ─── Tests ───────────────────────────────────────────────────────────────────
+
+describe('activeMilestone?.id guard (#2773)', () => {
+  it('rejects null activeMilestone', () => {
+    assert.equal(activeMilestoneIsUsable(null), false)
+  })
+
+  it('rejects undefined activeMilestone', () => {
+    assert.equal(activeMilestoneIsUsable(undefined), false)
+  })
+
+  it('rejects malformed activeMilestone with id: undefined', () => {
+    // This is the crash case from #2773 — object exists but id is undefined
+    const malformed = { id: undefined, title: 'Ghost Milestone' } as unknown as ActiveRef
+    assert.equal(activeMilestoneIsUsable(malformed), false)
+  })
+
+  it('rejects malformed activeMilestone with id: empty string', () => {
+    const malformed = { id: '', title: 'Empty ID Milestone' } as unknown as ActiveRef
+    assert.equal(activeMilestoneIsUsable(malformed), false)
+  })
+
+  it('accepts valid activeMilestone with a real id', () => {
+    const valid: ActiveRef = { id: 'M001', title: 'Real Milestone' }
+    assert.equal(activeMilestoneIsUsable(valid), true)
+  })
+})
+
+describe('headless-query stop behavior with corrupted milestone', () => {
+  // Simulates the decision logic from handleQuery (headless-query.ts:74-78)
+  function deriveNextAction(activeMilestone: ActiveRef | null | undefined, phase: string) {
+    if (!activeMilestone?.id) {
+      return {
+        action: 'stop' as const,
+        reason: phase === 'complete' ? 'All milestones complete.' : 'No active milestone.',
+      }
+    }
+    return { action: 'dispatch' as const, unitId: activeMilestone.id }
+  }
+
+  it('returns stop when activeMilestone is null', () => {
+    const result = deriveNextAction(null, 'pre-planning')
+    assert.equal(result.action, 'stop')
+  })
+
+  it('returns stop when activeMilestone has undefined id', () => {
+    const corrupted = { id: undefined, title: 'Corrupted' } as unknown as ActiveRef
+    const result = deriveNextAction(corrupted, 'executing')
+    assert.equal(result.action, 'stop')
+    assert.equal(result.reason, 'No active milestone.')
+  })
+
+  it('returns dispatch with valid milestone id', () => {
+    const valid: ActiveRef = { id: 'M001', title: 'Valid' }
+    const result = deriveNextAction(valid, 'executing')
+    assert.equal(result.action, 'dispatch')
+  })
+
+  it('returns correct stop reason when phase is complete', () => {
+    const result = deriveNextAction(null, 'complete')
+    assert.equal(result.action, 'stop')
+    assert.equal(result.reason, 'All milestones complete.')
+  })
+})

package/src/resources/extensions/gsd/tests/agent-end-retry.test.ts

@@ -102,7 +102,7 @@ test("pauseAuto calls resolveAgentEndCancelled to unblock the loop", () => {
   const fnBlock = source.slice(fnIdx, source.indexOf("\n/**\n * Build", fnIdx + 100));
 
   assert.ok(
-    fnBlock.includes("resolveAgentEndCancelled()"),
+    fnBlock.includes("resolveAgentEndCancelled("),
     "pauseAuto must call resolveAgentEndCancelled to unblock the auto-loop promise",
   );
 });

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

@@ -0,0 +1,61 @@
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+
+import { parseMilestoneTarget } from "../commands/handlers/auto.js";
+
+describe("parseMilestoneTarget", () => {
+  it("extracts a simple milestone ID", () => {
+    const result = parseMilestoneTarget("auto M016");
+    assert.equal(result.milestoneId, "M016");
+    assert.equal(result.rest, "auto");
+  });
+
+  it("extracts a milestone ID with unique suffix", () => {
+    const result = parseMilestoneTarget("auto M001-a3b4c5 --verbose");
+    assert.equal(result.milestoneId, "M001-a3b4c5");
+    assert.equal(result.rest, "auto --verbose");
+  });
+
+  it("returns null when no milestone ID is present", () => {
+    const result = parseMilestoneTarget("auto --verbose");
+    assert.equal(result.milestoneId, null);
+    assert.equal(result.rest, "auto --verbose");
+  });
+
+  it("extracts milestone ID with flags in any order", () => {
+    const result = parseMilestoneTarget("auto --verbose M003 --debug");
+    assert.equal(result.milestoneId, "M003");
+    assert.equal(result.rest, "auto --verbose --debug");
+  });
+
+  it("returns null for plain 'auto'", () => {
+    const result = parseMilestoneTarget("auto");
+    assert.equal(result.milestoneId, null);
+    assert.equal(result.rest, "auto");
+  });
+
+  it("extracts from 'next' command", () => {
+    const result = parseMilestoneTarget("next M012");
+    assert.equal(result.milestoneId, "M012");
+    assert.equal(result.rest, "next");
+  });
+
+  it("handles milestone ID at the start of input", () => {
+    const result = parseMilestoneTarget("M007");
+    assert.equal(result.milestoneId, "M007");
+    assert.equal(result.rest, "");
+  });
+
+  it("picks the first milestone ID when multiple appear", () => {
+    // Edge case: user accidentally types two. First one wins.
+    const result = parseMilestoneTarget("auto M001 M002");
+    assert.equal(result.milestoneId, "M001");
+    // M002 remains in rest since only the first match is removed
+    assert.ok(result.rest.includes("M002"));
+  });
+
+  it("does not match bare numbers without M prefix", () => {
+    const result = parseMilestoneTarget("auto 016");
+    assert.equal(result.milestoneId, null);
+  });
+});

package/src/resources/extensions/gsd/tests/auto-stale-lock-self-kill.test.ts

@@ -0,0 +1,87 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { mkdirSync, mkdtempSync, writeFileSync, existsSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { writeLock, readCrashLock, clearLock } from "../crash-recovery.ts";
+import { checkRemoteAutoSession, stopAutoRemote } from "../auto.ts";
+
+function makeTmpProject(): string {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-stale-lock-test-"));
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  return dir;
+}
+
+// ─── checkRemoteAutoSession: own-PID filtering (#2730) ───────────────────
+
+test("#2730: checkRemoteAutoSession returns { running: false } when lock PID matches current process", (t) => {
+  const dir = makeTmpProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // Write a lock with the current process PID — simulates a stale lock
+  // left behind after step-mode exit without full cleanup.
+  writeLock(dir, "execute-task", "M001/S01/T01");
+
+  const lock = readCrashLock(dir);
+  assert.ok(lock, "lock file should exist");
+  assert.equal(lock!.pid, process.pid, "lock should have our PID");
+
+  const result = checkRemoteAutoSession(dir);
+  assert.equal(result.running, false, "own PID must not be treated as a remote session");
+});
+
+test("#2730: checkRemoteAutoSession still detects a genuine remote session (different PID)", (t) => {
+  const dir = makeTmpProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // Use parent PID — guaranteed alive, guaranteed not our PID.
+  const remotePid = process.ppid;
+  const lockData = {
+    pid: remotePid,
+    startedAt: new Date().toISOString(),
+    unitType: "execute-task",
+    unitId: "M001/S01/T02",
+    unitStartedAt: new Date().toISOString(),
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
+
+  const result = checkRemoteAutoSession(dir);
+  assert.equal(result.running, true, "different live PID should be detected as running");
+  assert.equal(result.pid, remotePid);
+});
+
+// ─── stopAutoRemote: self-kill prevention (#2730) ────────────────────────
+
+test("#2730: stopAutoRemote does not send SIGTERM when lock PID matches current process", (t) => {
+  const dir = makeTmpProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // Write a lock with our own PID
+  writeLock(dir, "execute-task", "M001/S01/T01");
+
+  const result = stopAutoRemote(dir);
+  assert.equal(result.found, false, "own PID must not be signalled");
+
+  // The lock should be cleared as part of the self-detection cleanup
+  assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "stale self-lock should be cleared");
+});
+
+test("#2730: stopAutoRemote clears stale lock from dead remote process without error", (t) => {
+  const dir = makeTmpProject();
+  t.after(() => rmSync(dir, { recursive: true, force: true }));
+
+  // Simulate a stale lock from a process that no longer exists
+  const lockData = {
+    pid: 9999999,
+    startedAt: "2026-03-01T00:00:00Z",
+    unitType: "plan-slice",
+    unitId: "M001/S02",
+    unitStartedAt: "2026-03-01T00:05:00Z",
+  };
+  writeFileSync(join(dir, ".gsd", "auto.lock"), JSON.stringify(lockData, null, 2));
+
+  const result = stopAutoRemote(dir);
+  assert.equal(result.found, false, "dead remote PID should not be reported as found");
+  assert.ok(!existsSync(join(dir, ".gsd", "auto.lock")), "stale lock should be cleaned up");
+});

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

@@ -0,0 +1,80 @@
+/**
+ * auto-worktree-auto-resolve.test.ts — Unit tests for isSafeToAutoResolve.
+ *
+ * Covers: .gsd/ state files, build artifacts (.tsbuildinfo, .pyc, __pycache__,
+ * .DS_Store, .map), and rejection of real source files.
+ */
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  isSafeToAutoResolve,
+  SAFE_AUTO_RESOLVE_PATTERNS,
+} from "../auto-worktree.ts";
+
+describe("isSafeToAutoResolve", () => {
+  // ─── .gsd/ state files ───────────────────────────────────────────────────
+  test("returns true for .gsd/ prefixed paths", () => {
+    assert.ok(isSafeToAutoResolve(".gsd/STATE.md"));
+    assert.ok(isSafeToAutoResolve(".gsd/milestones/M001/CONTEXT.md"));
+    assert.ok(isSafeToAutoResolve(".gsd/gsd.db"));
+  });
+
+  // ─── Build artifact patterns ─────────────────────────────────────────────
+  test("returns true for .tsbuildinfo files", () => {
+    assert.ok(isSafeToAutoResolve("tsconfig.tsbuildinfo"));
+    assert.ok(isSafeToAutoResolve("dist/tsconfig.tsbuildinfo"));
+  });
+
+  test("returns true for .pyc files", () => {
+    assert.ok(isSafeToAutoResolve("module.pyc"));
+    assert.ok(isSafeToAutoResolve("src/utils/helpers.pyc"));
+  });
+
+  test("returns true for __pycache__/ paths", () => {
+    assert.ok(isSafeToAutoResolve("src/__pycache__/module.cpython-311.pyc"));
+    assert.ok(isSafeToAutoResolve("lib/__pycache__/foo.py"));
+  });
+
+  test("returns true for .DS_Store files", () => {
+    assert.ok(isSafeToAutoResolve(".DS_Store"));
+    assert.ok(isSafeToAutoResolve("src/.DS_Store"));
+  });
+
+  test("returns true for .map source map files", () => {
+    assert.ok(isSafeToAutoResolve("dist/index.js.map"));
+    assert.ok(isSafeToAutoResolve("out/bundle.css.map"));
+  });
+
+  // ─── Real source files (should NOT be auto-resolved) ─────────────────────
+  test("returns false for .ts source files", () => {
+    assert.ok(!isSafeToAutoResolve("src/index.ts"));
+    assert.ok(!isSafeToAutoResolve("lib/utils.ts"));
+  });
+
+  test("returns false for .js source files", () => {
+    assert.ok(!isSafeToAutoResolve("src/index.js"));
+    assert.ok(!isSafeToAutoResolve("lib/helpers.js"));
+  });
+
+  test("returns false for .py source files", () => {
+    assert.ok(!isSafeToAutoResolve("src/main.py"));
+    assert.ok(!isSafeToAutoResolve("scripts/deploy.py"));
+  });
+
+  test("returns false for config and data files", () => {
+    assert.ok(!isSafeToAutoResolve("package.json"));
+    assert.ok(!isSafeToAutoResolve("tsconfig.json"));
+    assert.ok(!isSafeToAutoResolve("README.md"));
+  });
+
+  // ─── SAFE_AUTO_RESOLVE_PATTERNS export ────────────────────────────────────
+  test("SAFE_AUTO_RESOLVE_PATTERNS is a non-empty array of RegExp", () => {
+    assert.ok(Array.isArray(SAFE_AUTO_RESOLVE_PATTERNS));
+    assert.ok(SAFE_AUTO_RESOLVE_PATTERNS.length > 0);
+    for (const pattern of SAFE_AUTO_RESOLVE_PATTERNS) {
+      assert.ok(pattern instanceof RegExp);
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/auto-worktree-milestone-merge.test.ts

@@ -77,7 +77,7 @@ function addSliceToMilestone(
   run(`git branch -d ${sliceBranch}`, wtPath);
 }
 
-describe("auto-worktree-milestone-merge", () => {
+describe("auto-worktree-milestone-merge", { timeout: 300_000 }, () => {
   const savedCwd = process.cwd();
   const tempDirs: string[] = [];