gsd-pi 2.76.0 → 2.77.0-dev.1594b263e

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

@@ -46,6 +46,7 @@ import { logWarning, logError } from './workflow-logger.js';
 import { extractVerdict } from './verdict-parser.js';
 import { loadEffectiveGSDPreferences } from './preferences.js';
 import { detectPendingEscalation } from './escalation.js';
+import { isTerminalMilestoneSummaryContent } from './milestone-summary-classifier.js';
 
 import {
   isDbAvailable,
@@ -139,6 +140,14 @@ export function isValidationTerminal(validationContent: string): boolean {
   return extractVerdict(validationContent) != null;
 }
 
+async function isTerminalMilestoneSummaryFile(
+  path: string,
+  loader: (path: string) => Promise<string | null>,
+): Promise<boolean> {
+  const content = await loader(path);
+  return content != null && isTerminalMilestoneSummaryContent(content);
+}
+
 // ─── State Derivation ──────────────────────────────────────────────────────
 
 // ── deriveState memoization ─────────────────────────────────────────────────
@@ -211,15 +220,15 @@ export async function getActiveMilestoneId(basePath: string): Promise<string | n
     const content = roadmapFile ? await loadFile(roadmapFile) : null;
     if (!content) {
       const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
-      if (summaryFile) continue;
+      if (summaryFile && await isTerminalMilestoneSummaryFile(summaryFile, loadFile)) continue;
       if (isGhostMilestone(basePath, mid)) continue;
       return mid;
     }
     const roadmap = parseRoadmap(content);
-    if (!isMilestoneComplete(roadmap)) {
-      const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
-      if (!summaryFile) return mid;
-    }
+    const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
+    if (summaryFile && await isTerminalMilestoneSummaryFile(summaryFile, loadFile)) continue;
+    if (!isMilestoneComplete(roadmap)) return mid;
+    return mid;
   }
   return null;
 }
