gsd-pi 2.49.0 → 2.50.0-dev.d210a87

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

@@ -6,85 +6,20 @@
  * Pure functions that receive all needed state as parameters — no module-level
  * globals or AutoContext dependency.
  */
-import { clearUnitRuntimeRecord } from "./unit-runtime.js";
+import { parseUnitId } from "./unit-id.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 { isDbAvailable, getTask, getSlice, getSliceTasks, updateTaskStatus } 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, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
+import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildSliceFileName, 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";
+import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-artifact-paths.js";
+// Re-export so existing consumers of auto-recovery.ts keep working.
+export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
 // ─── Artifact Resolution & Verification ───────────────────────────────────────
-/**
- * Resolve the expected artifact for a unit to an absolute path.
- */
-export function resolveExpectedArtifactPath(unitType, unitId, base) {
-    const parts = unitId.split("/");
-    const mid = parts[0];
-    const sid = parts[1];
-    switch (unitType) {
-        case "discuss-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "CONTEXT")) : null;
-        }
-        case "research-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "RESEARCH")) : null;
-        }
-        case "plan-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "ROADMAP")) : null;
-        }
-        case "research-slice": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "RESEARCH")) : null;
-        }
-        case "plan-slice": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "PLAN")) : null;
-        }
-        case "reassess-roadmap": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "ASSESSMENT")) : null;
-        }
-        case "run-uat": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "UAT-RESULT")) : null;
-        }
-        case "execute-task": {
-            const tid = parts[2];
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir && tid
-                ? join(dir, "tasks", buildTaskFileName(tid, "SUMMARY"))
-                : null;
-        }
-        case "complete-slice": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "SUMMARY")) : null;
-        }
-        case "validate-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "VALIDATION")) : null;
-        }
-        case "complete-milestone": {
-            const dir = resolveMilestonePath(base, mid);
-            return dir ? join(dir, buildMilestoneFileName(mid, "SUMMARY")) : null;
-        }
-        case "replan-slice": {
-            const dir = resolveSlicePath(base, mid, sid);
-            return dir ? join(dir, buildSliceFileName(sid, "REPLAN")) : null;
-        }
-        case "rewrite-docs":
-            return null;
-        case "reactive-execute":
-            // Reactive execute produces multiple task summaries — verified separately
-            return null;
-        default:
-            return null;
-    }
-}
 /**
  * Check whether a milestone produced implementation artifacts (non-`.gsd/` files)
  * in the git history. Uses `git log --name-only` to inspect all commits on the
@@ -214,13 +149,9 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // Reactive-execute: verify that each dispatched task's summary exists.
     // The unitId encodes the batch: "{mid}/{sid}/reactive+T02,T03"
     if (unitType === "reactive-execute") {
-        const parts = unitId.split("/");
-        const mid = parts[0];
-        const sidAndBatch = parts[1];
-        const batchPart = parts[2]; // "reactive+T02,T03"
-        if (!mid || !sidAndBatch || !batchPart)
+        const { milestone: mid, slice: sid, task: batchPart } = parseUnitId(unitId);
+        if (!mid || !sid || !batchPart)
             return false;
-        const sid = sidAndBatch;
         const plusIdx = batchPart.indexOf("+");
         if (plusIdx === -1) {
             // Legacy format "reactive" without batch IDs — fall back to "any summary"
@@ -244,6 +175,33 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         }
         return true;
     }
+    // Gate-evaluate: verify that each dispatched gate has been resolved in the DB.
+    // The unitId encodes the batch: "{mid}/{sid}/gates+Q3,Q4"
+    if (unitType === "gate-evaluate") {
+        const { milestone: mid, slice: sid, task: batchPart } = parseUnitId(unitId);
+        if (!mid || !sid || !batchPart)
+            return false;
+        const plusIdx = batchPart.indexOf("+");
+        if (plusIdx === -1)
+            return true; // no specific gates encoded — pass
+        const gateIds = batchPart.slice(plusIdx + 1).split(",").filter(Boolean);
+        if (gateIds.length === 0)
+            return true;
+        try {
+            const { getPendingGates: getPending } = require("./gsd-db.js");
+            const pending = getPending(mid, sid, "slice");
+            const pendingIds = new Set(pending.map((g) => g.gate_id));
+            // All dispatched gates must no longer be pending
+            for (const gid of gateIds) {
+                if (pendingIds.has(gid))
+                    return false;
+            }
+        }
+        catch {
+            // DB unavailable — treat as verified to avoid blocking
+        }
+        return true;
+    }
     const absPath = resolveExpectedArtifactPath(unitType, unitId, base);
     // For unit types with no verifiable artifact (null path), the parent directory
     // is missing on disk — treat as stale completion state so the key gets evicted (#313).
@@ -272,10 +230,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // 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];
+        const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
         if (mid && sid && tid) {
             const dbTask = getTask(mid, sid, tid);
             if (dbTask) {
@@ -307,9 +262,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // but omitted T{tid}-PLAN.md files would be marked complete, causing execute-task
     // to dispatch with a missing task plan (see issue #739).
     if (unitType === "plan-slice") {
-        const parts = unitId.split("/");
-        const mid = parts[0];
-        const sid = parts[1];
+        const { milestone: mid, slice: sid } = parseUnitId(unitId);
         if (mid && sid) {
             try {
                 // DB primary path — get task IDs to verify task plan files exist
@@ -345,9 +298,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
     // 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];
-        const sid = parts[1];
+        const { milestone: mid, slice: sid } = parseUnitId(unitId);
         if (mid && sid) {
             const dir = resolveSlicePath(base, mid, sid);
             if (dir) {
@@ -413,46 +364,49 @@ export function writeBlockerPlaceholder(unitType, unitId, base, reason) {
         `Review and replace this file before relying on downstream artifacts.`,
     ].join("\n");
     writeFileSync(absPath, content, "utf-8");
+    // Mark the task as complete in the DB so verifyExpectedArtifact passes.
+    // Without this, the DB status stays "pending" and the dispatch loop
+    // re-derives the same task indefinitely (#2531).
+    if (unitType === "execute-task" && isDbAvailable()) {
+        const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+        if (mid && sid && tid) {
+            try {
+                updateTaskStatus(mid, sid, tid, "complete", new Date().toISOString());
+            }
+            catch { /* non-fatal */ }
+        }
+    }
     return diagnoseExpectedArtifact(unitType, unitId, base);
 }
