gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/dist/resources/extensions/gsd/auto-recovery.js

@@ -6,13 +6,13 @@
  * Pure functions that receive all needed state as parameters — no module-level
  * globals or AutoContext dependency.
  */
-import { parseUnitId } from "./unit-id.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, nativeCommit, nativeCheckoutTheirs, nativeAddPaths, nativeMergeAbort, nativeResetHard, } from "./native-git-bridge.js";
-import { resolveMilestonePath, resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, relSlicePath, relTaskFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
-import { markSliceDoneInRoadmap } from "./roadmap-mutations.js";
+import { resolveMilestonePath, resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { dirname, join } from "node:path";
@@ -269,26 +269,37 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         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))
+            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)
         }
     }
     // plan-slice must also produce individual task plan files for every task listed
@@ -301,14 +312,28 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         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 = 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) => 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;
+                        }
                     }
                 }
             }
@@ -317,11 +342,8 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
             }
         }
     }
-    // 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];
@@ -333,24 +355,31 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
                 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.
+            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)
         }
     }
     // complete-milestone must have produced implementation artifacts (#1703).
@@ -423,52 +452,6 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
             return null;
     }
 }
-// ─── 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, mid, sid, tid, status, reason, maxAttempts) {
-    // 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 ───────────────────────────────────────────────
 /**
  * Detect leftover merge state from a prior session and reconcile it.
@@ -590,39 +573,8 @@ export async function selfHealRuntimeRecords(base, ctx) {
         const now = Date.now();
         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);
             if (record.phase === "dispatched" && age > STALE_THRESHOLD_MS) {
@@ -654,13 +606,10 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
         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":
@@ -672,7 +621,7 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
                 : 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");
         }
@@ -680,10 +629,9 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
             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": {
@@ -692,7 +640,7 @@ export function buildLoopRemediationSteps(unitType, unitId, base) {
             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/dist/resources/extensions/gsd/auto-start.js

@@ -402,6 +402,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 process.stderr.write(`gsd-db: failed to open existing database: ${err.message}\n`);
             }
         }
+        // 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);
         // Initialize routing history

package/dist/resources/extensions/gsd/auto-supervisor.js

@@ -9,6 +9,9 @@ import { nativeHasChanges } from "./native-git-bridge.js";
 // ─── Signal Handling ─────────────────────────────────────────────────────────
 /** Signals that should trigger lock cleanup on process termination. */
 const CLEANUP_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 = null;
 /**
  * Register signal handlers that clear lock files and exit cleanly.
  * Installs handlers on SIGTERM, SIGHUP, and SIGINT so that lock files
@@ -22,10 +25,17 @@ const CLEANUP_SIGNALS = ["SIGTERM", "SIGHUP", "SIGINT"];
  * Returns the new handler so the caller can store and deregister it later.
  */
 export function registerSigtermHandler(currentBasePath, previousHandler) {
+    // 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);
@@ -33,6 +43,7 @@ export function registerSigtermHandler(currentBasePath, previousHandler) {
     };
     for (const sig of CLEANUP_SIGNALS)
         process.on(sig, handler);
+    _currentSigtermHandler = handler;
     return handler;
 }
 /** Deregister signal handlers from all cleanup signals (called on stop/pause). */
@@ -41,6 +52,9 @@ export function deregisterSigtermHandler(handler) {
         for (const sig of CLEANUP_SIGNALS)
             process.off(sig, handler);
     }
+    if (_currentSigtermHandler === handler) {
+        _currentSigtermHandler = null;
+    }
 }
 // ─── Working Tree Activity Detection ──────────────────────────────────────────
 /**

package/dist/resources/extensions/gsd/auto-timeout-recovery.js

@@ -4,7 +4,7 @@
  * and blocker placeholder generation.
  */
 import { readUnitRuntimeRecord, writeUnitRuntimeRecord, formatExecuteTaskRecoveryStatus, inspectExecuteTaskDurability, } from "./unit-runtime.js";
-import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, skipExecuteTask, writeBlockerPlaceholder, } from "./auto-recovery.js";
+import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, writeBlockerPlaceholder, } from "./auto-recovery.js";
 import { existsSync } from "node:fs";
 import { resolveAgentEnd } from "./auto-loop.js";
 export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rctx) {
@@ -78,13 +78,10 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
             ctx.ui.notify(`${reason === "idle" ? "Idle" : "Timeout"} recovery: steering ${unitType} ${unitId} to finish durable output (attempt ${attemptNumber}, session ${recoveryAttempts + 1}/${maxRecoveryAttempts}).`, "warning");
             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;
-        if (skipped) {
+        const placeholder = writeBlockerPlaceholder(unitType, unitId, basePath, `${reason} recovery exhausted ${maxRecoveryAttempts} attempts. Status: ${diagnostic}`);
+        if (placeholder) {
             writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
                 phase: "skipped",
                 recovery: status,

package/dist/resources/extensions/gsd/auto-verification.js

@@ -9,8 +9,8 @@
  * value instead of calling return/pauseAuto directly — the caller
  * checks the result and handles control flow.
  */
-import { loadFile, parsePlan } from "./files.js";
-import { resolveSliceFile, resolveSlicePath } from "./paths.js";
+import { resolveSlicePath } from "./paths.js";
+import { isDbAvailable, getTask } from "./gsd-db.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit, } from "./verification-gate.js";
 import { writeVerificationJSON } from "./verification-evidence.js";
@@ -38,15 +38,10 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
         let taskPlanVerify;
         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({
             basePath: s.basePath,