gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/src/resources/extensions/gsd/auto-recovery.ts

@@ -11,7 +11,9 @@ import type { ExtensionContext } from "@gsd/pi-coding-agent";
 import { parseUnitId } from "./unit-id.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearUnitRuntimeRecord } from "./unit-runtime.js";
-import { clearParseCache, parseRoadmap, parsePlan } from "./files.js";
+import { clearParseCache } from "./files.js";
+import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
+import { isDbAvailable, getTask, getSlice, getSliceTasks } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import {
   nativeConflictFiles,
@@ -38,7 +40,6 @@ import {
   clearPathCache,
   resolveGsdRootFile,
 } from "./paths.js";
-import { markSliceDoneInRoadmap } from "./roadmap-mutations.js";
 import {
   existsSync,
   mkdirSync,
@@ -325,25 +326,34 @@ export function verifyExpectedArtifact(
     if (!hasCheckboxTask && !hasHeadingTask) return false;
   }
 
-  // execute-task must also have its checkbox marked [x] in the slice plan.
-  // Heading-style plans (### T01 -- Title) have no checkbox — the task summary
-  // file existence (checked above via resolveExpectedArtifactPath) is sufficient.
+  // execute-task: DB status is authoritative. Fall back to heading-style plan
+  // detection when the DB is unavailable (unmigrated projects).
   if (unitType === "execute-task") {
     const parts = unitId.split("/");
     const mid = parts[0];
     const sid = parts[1];
     const tid = parts[2];
     if (mid && sid && tid) {
-      const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
-      if (planAbs && existsSync(planAbs)) {
-        const planContent = readFileSync(planAbs, "utf-8");
-        const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-        const cbRe = new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m");
-        const hdRe = new RegExp(`^#{2,4}\\s+${escapedTid}\\s*(?:--|—|:)`, "m");
-        // Heading-style entries count as verified (no checkbox to toggle);
-        // checkbox-style entries require [x].
-        if (!cbRe.test(planContent) && !hdRe.test(planContent)) return false;
+      const dbTask = getTask(mid, sid, tid);
+      if (dbTask) {
+        // DB available — trust it
+        if (dbTask.status !== "complete" && dbTask.status !== "done") return false;
+      } else if (!isDbAvailable()) {
+        // LEGACY: Pre-migration fallback for projects without DB.
+        // Fall back to plan heading check (format detection, not reconciliation).
+        // Heading-style entries (### T01 --) count as verified because the
+        // summary file existence (checked above) is the real signal.
+        const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
+        if (planAbs && existsSync(planAbs)) {
+          const planContent = readFileSync(planAbs, "utf-8");
+          const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+          const hdRe = new RegExp(`^#{2,4}\\s+${escapedTid}\\s*(?:--|—|:)`, "m");
+          const cbRe = new RegExp(`^- \\[[xX]\\] \\*\\*${escapedTid}:`, "m");
+          if (!hdRe.test(planContent) && !cbRe.test(planContent)) return false;
+        }
       }
+      // else: DB available but task not found — summary file exists (checked above),
+      // so treat as verified (task may not be imported yet)
     }
   }
 
@@ -357,13 +367,27 @@ export function verifyExpectedArtifact(
     const sid = parts[1];
     if (mid && sid) {
       try {
-        const planContent = readFileSync(absPath, "utf-8");
-        const plan = parsePlan(planContent);
-        const tasksDir = resolveTasksDir(base, mid, sid);
-        if (plan.tasks.length > 0 && tasksDir) {
-          for (const task of plan.tasks) {
-            const taskPlanFile = join(tasksDir, `${task.id}-PLAN.md`);
-            if (!existsSync(taskPlanFile)) return false;
+        // DB primary path — get task IDs to verify task plan files exist
+        let taskIds: string[] | null = null;
+        if (isDbAvailable()) {
+          const tasks = getSliceTasks(mid, sid);
+          if (tasks.length > 0) taskIds = tasks.map(t => t.id);
+        }
+
+        if (!taskIds) {
+          // LEGACY: DB unavailable or no tasks in DB — parse plan file for task IDs
+          const planContent = readFileSync(absPath, "utf-8");
+          const plan = parseLegacyPlan(planContent);
+          if (plan.tasks.length > 0) taskIds = plan.tasks.map((t: { id: string }) => t.id);
+        }
+
+        if (taskIds && taskIds.length > 0) {
+          const tasksDir = resolveTasksDir(base, mid, sid);
+          if (tasksDir) {
+            for (const tid of taskIds) {
+              const taskPlanFile = join(tasksDir, `${tid}-PLAN.md`);
+              if (!existsSync(taskPlanFile)) return false;
+            }
           }
         }
       } catch {
@@ -372,11 +396,8 @@ export function verifyExpectedArtifact(
     }
   }
 
-  // complete-slice must also produce a UAT file AND mark the slice [x] in the roadmap.
-  // Without the roadmap check, a crash after writing SUMMARY+UAT but before updating
-  // the roadmap causes an infinite skip loop: the idempotency key says "done" but the
-  // state machine keeps returning the same complete-slice unit (roadmap still shows
-  // the slice incomplete), so dispatchNextUnit recurses forever.
+  // complete-slice: DB status is authoritative for whether the slice is done.
+  // Fall back to file-based check (roadmap [x]) when DB is unavailable.
   if (unitType === "complete-slice") {
     const parts = unitId.split("/");
     const mid = parts[0];
@@ -387,22 +408,28 @@ export function verifyExpectedArtifact(
         const uatPath = join(dir, buildSliceFileName(sid, "UAT"));
         if (!existsSync(uatPath)) return false;
       }
-      // Verify the roadmap has the slice marked [x]. If not, the completion
-      // record is stale — the unit must re-run to update the roadmap.
-      const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-      if (roadmapFile && existsSync(roadmapFile)) {
-        try {
-          const roadmapContent = readFileSync(roadmapFile, "utf-8");
-          const roadmap = parseRoadmap(roadmapContent);
-          const slice = roadmap.slices.find((s) => s.id === sid);
-          if (slice && !slice.done) return false;
-        } catch {
-          // Corrupt/unparseable roadmap — fail verification so the unit
-          // re-runs and has a chance to fix the roadmap. Silently passing
-          // here could advance past an incomplete slice.
-          return false;
+
+      const dbSlice = getSlice(mid, sid);
+      if (dbSlice) {
+        // DB available — trust it
+        if (dbSlice.status !== "complete") return false;
+      } else if (!isDbAvailable()) {
+        // LEGACY: Pre-migration fallback for projects without DB.
+        // Fall back to roadmap checkbox check via parsers-legacy
+        const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
+        if (roadmapFile && existsSync(roadmapFile)) {
+          try {
+            const roadmapContent = readFileSync(roadmapFile, "utf-8");
+            const roadmap = parseLegacyRoadmap(roadmapContent);
+            const slice = roadmap.slices.find((s) => s.id === sid);
+            if (slice && !slice.done) return false;
+          } catch {
+            return false;
+          }
         }
       }
+      // else: DB available but slice not found — summary + UAT exist,
+      // treat as verified (slice may not be imported yet)
     }
   }
 
@@ -486,61 +513,6 @@ export function diagnoseExpectedArtifact(
   }
 }
 
-// ─── Skip / Blocker Artifact Generation ───────────────────────────────────────
-
-/**
- * Write skip artifacts for a stuck execute-task: a blocker task summary and
- * the [x] checkbox in the slice plan. Returns true if artifacts were written.
- */
-export function skipExecuteTask(
-  base: string,
-  mid: string,
-  sid: string,
-  tid: string,
-  status: { summaryExists: boolean; taskChecked: boolean },
-  reason: string,
-  maxAttempts: number,
-): boolean {
-  // Write a blocker task summary if missing.
-  if (!status.summaryExists) {
-    const tasksDir = resolveTasksDir(base, mid, sid);
-    const sDir = resolveSlicePath(base, mid, sid);
-    const targetDir = tasksDir ?? (sDir ? join(sDir, "tasks") : null);
-    if (!targetDir) return false;
-    if (!existsSync(targetDir)) mkdirSync(targetDir, { recursive: true });
-    const summaryPath = join(targetDir, buildTaskFileName(tid, "SUMMARY"));
-    const content = [
-      `# BLOCKER — task skipped by auto-mode recovery`,
-      ``,
-      `Task \`${tid}\` in slice \`${sid}\` (milestone \`${mid}\`) failed to complete after ${reason} recovery exhausted ${maxAttempts} attempts.`,
-      ``,
-      `This placeholder was written by auto-mode so the pipeline can advance.`,
-      `Review this task manually and replace this file with a real summary.`,
-    ].join("\n");
-    writeFileSync(summaryPath, content, "utf-8");
-  }
-
-  // Mark [x] in the slice plan if not already checked.
-  if (!status.taskChecked) {
-    const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
-    if (planAbs && existsSync(planAbs)) {
-      const planContent = readFileSync(planAbs, "utf-8");
-      const escapedTid = tid.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-      const re = new RegExp(`^(- \\[) \\] (\\*\\*${escapedTid}:)`, "m");
-      if (re.test(planContent)) {
-        writeFileSync(planAbs, planContent.replace(re, "$1x] $2"), "utf-8");
-      } else {
-        // Regex didn't match — checkbox format differs from expected pattern.
-        // Return false so callers know the plan was NOT updated and can
-        // fall through to other recovery strategies instead of assuming success.
-        return false;
-      }
-    }
-  }
-
-  return true;
-}
-
 // ─── Merge State Reconciliation ───────────────────────────────────────────────
 
 /**
@@ -672,41 +644,8 @@ export async function selfHealRuntimeRecords(
     for (const record of records) {
       const { unitType, unitId } = record;
 
-      // Case 0: complete-slice with SUMMARY + UAT but unchecked roadmap (#1350).
-      // If a complete-slice was interrupted after writing artifacts but before
-      // flipping the roadmap checkbox, the verification fails and the dispatch
-      // loop relaunches the same unit forever. Auto-fix the checkbox.
-      if (unitType === "complete-slice") {
-        const { milestone: mid, slice: sid } = parseUnitId(unitId);
-        if (mid && sid) {
-          const dir = resolveSlicePath(base, mid, sid);
-          if (dir) {
-            const summaryPath = join(dir, buildSliceFileName(sid, "SUMMARY"));
-            const uatPath = join(dir, buildSliceFileName(sid, "UAT"));
-            if (existsSync(summaryPath) && existsSync(uatPath)) {
-              const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-              if (roadmapFile && existsSync(roadmapFile)) {
-                try {
-                  const roadmapContent = readFileSync(roadmapFile, "utf-8");
-                  const roadmap = parseRoadmap(roadmapContent);
-                  const slice = (roadmap.slices ?? []).find(s => s.id === sid);
-                  if (slice && !slice.done) {
-                    // Auto-fix: flip the checkbox using shared utility
-                    if (markSliceDoneInRoadmap(base, mid, sid)) {
-                      ctx.ui.notify(
-                        `Self-heal: marked ${sid} done in roadmap (SUMMARY + UAT exist but checkbox was stale).`,
-                        "info",
-                      );
-                    }
-                  }
-                } catch {
-                  // Roadmap parse failure — don't block self-heal
-                }
-              }
-            }
-          }
-        }
-      }
+      // Case 0 removed — roadmap checkbox auto-fix is no longer needed.
+      // With DB-as-truth, stale checkboxes are fixed by repairStaleRenders().
 
       // Clear stale dispatched records (dispatched > 1h ago, process crashed)
       const age = now - (record.startedAt ?? 0);
@@ -746,13 +685,10 @@ export function buildLoopRemediationSteps(
   switch (unitType) {
     case "execute-task": {
       if (!mid || !sid || !tid) break;
-      const planRel = relSliceFile(base, mid, sid, "PLAN");
-      const summaryRel = relTaskFile(base, mid, sid, tid, "SUMMARY");
       return [
-        `   1. Write ${summaryRel} (even a partial summary is sufficient to unblock the pipeline)`,
-        `   2. Mark ${tid} [x] in ${planRel}: change "- [ ] **${tid}:" → "- [x] **${tid}:"`,
-        `   3. Run \`gsd doctor\` to reconcile .gsd/ state`,
-        `   4. Resume auto-mode — it will pick up from the next task`,
+        `   1. Run \`gsd undo-task ${tid}\` to reset the task state`,
+        `   2. Resume auto-mode — it will re-execute the task`,
+        `   3. If the task keeps failing, run \`gsd recover\` to rebuild DB state from disk`,
       ].join("\n");
     }
     case "plan-slice":
@@ -764,17 +700,16 @@ export function buildLoopRemediationSteps(
           : relSliceFile(base, mid, sid, "RESEARCH");
       return [
         `   1. Write ${artifactRel} manually (or with the LLM in interactive mode)`,
-        `   2. Run \`gsd doctor\` to reconcile .gsd/ state`,
+        `   2. Run \`gsd recover\` to rebuild DB state from disk`,
         `   3. Resume auto-mode`,
       ].join("\n");
     }
     case "complete-slice": {
       if (!mid || !sid) break;
       return [
-        `   1. Write the slice summary and UAT file for ${sid} in ${relSlicePath(base, mid, sid)}`,
-        `   2. Mark ${sid} [x] in ${relMilestoneFile(base, mid, "ROADMAP")}`,
-        `   3. Run \`gsd doctor\` to reconcile .gsd/ state`,
-        `   4. Resume auto-mode`,
+        `   1. Run \`gsd reset-slice ${sid}\` to reset the slice and all its tasks`,
+        `   2. Resume auto-mode — it will re-execute incomplete tasks and re-complete the slice`,
+        `   3. If the slice keeps failing, run \`gsd recover\` to rebuild DB state from disk`,
       ].join("\n");
     }
     case "validate-milestone": {
@@ -782,7 +717,7 @@ export function buildLoopRemediationSteps(
       const artifactRel = relMilestoneFile(base, mid, "VALIDATION");
       return [
         `   1. Write ${artifactRel} with verdict: pass`,
-        `   2. Run \`gsd doctor\``,
+        `   2. Run \`gsd recover\` to rebuild DB state from disk`,
         `   3. Resume auto-mode`,
       ].join("\n");
     }

package/src/resources/extensions/gsd/auto-start.ts

@@ -551,6 +551,20 @@ export async function bootstrapAutoSession(
       }
     }
 
+    // Gate: abort bootstrap if the DB file exists but the provider is
+    // still unavailable after both open attempts above. Without this,
+    // auto-mode starts but every gsd_task_complete / gsd_slice_complete
+    // call returns "db_unavailable", triggering artifact-retry which
+    // re-dispatches the same task — producing an infinite loop (#2419).
+    if (existsSync(gsdDbPath) && !isDbAvailable()) {
+      ctx.ui.notify(
+        "SQLite database exists but failed to open. Auto-mode cannot proceed without a working database provider. " +
+          "Check for corrupt gsd.db or missing native SQLite bindings.",
+        "error",
+      );
+      return releaseLockAndReturn();
+    }
+
     // Initialize metrics
     initMetrics(s.basePath);
 

package/src/resources/extensions/gsd/auto-supervisor.ts

@@ -13,6 +13,10 @@ import { nativeHasChanges } from "./native-git-bridge.js";
 /** Signals that should trigger lock cleanup on process termination. */
 const CLEANUP_SIGNALS: NodeJS.Signals[] = ["SIGTERM", "SIGHUP", "SIGINT"];
 
+/** Module-level reference to the last registered handler, used as a safety net
+ *  to prevent handler accumulation if the caller neglects to pass previousHandler. */
+let _currentSigtermHandler: (() => void) | null = null;
+
 /**
  * Register signal handlers that clear lock files and exit cleanly.
  * Installs handlers on SIGTERM, SIGHUP, and SIGINT so that lock files
@@ -29,15 +33,22 @@ export function registerSigtermHandler(
   currentBasePath: string,
   previousHandler: (() => void) | null,
 ): () => void {
+  // Remove the explicitly-passed previous handler
   if (previousHandler) {
     for (const sig of CLEANUP_SIGNALS) process.off(sig, previousHandler);
   }
+  // Safety net: also remove the module-tracked handler in case the caller
+  // forgot to pass previousHandler (prevents handler accumulation)
+  if (_currentSigtermHandler && _currentSigtermHandler !== previousHandler) {
+    for (const sig of CLEANUP_SIGNALS) process.off(sig, _currentSigtermHandler);
+  }
   const handler = () => {
     clearLock(currentBasePath);
     releaseSessionLock(currentBasePath);
     process.exit(0);
   };
   for (const sig of CLEANUP_SIGNALS) process.on(sig, handler);
+  _currentSigtermHandler = handler;
   return handler;
 }
 
@@ -46,6 +57,9 @@ export function deregisterSigtermHandler(handler: (() => void) | null): void {
   if (handler) {
     for (const sig of CLEANUP_SIGNALS) process.off(sig, handler);
   }
+  if (_currentSigtermHandler === handler) {
+    _currentSigtermHandler = null;
+  }
 }
 
 // ─── Working Tree Activity Detection ──────────────────────────────────────────

package/src/resources/extensions/gsd/auto-timeout-recovery.ts

@@ -14,7 +14,6 @@ import {
 import {
   resolveExpectedArtifactPath,
   diagnoseExpectedArtifact,
-  skipExecuteTask,
   writeBlockerPlaceholder,
 } from "./auto-recovery.js";
 import { existsSync } from "node:fs";
@@ -127,14 +126,14 @@ export async function recoverTimedOutUnit(
       return "recovered";
     }
 
-    // Retries exhausted — write missing durable artifacts and advance.
+    // Retries exhausted — write a blocker placeholder and advance.
     const diagnostic = formatExecuteTaskRecoveryStatus(status);
-    const [mid, sid, tid] = unitId.split("/");
-    const skipped = mid && sid && tid
-      ? skipExecuteTask(basePath, mid, sid, tid, status, reason, maxRecoveryAttempts)
-      : false;
+    const placeholder = writeBlockerPlaceholder(
+      unitType, unitId, basePath,
+      `${reason} recovery exhausted ${maxRecoveryAttempts} attempts. Status: ${diagnostic}`,
+    );
 
-    if (skipped) {
+    if (placeholder) {
       writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
         phase: "skipped",
         recovery: status,

package/src/resources/extensions/gsd/auto-verification.ts

@@ -11,8 +11,8 @@
  */
 
 import type { ExtensionContext, ExtensionAPI } from "@gsd/pi-coding-agent";
-import { loadFile, parsePlan } from "./files.js";
 import { resolveSliceFile, resolveSlicePath } from "./paths.js";
+import { isDbAvailable, getTask } from "./gsd-db.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import {
   runVerificationGate,
@@ -64,15 +64,10 @@ export async function runPostUnitVerification(
     let taskPlanVerify: string | undefined;
     if (parts.length >= 3) {
       const [mid, sid, tid] = parts;
-      const planFile = resolveSliceFile(s.basePath, mid, sid, "PLAN");
-      if (planFile) {
-        const planContent = await loadFile(planFile);
-        if (planContent) {
-          const slicePlan = parsePlan(planContent);
-          const taskEntry = slicePlan?.tasks?.find((t) => t.id === tid);
-          taskPlanVerify = taskEntry?.verify;
-        }
+      if (isDbAvailable()) {
+        taskPlanVerify = getTask(mid, sid, tid)?.verify;
       }
+      // When DB unavailable, taskPlanVerify stays undefined — gate runs without task-specific checks
     }
 
     const result = runVerificationGate({