-export function diagnoseExpectedArtifact(unitType, unitId, base) {
-    const parts = unitId.split("/");
-    const mid = parts[0];
-    const sid = parts[1];
-    switch (unitType) {
-        case "discuss-milestone":
-            return `${relMilestoneFile(base, mid, "CONTEXT")} (milestone context from discussion)`;
-        case "research-milestone":
-            return `${relMilestoneFile(base, mid, "RESEARCH")} (milestone research)`;
-        case "plan-milestone":
-            return `${relMilestoneFile(base, mid, "ROADMAP")} (milestone roadmap)`;
-        case "research-slice":
-            return `${relSliceFile(base, mid, sid, "RESEARCH")} (slice research)`;
-        case "plan-slice":
-            return `${relSliceFile(base, mid, sid, "PLAN")} (slice plan)`;
-        case "execute-task": {
-            const tid = parts[2];
-            return `Task ${tid} marked [x] in ${relSliceFile(base, mid, sid, "PLAN")} + summary written`;
+// ─── Merge State Reconciliation ───────────────────────────────────────────────
+/**
+ * Best-effort abort of a pending merge/squash and hard-reset to HEAD.
+ * Handles both real merges (MERGE_HEAD) and squash merges (SQUASH_MSG).
+ */
+function abortAndResetMerge(basePath, hasMergeHead, squashMsgPath) {
+    if (hasMergeHead) {
+        try {
+            nativeMergeAbort(basePath);
         }
-        case "complete-slice":
-            return `Slice ${sid} marked [x] in ${relMilestoneFile(base, mid, "ROADMAP")} + summary + UAT written`;
-        case "replan-slice":
-            return `${relSliceFile(base, mid, sid, "REPLAN")} + updated ${relSliceFile(base, mid, sid, "PLAN")}`;
-        case "rewrite-docs":
-            return "Active overrides resolved in .gsd/OVERRIDES.md + plan documents updated";
-        case "reassess-roadmap":
-            return `${relSliceFile(base, mid, sid, "ASSESSMENT")} (roadmap reassessment)`;
-        case "run-uat":
-            return `${relSliceFile(base, mid, sid, "UAT-RESULT")} (UAT result)`;
-        case "validate-milestone":
-            return `${relMilestoneFile(base, mid, "VALIDATION")} (milestone validation report)`;
-        case "complete-milestone":
-            return `${relMilestoneFile(base, mid, "SUMMARY")} (milestone summary)`;
-        default:
-            return null;
+        catch {
+            /* best-effort */
+        }
+    }
+    else if (squashMsgPath) {
+        try {
+            unlinkSync(squashMsgPath);
+        }
+        catch {
+            /* best-effort */
+        }
+    }
+    try {
+        nativeResetHard(basePath);
+    }
+    catch {
+        /* best-effort */
     }
 }
-// ─── Merge State Reconciliation ───────────────────────────────────────────────
 /**
  * Detect leftover merge state from a prior session and reconcile it.
  * If MERGE_HEAD or SQUASH_MSG exists, check whether conflicts are resolved.
@@ -503,105 +457,25 @@ export function reconcileMergeState(basePath, ctx) {
                 }
             }
             if (!resolved) {
-                if (hasMergeHead) {
-                    try {
-                        nativeMergeAbort(basePath);
-                    }
-                    catch {
-                        /* best-effort */
-                    }
-                }
-                else if (hasSquashMsg) {
-                    try {
-                        unlinkSync(squashMsgPath);
-                    }
-                    catch {
-                        /* best-effort */
-                    }
-                }
-                try {
-                    nativeResetHard(basePath);
-                }
-                catch {
-                    /* best-effort */
-                }
+                abortAndResetMerge(basePath, hasMergeHead, squashMsgPath);
                 ctx.ui.notify("Detected leftover merge state — auto-resolve failed, cleaned up. Re-deriving state.", "warning");
             }
         }
         else {
             // Code conflicts present — abort and reset
-            if (hasMergeHead) {
-                try {
-                    nativeMergeAbort(basePath);
-                }
-                catch {
-                    /* best-effort */
-                }
-            }
-            else if (hasSquashMsg) {
-                try {
-                    unlinkSync(squashMsgPath);
-                }
-                catch {
-                    /* best-effort */
-                }
-            }
-            try {
-                nativeResetHard(basePath);
-            }
-            catch {
-                /* best-effort */
-            }
+            abortAndResetMerge(basePath, hasMergeHead, squashMsgPath);
             ctx.ui.notify("Detected leftover merge state with unresolved conflicts — cleaned up. Re-deriving state.", "warning");
         }
     }
     return true;
 }