@@ -258,7 +267,7 @@ export async function deriveState(basePath: string): Promise<GSDState> {
       let synced = false;
       for (const diskId of diskIds) {
         if (!isGhostMilestone(basePath, diskId)) {
-          insertMilestone({ id: diskId, status: 'active' });
+          insertMilestone(diskMilestoneInsert(basePath, diskId));
           synced = true;
         }
       }
@@ -318,6 +327,42 @@ function extractContextTitle(content: string | null, fallback: string): string {
 // Alias kept for backward compatibility within this file.
 const isStatusDone = isClosedStatus;
 
+function loadSync(path: string | null): string | null {
+  if (!path) return null;
+  try {
+    return readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+}
+
+function diskMilestoneInsert(basePath: string, mid: string): {
+  id: string;
+  title?: string;
+  status: string;
+  depends_on: string[];
+} {
+  const contextContent = loadSync(resolveMilestoneFile(basePath, mid, "CONTEXT"));
+  const draftContent = !contextContent ? loadSync(resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT")) : null;
+  const roadmapContent = loadSync(resolveMilestoneFile(basePath, mid, "ROADMAP"));
+  const summaryContent = loadSync(resolveMilestoneFile(basePath, mid, "SUMMARY"));
+  const roadmap = roadmapContent ? parseRoadmap(roadmapContent) : null;
+  const summary = summaryContent ? parseSummary(summaryContent) : null;
+  const summaryTerminal = summaryContent != null && isTerminalMilestoneSummaryContent(summaryContent);
+  const parked = resolveMilestoneFile(basePath, mid, "PARKED") !== null;
+
+  return {
+    id: mid,
+    title: roadmap
+      ? stripMilestonePrefix(roadmap.title)
+      : (contextContent || draftContent)
+        ? extractContextTitle(contextContent || draftContent, mid)
+        : (summary?.title || mid),
+    status: parked ? "parked" : summaryTerminal ? "complete" : "active",
+    depends_on: parseContextDependsOn(contextContent ?? draftContent),
+  };
+}
+
 /**
  * Derive GSD state from the milestones/slices/tasks DB tables.
  * Flag files (PARKED, VALIDATION, CONTINUE, REPLAN, REPLAN-TRIGGER, CONTEXT-DRAFT)
@@ -333,7 +378,7 @@ function reconcileDiskToDb(basePath: string): MilestoneRow[] {
   let synced = false;
   for (const diskId of diskIds) {
     if (!dbIdSet.has(diskId) && !isGhostMilestone(basePath, diskId)) {
-      insertMilestone({ id: diskId, status: 'active' });
+      insertMilestone(diskMilestoneInsert(basePath, diskId));
       synced = true;
     }
   }
@@ -613,7 +658,7 @@ async function handleAllSlicesDone(
   const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
   const verdict = validationContent ? extractVerdict(validationContent) : undefined;
 
-  if (!validationTerminal || verdict === 'needs-remediation') {
+  if (!validationTerminal) {
     return {
       activeMilestone, activeSlice: null, activeTask: null,
       phase: 'validating-milestone',
@@ -624,6 +669,24 @@ async function handleAllSlicesDone(
     };
   }
 
+  // All roadmap slices are done (enforced by caller) and verdict is
+  // needs-remediation — remediation cannot progress without new slices.
+  // Return blocked instead of re-dispatching validate-milestone (#4506).
+  if (verdict === 'needs-remediation') {
+    return {
+      activeMilestone, activeSlice: null, activeTask: null,
+      phase: 'blocked',
+      recentDecisions: [],
+      blockers: [
+        `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
+          `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+      ],
+      nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
+      registry, requirements,
+      progress: { milestones: milestoneProgress, slices: sliceProgress },
+    };
+  }
+
   return {
     activeMilestone, activeSlice: null, activeTask: null,
     phase: 'completing-milestone',
@@ -650,37 +713,12 @@ function resolveSliceDependencies(activeMilestoneSlices: SliceRow[]): { activeSl
     }
   }
 
-  // First pass: find a slice with ALL dependencies satisfied (strict)
-  let bestFallback: SliceRow | null = null;
-  let bestFallbackSatisfied = -1;
-
   for (const s of activeMilestoneSlices) {
     if (isStatusDone(s.status)) continue;
     if (isDeferredStatus(s.status)) continue;
     if (s.depends.every(dep => doneSliceIds.has(dep))) {
       return { activeSlice: { id: s.id, title: s.title }, activeSliceRow: s };
     }
-    // Track the slice with the most satisfied dependencies as fallback
-    const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
-    if (satisfied > bestFallbackSatisfied || (satisfied === bestFallbackSatisfied && !bestFallback)) {
-      bestFallback = s;
-      bestFallbackSatisfied = satisfied;
-    }
-  }
-
-  // Fallback: if no slice has all deps met but there ARE incomplete non-deferred
-  // slices, pick the one with the most deps satisfied. This prevents hard-blocking
-  // when dependency metadata is stale (e.g. after reassessment added/removed slices)
-  // or when deps reference slices from previous milestones.
-  if (bestFallback) {
-    const unmet = bestFallback.depends.filter(dep => !doneSliceIds.has(dep));
-    logWarning("state",
-      `No slice has all deps satisfied — falling back to ${bestFallback.id} ` +
-      `(${bestFallbackSatisfied}/${bestFallback.depends.length} deps met, ` +
-      `unmet: ${unmet.join(", ")})`,
-      { mid: activeMilestoneSlices[0]?.milestone_id, sid: bestFallback.id },
-    );
-    return { activeSlice: { id: bestFallback.id, title: bestFallback.title }, activeSliceRow: bestFallback };
   }
 
   return { activeSlice: null, activeSliceRow: null };
@@ -694,14 +732,19 @@ async function reconcileSliceTasks(
 ): Promise<TaskRow[]> {
   let tasks = getSliceTasks(milestoneId, sliceId);
 
-  if (tasks.length === 0 && planFile) {
+  // #3600/#4974: import missing plan-file tasks even when the DB already has
+  // a partial task set. Existing DB task statuses stay authoritative.
+  if (planFile) {
     try {
       const planContent = await loadFile(planFile);
       if (planContent) {
         const diskPlan = parsePlan(planContent);
         if (diskPlan.tasks.length > 0) {
+          const dbTaskIds = new Set(tasks.map(t => t.id));
+          let inserted = 0;
           for (let i = 0; i < diskPlan.tasks.length; i++) {
             const t = diskPlan.tasks[i];
+            if (dbTaskIds.has(t.id)) continue;
             try {
               insertTask({
                 id: t.id,
@@ -711,12 +754,15 @@ async function reconcileSliceTasks(
                 status: t.done ? 'complete' : 'pending',
                 sequence: i + 1,
               });
+              inserted++;
             } catch (insertErr) {
               logWarning("reconcile", `failed to insert task ${t.id} from plan file: ${insertErr instanceof Error ? insertErr.message : String(insertErr)}`);
             }
           }
-          tasks = getSliceTasks(milestoneId, sliceId);
-          logWarning("reconcile", `imported ${tasks.length} tasks from plan file for ${milestoneId}/${sliceId} — DB was empty (#3600)`, { mid: milestoneId, sid: sliceId });
+          if (inserted > 0) {
+            tasks = getSliceTasks(milestoneId, sliceId);
+            logWarning("reconcile", `imported ${inserted} missing task(s) from plan file for ${milestoneId}/${sliceId}`, { mid: milestoneId, sid: sliceId });
+          }
         }
       }
     } catch (err) {
@@ -1142,7 +1188,7 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
     const rc = rf ? await cachedLoadFile(rf) : null;
     if (!rc) {
       const sf = resolveMilestoneFile(basePath, mid, "SUMMARY");
-      if (sf) completeMilestoneIds.add(mid);
+      if (sf && await isTerminalMilestoneSummaryFile(sf, cachedLoadFile)) completeMilestoneIds.add(mid);
       continue;
     }
     const rmap = parseRoadmap(rc);
@@ -1151,11 +1197,11 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       // Summary is the terminal artifact — if it exists, the milestone is
       // complete even when roadmap checkboxes weren't ticked (#864).
       const sf = resolveMilestoneFile(basePath, mid, "SUMMARY");
-      if (sf) completeMilestoneIds.add(mid);
+      if (sf && await isTerminalMilestoneSummaryFile(sf, cachedLoadFile)) completeMilestoneIds.add(mid);
       continue;
     }
     const sf = resolveMilestoneFile(basePath, mid, "SUMMARY");
-    if (sf) completeMilestoneIds.add(mid);
+    if (sf && await isTerminalMilestoneSummaryFile(sf, cachedLoadFile)) completeMilestoneIds.add(mid);
   }
 
   // Phase 2: Build registry using cached roadmaps (no re-parsing or re-reading)
@@ -1183,12 +1229,14 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
       if (summaryFile) {
         const summaryContent = await cachedLoadFile(summaryFile);
-        const summaryTitle = summaryContent
-          ? (parseSummary(summaryContent).title || mid)
-          : mid;
-        registry.push({ id: mid, title: summaryTitle, status: 'complete' });
-        completeMilestoneIds.add(mid);
-        continue;
+        if (summaryContent != null && isTerminalMilestoneSummaryContent(summaryContent)) {
+          const summaryTitle = summaryContent
+            ? (parseSummary(summaryContent).title || mid)
+            : mid;
+          registry.push({ id: mid, title: summaryTitle, status: 'complete' });
+          completeMilestoneIds.add(mid);
+          continue;
+        }
       }
       // Ghost milestone (only META.json, no CONTEXT/ROADMAP/SUMMARY) — skip entirely
       if (isGhostMilestone(basePath, mid)) continue;
@@ -1244,7 +1292,7 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       // needs-remediation is terminal but requires re-validation (#3596)
       const needsRevalidation = !validationTerminal || verdict === 'needs-remediation';
 
-      if (summaryFile) {
+      if (summaryFile && await isTerminalMilestoneSummaryFile(summaryFile, cachedLoadFile)) {
         // Summary exists → milestone is complete regardless of validation state.
         // The summary is the terminal artifact (#864).
         registry.push({ id: mid, title, status: 'complete' });
@@ -1270,7 +1318,7 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       // Roadmap slices not all checked — but if a summary exists, the milestone
       // is still complete. The summary is the terminal artifact (#864).
       const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
-      if (summaryFile) {
+      if (summaryFile && await isTerminalMilestoneSummaryFile(summaryFile, cachedLoadFile)) {
         registry.push({ id: mid, title, status: 'complete' });
       } else if (!activeMilestoneFound) {
         // Check milestone-level dependencies before promoting to active.
@@ -1450,9 +1498,11 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       total: activeRoadmap.slices.length,
     };
 
-    // Force re-validation when verdict is needs-remediation — remediation slices
-    // may have completed since the stale validation was written (#3596).
-    if (!validationTerminal || verdict === 'needs-remediation') {
+    // Force re-validation when VALIDATION.md is absent or non-terminal —
+    // remediation slices may have completed since the stale validation was
+    // written (#3596). But needs-remediation with all slices done is a dead
+    // end — return blocked to avoid an infinite dispatch loop (#4506).
+    if (!validationTerminal) {
       return {
         activeMilestone,
         activeSlice: null,
@@ -1470,6 +1520,27 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       };
     }
 
+    if (verdict === 'needs-remediation') {
+      return {
+        activeMilestone,
+        activeSlice: null,
+        activeTask: null,
+        phase: 'blocked',
+        recentDecisions: [],
+        blockers: [
+          `Milestone ${activeMilestone.id} validation verdict is needs-remediation but all slices are complete. ` +
+            `Add remediation slices via gsd_reassess_roadmap or override the verdict manually.`,
+        ],
+        nextAction: `Resolve ${activeMilestone.id} remediation before proceeding.`,
+        registry,
+        requirements,
+        progress: {
+          milestones: milestoneProgress,
+          slices: sliceProgress,
+        },
+      };
+    }
+
     return {
       activeMilestone,
       activeSlice: null,
@@ -1522,32 +1593,12 @@ export async function _deriveStateImpl(basePath: string): Promise<GSDState> {
       };
     }
   } else {
-    let bestFallbackLegacy: { id: string; title: string; depends: string[] } | null = null;
-    let bestFallbackLegacySatisfied = -1;
-
     for (const s of activeRoadmap.slices) {
       if (s.done) continue;
       if (s.depends.every(dep => doneSliceIds.has(dep))) {
         activeSlice = { id: s.id, title: s.title };
         break;
       }
-      // Track best fallback
-      const satisfied = s.depends.filter(dep => doneSliceIds.has(dep)).length;
-      if (satisfied > bestFallbackLegacySatisfied) {
-        bestFallbackLegacy = s;
-        bestFallbackLegacySatisfied = satisfied;
-      }
-    }
-
-    // Fallback: if no slice has all deps met, pick the one with the most deps satisfied
-    if (!activeSlice && bestFallbackLegacy) {
-      const unmet = bestFallbackLegacy.depends.filter(dep => !doneSliceIds.has(dep));
-      logWarning("state",
-        `No slice has all deps satisfied — falling back to ${bestFallbackLegacy.id} ` +
-        `(${bestFallbackLegacySatisfied}/${bestFallbackLegacy.depends.length} deps met, ` +
-        `unmet: ${unmet.join(", ")})`,
-      );
-      activeSlice = { id: bestFallbackLegacy.id, title: bestFallbackLegacy.title };
     }
   }
 

package/src/resources/extensions/gsd/sync-lock.ts

@@ -1,11 +1,10 @@
 // GSD Extension — Advisory Sync Lock
 // Prevents concurrent worktree syncs from colliding via a simple file lock.
-// Stale locks (mtime > 60s) are auto-overridden. Lock acquisition waits up
-// to 5 seconds then skips non-fatally.
+// Stale locks (mtime > 60s, owner PID confirmed dead) are overridden. Lock
+// acquisition waits up to 5 seconds then skips non-fatally.
 
-import { existsSync, statSync, unlinkSync } from "node:fs";
-import { join } from "node:path";
-import { atomicWriteSync } from "./atomic-write.js";
+import { closeSync, existsSync, mkdirSync, openSync, readFileSync, statSync, unlinkSync, writeSync } from "node:fs";
+import { dirname, join } from "node:path";
 
 const STALE_THRESHOLD_MS = 60_000; // 60 seconds
 const DEFAULT_TIMEOUT_MS = 5_000;  // 5 seconds
@@ -23,13 +22,59 @@ function sleepSync(ms: number): void {
   Atomics.wait(SLEEP_VIEW, 0, 0, ms);
 }
 
+/** True if the given PID is alive in the current process namespace. */
+function isPidAlive(pid: number): boolean {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (err) {
+    if ((err as NodeJS.ErrnoException).code === "EPERM") return true;
+    return false;
+  }
+}
+
+/**
+ * Atomically create the lock file with `O_EXCL` semantics. Returns true on
+ * exclusive create, false if the file already existed. Any other error
+ * propagates.
+ */
+function tryCreateLockFile(lp: string, payload: string): boolean {
+  // Ensure parent dir exists (`atomicWriteSync` previously did this implicitly).
+  try {
+    mkdirSync(dirname(lp), { recursive: true });
+  } catch {
+    /* best-effort */
+  }
+  let fd: number;
+  try {
+    // "wx" → O_WRONLY | O_CREAT | O_EXCL — atomic create-if-not-exists on POSIX.
+    fd = openSync(lp, "wx");
+  } catch (err) {
+    const code = (err as NodeJS.ErrnoException).code;
+    if (code === "EEXIST") return false;
+    throw err;
+  }
+  try {
+    writeSync(fd, payload);
+  } finally {
+    closeSync(fd);
+  }
+  return true;
+}
+
 /**
  * Acquire an advisory sync lock for the given basePath.
  * Returns { acquired: true } on success, { acquired: false } after timeout.
  *
- * - Creates lock file at {basePath}/.gsd/sync.lock with JSON { pid, acquired_at }
- * - If lock exists and mtime > 60s (stale), overrides it
- * - If lock exists and not stale, spins up to timeoutMs before giving up
+ * Replaces a non-atomic `existsSync` + `atomicWriteSync` (write-temp+rename,
+ * which is not exclusive-create) sequence that allowed two callers to both
+ * believe they had acquired the lock, corrupting the event log.
+ * (Issue #4980 CRIT-4)
+ *
+ * Stale-lock override now also verifies the recorded owner PID is dead
+ * before stealing — prevents a slow event-loop pause (>60s under heavy I/O)
+ * from making a legitimately-held lock appear stale and get stolen.
+ * (Issue #4980 M-concurrency-3)
  */
 export function acquireSyncLock(
   basePath: string,
@@ -37,45 +82,58 @@ export function acquireSyncLock(
 ): { acquired: boolean } {
   const lp = lockFilePath(basePath);
   const deadline = Date.now() + timeoutMs;
+  const lockData = JSON.stringify(
+    { pid: process.pid, acquired_at: new Date().toISOString() },
+    null,
+    2,
+  );
 
   while (true) {
-    // Check if lock file exists
-    if (existsSync(lp)) {
-      // Check staleness
-      try {
-        const stat = statSync(lp);
-        const age = Date.now() - stat.mtimeMs;
-        if (age > STALE_THRESHOLD_MS) {
-          // Stale lock — override it
-          try { unlinkSync(lp); } catch { /* race: already removed */ }
-        } else {
-          // Lock is held and not stale — wait or give up
-          if (Date.now() >= deadline) {
-            return { acquired: false };
-          }
-          sleepSync(SPIN_INTERVAL_MS);
-          continue;
-        }
-      } catch {
-        // stat failed (file removed between exists check and stat) — try to acquire
+    // First try the fast path: atomic create. No check-then-write race.
+    try {
+      if (tryCreateLockFile(lp, lockData)) {
+        return { acquired: true };
       }
+    } catch {
+      /* unexpected — fall through to retry */
     }
 
-    // Lock file does not exist (or was just removed) — try to write it
+    // File exists. Decide whether to steal (stale + owner dead) or wait.
+    let canSteal = false;
     try {
-      const lockData = {
-        pid: process.pid,
-        acquired_at: new Date().toISOString(),
-      };
-      atomicWriteSync(lp, JSON.stringify(lockData, null, 2));
-      return { acquired: true };
-    } catch {
-      // Write failed (race condition with another process) — retry or give up
-      if (Date.now() >= deadline) {
-        return { acquired: false };
+      const stat = statSync(lp);
+      const age = Date.now() - stat.mtimeMs;
+      if (age > STALE_THRESHOLD_MS) {
+        // Verify the recorded owner PID is dead before stealing.
+        let ownerAlive = false;
+        try {
+          const data = JSON.parse(readFileSync(lp, "utf-8")) as { pid?: number };
+          if (typeof data.pid === "number" && data.pid !== process.pid) {
+            ownerAlive = isPidAlive(data.pid);
+          }
+        } catch {
+          // Lock contents unreadable — be conservative and steal only on age.
+          // A garbage lock file that we cannot parse is safer to remove than
+          // to leave wedging the lock indefinitely.
+        }
+        canSteal = !ownerAlive;
       }
-      sleepSync(SPIN_INTERVAL_MS);
+    } catch {
+      // stat failed (file removed between exists and stat) — retry create.
+      continue;
+    }
+
+    if (canSteal) {
+      try { unlinkSync(lp); } catch { /* race: already removed */ }
+      // Loop back to retry create.
+      continue;
+    }
+
+    // Lock is held and not stale (or owner is alive) — wait or give up.
+    if (Date.now() >= deadline) {
+      return { acquired: false };
     }
+    sleepSync(SPIN_INTERVAL_MS);
   }
 }