-// ─── Self-Heal Runtime Records ────────────────────────────────────────────────
-/**
- * Self-heal: scan runtime records in .gsd/ and clear stale ones.
- * Clears dispatched records older than 1 hour (process crashed before
- * completing the unit). deriveState() handles re-derivation — no need
- * for completion key persistence here.
- */
-export async function selfHealRuntimeRecords(base, ctx) {
-    try {
-        const { listUnitRuntimeRecords } = await import("./unit-runtime.js");
-        const records = listUnitRuntimeRecords(base);
-        let healed = 0;
-        const STALE_THRESHOLD_MS = 60 * 60 * 1000; // 1 hour
-        const now = Date.now();
-        for (const record of records) {
-            const { unitType, unitId } = record;
-            // 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) {
-                clearUnitRuntimeRecord(base, unitType, unitId);
-                healed++;
-                continue;
-            }
-        }
-        if (healed > 0) {
-            ctx.ui.notify(`Self-heal: cleared ${healed} stale runtime record(s).`, "info");
-        }
-    }
-    catch (e) {
-        // Non-fatal — self-heal should never block auto-mode start
-        void e;
-    }
-}
 // ─── Loop Remediation ─────────────────────────────────────────────────────────
 /**
  * Build concrete, manual remediation steps for a loop-detected unit failure.
  * These are shown when automatic reconciliation is not possible.
  */
 export function buildLoopRemediationSteps(unitType, unitId, base) {
-    const parts = unitId.split("/");
-    const mid = parts[0];
-    const sid = parts[1];
-    const tid = parts[2];
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     switch (unitType) {
         case "execute-task": {
             if (!mid || !sid || !tid)

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

@@ -24,7 +24,7 @@ import { nativeInit, nativeAddAll, nativeCommit, } from "./native-git-bridge.js"
 import { GitServiceImpl } from "./git-service.js";
 import { captureIntegrationBranch, detectWorktreeName, setActiveMilestoneId, } from "./worktree.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
-import { readResourceVersion } from "./auto-worktree-sync.js";
+import { readResourceVersion, cleanStaleRuntimeUnits } from "./auto-worktree.js";
 import { initMetrics } from "./metrics.js";
 import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
@@ -33,6 +33,7 @@ import { snapshotSkills } from "./skill-discovery.js";
 import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { hideFooter } from "./auto-dashboard.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
+import { parseUnitId } from "./unit-id.js";
 import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, } from "node:fs";
 import { join } from "node:path";
 import { sep as pathSep } from "node:path";
@@ -119,7 +120,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 ctx.ui.notify(`Another auto-mode session (PID ${crashLock.pid}) appears to be running.\nStop it with \`kill ${crashLock.pid}\` before starting a new session.`, "error");
                 return releaseLockAndReturn();
             }
-            const recoveredMid = crashLock.unitId.split("/")[0];
+            const recoveredMid = parseUnitId(crashLock.unitId).milestone;
             const milestoneAlreadyComplete = recoveredMid
                 ? !!resolveMilestoneFile(base, recoveredMid, "SUMMARY")
                 : false;
@@ -159,35 +160,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // Invalidate caches before initial state derivation
         invalidateAllCaches();
         // Clean stale runtime unit files for completed milestones (#887)
-        try {
-            const runtimeUnitsDir = join(gsdRoot(base), "runtime", "units");
-            if (existsSync(runtimeUnitsDir)) {
-                for (const file of readdirSync(runtimeUnitsDir)) {
-                    if (!file.endsWith(".json"))
-                        continue;
-                    const midMatch = file.match(/(M\d+(?:-[a-z0-9]{6})?)/);
-                    if (!midMatch)
-                        continue;
-                    const mid = midMatch[1];
-                    if (resolveMilestoneFile(base, mid, "SUMMARY")) {
-                        try {
-                            unlinkSync(join(runtimeUnitsDir, file));
-                        }
-                        catch (e) {
-                            debugLog("stale-unit-cleanup-failed", {
-                                file,
-                                error: e instanceof Error ? e.message : String(e),
-                            });
-                        }
-                    }
-                }
-            }
-        }
-        catch (e) {
-            debugLog("stale-unit-dir-cleanup-failed", {
-                error: e instanceof Error ? e.message : String(e),
-            });
-        }
+        cleanStaleRuntimeUnits(gsdRoot(base), (mid) => !!resolveMilestoneFile(base, mid, "SUMMARY"));
         let state = await deriveState(base);
         // Stale worktree state recovery (#654)
         if (state.activeMilestone &&

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

@@ -155,7 +155,7 @@ export function startUnitSupervision(sctx) {
             const message = err instanceof Error ? err.message : String(err);
             console.error(`[idle-watchdog] Unhandled error: ${message}`);
             // Unblock any pending unit promise so the auto-loop is not orphaned.
-            resolveAgentEndCancelled();
+            resolveAgentEndCancelled({ message: `Idle watchdog error: ${message}`, category: "idle", isTransient: true });
             try {
                 ctx.ui.notify(`Idle watchdog error: ${message}`, "warning");
             }
@@ -188,7 +188,7 @@ export function startUnitSupervision(sctx) {
             const message = err instanceof Error ? err.message : String(err);
             console.error(`[hard-timeout] Unhandled error: ${message}`);
             // Unblock any pending unit promise so the auto-loop is not orphaned.
-            resolveAgentEndCancelled();
+            resolveAgentEndCancelled({ message: `Hard timeout error: ${message}`, category: "timeout", isTransient: true });
             try {
                 ctx.ui.notify(`Hard timeout error: ${message}`, "warning");
             }

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

@@ -0,0 +1,20 @@
+// Shared utilities for the auto-loop modules (auto-post-unit, auto, etc.).
+import { debugLog } from "./debug-logger.js";
+/**
+ * Run a non-fatal operation, logging any error via `debugLog` and continuing.
+ *
+ * Replaces the repeated try-catch-debugLog-continue boilerplate that wraps
+ * operations whose failure should not abort the post-unit pipeline.
+ *
+ * @param context - The debugLog event name (e.g. "postUnit")
+ * @param phase   - The phase label attached to the debug entry
+ * @param fn      - The operation to execute (may be sync or async)
+ */
+export async function runSafely(context, phase, fn) {
+    try {
+        await fn();
+    }
+    catch (e) {
+        debugLog(context, { phase, error: String(e) });
+    }
+}

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

@@ -10,6 +10,7 @@
  * checks the result and handles control flow.
  */
 import { resolveSlicePath } from "./paths.js";
+import { parseUnitId } from "./unit-id.js";
 import { isDbAvailable, getTask } from "./gsd-db.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit, } from "./verification-gate.js";
@@ -34,18 +35,15 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
         const effectivePrefs = loadEffectiveGSDPreferences();
         const prefs = effectivePrefs?.preferences;
         // Read task plan verify field
-        const parts = s.currentUnit.id.split("/");
+        const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
         let taskPlanVerify;
-        if (parts.length >= 3) {
-            const [mid, sid, tid] = parts;
+        if (mid && sid && tid) {
             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,
-            unitId: s.currentUnit.id,
             cwd: s.basePath,
             preferenceCommands: prefs?.verification_commands,
             taskPlanVerify,
@@ -100,9 +98,8 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
         }
         // Write verification evidence JSON
         const attempt = s.verificationRetryCount.get(s.currentUnit.id) ?? 0;
-        if (parts.length >= 3) {
+        if (mid && sid && tid) {
             try {
-                const [mid, sid, tid] = parts;
                 const sDir = resolveSlicePath(s.basePath, mid, sid);
                 if (sDir) {
                     const tasksDir = join(sDir, "tasks");