gsd-pi 2.45.0 → 2.46.0-dev.5c2b8ed

package/dist/help-text.js

@@ -32,7 +32,7 @@ const SUBCOMMAND_HELP = {
     install: [
         'Usage: gsd install <source> [-l, --local]',
         '',
-        'Install a package/extension source and run declared lifecycle hooks.',
+        'Install a package/extension source and run post-install validation (dependency checks, setup).',
         '',
         'Examples:',
         '  gsd install npm:@foo/bar',

package/dist/loader.js

@@ -26,6 +26,40 @@ if (firstArg === '--help' || firstArg === '-h') {
     printHelp(gsdVersion);
     process.exit(0);
 }
+// ---------------------------------------------------------------------------
+// Runtime dependency checks — fail fast with clear diagnostics before any
+// heavy imports. Reads minimum Node version from the engines field in
+// package.json (already parsed above) and verifies git is available.
+// ---------------------------------------------------------------------------
+{
+    const MIN_NODE_MAJOR = 22;
+    const red = '\x1b[31m';
+    const bold = '\x1b[1m';
+    const dim = '\x1b[2m';
+    const reset = '\x1b[0m';
+    // -- Node version --
+    const nodeMajor = parseInt(process.versions.node.split('.')[0], 10);
+    if (nodeMajor < MIN_NODE_MAJOR) {
+        process.stderr.write(`\n${red}${bold}Error:${reset} GSD requires Node.js >= ${MIN_NODE_MAJOR}.0.0\n` +
+            `       You are running Node.js ${process.versions.node}\n\n` +
+            `${dim}Install a supported version:${reset}\n` +
+            `  nvm install ${MIN_NODE_MAJOR}   ${dim}# if using nvm${reset}\n` +
+            `  fnm install ${MIN_NODE_MAJOR}   ${dim}# if using fnm${reset}\n` +
+            `  brew install node@${MIN_NODE_MAJOR} ${dim}# macOS Homebrew${reset}\n\n`);
+        process.exit(1);
+    }
+    // -- git --
+    try {
+        const { execFileSync } = await import('child_process');
+        execFileSync('git', ['--version'], { stdio: 'ignore' });
+    }
+    catch {
+        process.stderr.write(`\n${red}${bold}Error:${reset} GSD requires git but it was not found on PATH.\n\n` +
+            `${dim}Install git:${reset}\n` +
+            `  https://git-scm.com/downloads\n\n`);
+        process.exit(1);
+    }
+}
 import { agentDir, appRoot } from './app-paths.js';
 import { serializeBundledExtensionPaths } from './bundled-extension-paths.js';
 import { discoverExtensionEntryPaths } from './extension-discovery.js';

package/dist/resources/extensions/gsd/auto/phases.js

@@ -11,12 +11,15 @@ import { MAX_RECOVERY_CHARS, BUDGET_THRESHOLDS, } from "./types.js";
 import { detectStuck } from "./detect-stuck.js";
 import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
-import { gsdRoot } from "../paths.js";
-import { atomicWriteSync } from "../atomic-write.js";
 import { PROJECT_FILES } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
 import { join } from "node:path";
 import { existsSync, cpSync } from "node:fs";
+import { logWarning } from "../workflow-logger.js";
+import { gsdRoot } from "../paths.js";
+import { atomicWriteSync } from "../atomic-write.js";
+import { verifyExpectedArtifact } from "../auto-recovery.js";
+import { writeUnitRuntimeRecord } from "../unit-runtime.js";
 // ─── generateMilestoneReport ──────────────────────────────────────────────────
 /**
  * Generate and write an HTML milestone report snapshot.
@@ -102,8 +105,8 @@ export async function runPreDispatch(ic, loopState) {
             return { action: "break", reason: "health-gate-failed" };
         }
     }
-    catch {
-        // Non-fatal
+    catch (e) {
+        logWarning("engine", "Pre-dispatch health gate threw unexpectedly", { error: String(e) });
     }
     // Sync project root artifacts into worktree
     if (s.originalBasePath &&
@@ -157,7 +160,8 @@ export async function runPreDispatch(ic, loopState) {
                 await deps.stopAuto(ctx, pi, `Merge conflict on milestone ${s.currentMilestoneId}`);
                 return { action: "break", reason: "merge-conflict" };
             }
-            // Non-conflict errors — log and continue
+            // Non-conflict merge errors — log and continue
+            logWarning("engine", "Milestone merge failed with non-conflict error", { milestone: s.currentMilestoneId, error: String(mergeErr) });
         }
         // PR creation (auto_pr) is handled inside mergeMilestoneToMain (#2302)
         deps.invalidateAllCaches();
@@ -177,11 +181,7 @@ export async function runPreDispatch(ic, loopState) {
             .filter((m) => m.status !== "complete" && m.status !== "parked")
             .map((m) => m.id);
         deps.pruneQueueOrder(s.basePath, pendingIds);
-        // Reset completed-units tracking for the new milestone — stale entries
-        // from the previous milestone cause the dispatch loop to skip units
-        // that haven't actually been completed in the new milestone's context.
         // Archive the old completed-units.json instead of wiping it (#2313).
-        s.completedUnits = [];
         try {
             const completedKeysPath = join(gsdRoot(s.basePath), "completed-units.json");
             if (existsSync(completedKeysPath) && s.currentMilestoneId) {
@@ -190,7 +190,9 @@ export async function runPreDispatch(ic, loopState) {
             }
             atomicWriteSync(completedKeysPath, JSON.stringify([], null, 2));
         }
-        catch { /* non-fatal */ }
+        catch (e) {
+            logWarning("engine", "Failed to archive completed-units on milestone transition", { error: String(e) });
+        }
         // Rebuild STATE.md immediately so it reflects the new active milestone.
         // This bypasses the 30-second throttle in the normal rebuild path —
         // milestone transitions are rare and important enough to warrant an
@@ -198,8 +200,8 @@ export async function runPreDispatch(ic, loopState) {
         try {
             await deps.rebuildState(s.basePath);
         }
-        catch {
-            // Non-fatal — STATE.md will be rebuilt on the next regular cycle
+        catch (e) {
+            logWarning("engine", "STATE.md rebuild failed after milestone transition", { error: String(e) });
         }
     }
     if (mid) {
@@ -364,7 +366,7 @@ export async function runDispatch(ic, preData, loopState) {
             if (loopState.stuckRecoveryAttempts === 0) {
                 // Level 1: try verifying the artifact, then cache invalidation + retry
                 loopState.stuckRecoveryAttempts++;
-                const artifactExists = deps.verifyExpectedArtifact(unitType, unitId, s.basePath);
+                const artifactExists = verifyExpectedArtifact(unitType, unitId, s.basePath);
                 if (artifactExists) {
                     debugLog("autoLoop", {
                         phase: "stuck-recovery",
@@ -584,7 +586,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     const unitStartSeq = ic.nextSeq();
     deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: unitStartSeq, eventType: "unit-start", data: { unitType, unitId } });
     deps.captureAvailableSkills();
-    deps.writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
+    writeUnitRuntimeRecord(s.basePath, unitType, unitId, s.currentUnit.startedAt, {
         phase: "dispatched",
         wrapupWarningSent: false,
         timeoutAt: null,
@@ -644,8 +646,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                     (requirementsContent?.length ?? 0) +
                     (projectContent?.length ?? 0);
         }
-        catch {
-            // Non-fatal
+        catch (e) {
+            logWarning("engine", "Baseline char count measurement failed", { error: String(e) });
         }
     }
     // Cache-optimize prompt section ordering
@@ -654,7 +656,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     }
     catch (reorderErr) {
         const msg = reorderErr instanceof Error ? reorderErr.message : String(reorderErr);
-        process.stderr.write(`[gsd] prompt reorder failed (non-fatal): ${msg}\n`);
+        logWarning("engine", "Prompt reorder failed", { error: msg });
     }
     // Select and apply model (with tier escalation on retry — normal units only)
     const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier });
@@ -699,7 +701,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     });
     // Write preliminary lock (no session path yet — runUnit creates a new session).
     // Crash recovery can still identify the in-flight unit from this lock.
-    deps.writeLock(deps.lockBase(), unitType, unitId, s.completedUnits.length);
+    deps.writeLock(deps.lockBase(), unitType, unitId);
     debugLog("autoLoop", {
         phase: "runUnit-start",
         iteration: ic.iteration,
@@ -716,8 +718,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     });
     // Now that runUnit has called newSession(), the session file path is correct.
     const sessionFile = deps.getSessionFile(ctx);
-    deps.updateSessionLock(deps.lockBase(), unitType, unitId, s.completedUnits.length, sessionFile);
-    deps.writeLock(deps.lockBase(), unitType, unitId, s.completedUnits.length, sessionFile);
+    deps.updateSessionLock(deps.lockBase(), unitType, unitId, sessionFile);
+    deps.writeLock(deps.lockBase(), unitType, unitId, sessionFile);
     // Tag the most recent window entry with error info for stuck detection
     if (unitResult.status === "error" || unitResult.status === "cancelled") {
         const lastEntry = loopState.recentUnits[loopState.recentUnits.length - 1];
@@ -761,8 +763,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                     warning: "Task completed with 0 tool calls — likely hallucinated, marking as failed",
                 });
                 ctx.ui.notify(`${unitType} ${unitId} completed with 0 tool calls — hallucinated summary, will retry`, "warning");
-                // Do NOT add to completedUnits — fall through to next iteration
-                // where dispatch will re-derive and re-dispatch this task.
+                // Fall through to next iteration where dispatch will re-derive
+                // and re-dispatch this task.
                 return { action: "next", data: { unitStartedAt: s.currentUnit.startedAt } };
             }
         }
@@ -772,25 +774,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     }
     const skipArtifactVerification = unitType.startsWith("hook/") || unitType === "custom-step";
     const artifactVerified = skipArtifactVerification ||
-        deps.verifyExpectedArtifact(unitType, unitId, s.basePath);
+        verifyExpectedArtifact(unitType, unitId, s.basePath);
     if (artifactVerified) {
-        s.completedUnits.push({
-            type: unitType,
-            id: unitId,
-            startedAt: s.currentUnit.startedAt,
-            finishedAt: Date.now(),
-        });
-        if (s.completedUnits.length > 200) {
-            s.completedUnits = s.completedUnits.slice(-200);
-        }
-        // Flush completed-units to disk so the record survives crashes
-        try {
-            const completedKeysPath = join(gsdRoot(s.basePath), "completed-units.json");
-            const keys = s.completedUnits.map((u) => `${u.type}/${u.id}`);
-            atomicWriteSync(completedKeysPath, JSON.stringify(keys, null, 2));
-        }
-        catch { /* non-fatal: disk flush failure */ }
-        deps.clearUnitRuntimeRecord(s.basePath, unitType, unitId);
         s.unitDispatchCount.delete(`${unitType}/${unitId}`);
         s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
     }
@@ -823,8 +808,8 @@ export async function runFinalize(ic, iterData, sidecarItem) {
     // Sidecar items use lightweight pre-verification opts
     const preVerificationOpts = sidecarItem
         ? sidecarItem.kind === "hook"
-            ? { skipSettleDelay: true, skipDoctor: true, skipStateRebuild: true, skipWorktreeSync: true }
-            : { skipSettleDelay: true, skipStateRebuild: true }
+            ? { skipSettleDelay: true, skipWorktreeSync: true }
+            : { skipSettleDelay: true }
         : undefined;
     const preResult = await deps.postUnitPreVerification(postUnitCtx, preVerificationOpts);
     if (preResult === "dispatched") {

package/dist/resources/extensions/gsd/auto/run-unit.js

@@ -6,6 +6,7 @@
 import { NEW_SESSION_TIMEOUT_MS } from "./session.js";
 import { _setCurrentResolve, _setSessionSwitchInFlight } from "./resolve.js";
 import { debugLog } from "../debug-logger.js";
+import { logWarning } from "../workflow-logger.js";
 /**
  * Execute a single unit: create a new session, send the prompt, and await
  * the agent_end promise. Returns a UnitResult describing what happened.
@@ -66,7 +67,9 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
             process.chdir(s.basePath);
         }
     }
-    catch { /* non-fatal — chdir may fail if dir was removed */ }
+    catch (e) {
+        logWarning("engine", "Failed to chdir to basePath before dispatch", { basePath: s.basePath, error: String(e) });
+    }
     // ── Send the prompt ──
     debugLog("runUnit", { phase: "send-message", unitType, unitId });
     pi.sendMessage({ customType: "gsd-auto", content: prompt, display: s.verbose }, { triggerTurn: true });
@@ -90,8 +93,8 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
             cmdCtxAny.clearQueue();
         }
     }
-    catch {
-        // Non-fatal — clearQueue may not be available in all contexts
+    catch (e) {
+        logWarning("engine", "clearQueue failed after unit completion", { error: String(e) });
     }
     return result;
 }

package/dist/resources/extensions/gsd/auto/session.js

@@ -46,7 +46,6 @@ export class AutoSession {
     // ── Current unit ─────────────────────────────────────────────────────────
     currentUnit = null;
     currentUnitRouting = null;
-    completedUnits = [];
     currentMilestoneId = null;
     // ── Model state ──────────────────────────────────────────────────────────
     autoModeStartModel = null;
@@ -100,14 +99,6 @@ export class AutoSession {
     get lockBasePath() {
         return this.originalBasePath || this.basePath;
     }
-    completeCurrentUnit() {
-        if (!this.currentUnit)
-            return null;
-        const done = { ...this.currentUnit, finishedAt: Date.now() };
-        this.completedUnits.push(done);
-        this.currentUnit = null;
-        return done;
-    }
     reset() {
         this.clearTimers();
         // Lifecycle
@@ -129,7 +120,6 @@ export class AutoSession {
         // Unit
         this.currentUnit = null;
         this.currentUnitRouting = null;
-        this.completedUnits = [];
         this.currentMilestoneId = null;
         // Model
         this.autoModeStartModel = null;
@@ -164,7 +154,6 @@ export class AutoSession {
             activeRunDir: this.activeRunDir,
             currentMilestoneId: this.currentMilestoneId,
             currentUnit: this.currentUnit,
-            completedUnits: this.completedUnits.length,
             unitDispatchCount: Object.fromEntries(this.unitDispatchCount),
         };
     }

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -0,0 +1,112 @@
+// GSD Auto-mode — Artifact Path Resolution
+//
+// resolveExpectedArtifactPath and diagnoseExpectedArtifact moved here from
+// auto-recovery.ts (Phase 5 dead-code cleanup). The artifact verification
+// function was removed entirely — callers now query WorkflowEngine directly.
+import { resolveMilestonePath, resolveSlicePath, relMilestoneFile, relSliceFile, buildMilestoneFileName, buildSliceFileName, buildTaskFileName, } from "./paths.js";
+import { join } from "node:path";
+/**
+ * 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;
+    }
+}
+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`;
+        }
+        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;
+    }
+}

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -13,14 +13,12 @@
 import { deriveState } from "./state.js";
 import { loadFile, parseSummary, resolveAllOverrides } from "./files.js";
 import { loadPrompt } from "./prompt-loader.js";
-import { resolveSliceFile, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, gsdRoot, } from "./paths.js";
+import { resolveSliceFile, resolveTaskFile, resolveMilestoneFile, resolveTasksDir, buildTaskFileName, } from "./paths.js";
 import { invalidateAllCaches } from "./cache.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { autoCommitCurrentBranch, } from "./worktree.js";
 import { verifyExpectedArtifact, resolveExpectedArtifactPath, } from "./auto-recovery.js";
-import { writeUnitRuntimeRecord, clearUnitRuntimeRecord } from "./unit-runtime.js";
-import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.js";
-import { recordHealthSnapshot, checkHealEscalation } from "./doctor-proactive.js";
+import { regenerateIfMissing } from "./workflow-projections.js";
 import { syncStateToProjectRoot } from "./auto-worktree-sync.js";
 import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
@@ -30,7 +28,6 @@ import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { atomicWriteSync } from "./atomic-write.js";
 import { _resetHasChangesCache } from "./native-git-bridge.js";
 /**
  * Detect summary files written directly to disk without the LLM calling
@@ -137,8 +134,6 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
     }
     return rogues;
 }
-/** Throttle STATE.md rebuilds — at most once per 30 seconds */
-const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 /**
  * Pre-verification processing: parallel worker signal check, cache invalidation,
  * auto-commit, doctor run, state rebuild, worktree sync, artifact verification.
@@ -232,74 +227,6 @@ export async function postUnitPreVerification(pctx, opts) {
         catch (e) {
             debugLog("postUnit", { phase: "github-sync", error: String(e) });
         }
-        // Doctor: fix mechanical bookkeeping (skipped for lightweight sidecars)
-        if (!opts?.skipDoctor)
-            try {
-                const scopeParts = s.currentUnit.id.split("/").slice(0, 2);
-                const doctorScope = scopeParts.join("/");
-                const sliceTerminalUnits = new Set(["complete-slice", "run-uat"]);
-                const effectiveFixLevel = sliceTerminalUnits.has(s.currentUnit.type) ? "all" : "task";
-                const report = await runGSDDoctor(s.basePath, { fix: true, scope: doctorScope, fixLevel: effectiveFixLevel });
-                // Human-readable fix notification with details
-                if (report.fixesApplied.length > 0) {
-                    const fixSummary = report.fixesApplied.length <= 2
-                        ? report.fixesApplied.join("; ")
-                        : `${report.fixesApplied[0]}; +${report.fixesApplied.length - 1} more`;
-                    ctx.ui.notify(`Doctor: ${fixSummary}`, "info");
-                }
-                // Proactive health tracking — filter to current milestone to avoid
-                // cross-milestone stale errors inflating the escalation counter
-                const currentMilestoneId = s.currentUnit.id.split("/")[0];
-                const milestoneIssues = currentMilestoneId
-                    ? report.issues.filter(i => i.unitId === currentMilestoneId ||
-                        i.unitId.startsWith(`${currentMilestoneId}/`))
-                    : report.issues;
-                const summary = summarizeDoctorIssues(milestoneIssues);
-                // Pass issue details + scope for real-time visibility in the progress widget
-                const issueDetails = milestoneIssues
-                    .filter(i => i.severity === "error" || i.severity === "warning")
-                    .map(i => ({ code: i.code, message: i.message, severity: i.severity, unitId: i.unitId }));
-                recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length, issueDetails, report.fixesApplied, doctorScope);
-                // Check if we should escalate to LLM-assisted heal
-                if (summary.errors > 0) {
-                    const unresolvedErrors = milestoneIssues
-                        .filter(i => i.severity === "error" && !i.fixable)
-                        .map(i => ({ code: i.code, message: i.message, unitId: i.unitId }));
-                    const escalation = checkHealEscalation(summary.errors, unresolvedErrors);
-                    if (escalation.shouldEscalate) {
-                        ctx.ui.notify(`Doctor heal escalation: ${escalation.reason}. Dispatching LLM-assisted heal.`, "warning");
-                        try {
-                            const { formatDoctorIssuesForPrompt, formatDoctorReport } = await import("./doctor.js");
-                            const { dispatchDoctorHeal } = await import("./commands-handlers.js");
-                            const actionable = report.issues.filter(i => i.severity === "error");
-                            const reportText = formatDoctorReport(report, { scope: doctorScope, includeWarnings: true });
-                            const structuredIssues = formatDoctorIssuesForPrompt(actionable);
-                            dispatchDoctorHeal(pi, doctorScope, reportText, structuredIssues);
-                            return "dispatched";
-                        }
-                        catch (e) {
-                            debugLog("postUnit", { phase: "doctor-heal-dispatch", error: String(e) });
-                        }
-                    }
-                }
-            }
-            catch (e) {
-                debugLog("postUnit", { phase: "doctor", error: String(e) });
-            }
-        // Throttled STATE.md rebuild (skipped for lightweight sidecars)
-        if (!opts?.skipStateRebuild) {
-            const now = Date.now();
-            if (now - s.lastStateRebuildAt >= STATE_REBUILD_MIN_INTERVAL_MS) {
-                try {
-                    await rebuildState(s.basePath);
-                    s.lastStateRebuildAt = now;
-                    autoCommitCurrentBranch(s.basePath, "state-rebuild", s.currentUnit.id);
-                }
-                catch (e) {
-                    debugLog("postUnit", { phase: "state-rebuild", error: String(e) });
-                }
-            }
-        }
         // Prune dead bg-shell processes
         try {
             const { pruneDeadProcesses } = await import("../bg-shell/process-manager.js");
@@ -411,6 +338,27 @@ export async function postUnitPreVerification(pctx, opts) {
             catch (e) {
                 debugLog("postUnit", { phase: "artifact-verify", error: String(e) });
             }
+            // If verification failed, attempt to regenerate missing projection files
+            // from DB data before giving up (e.g. research-slice produces PLAN from engine).
+            if (!triggerArtifactVerified) {
+                try {
+                    const parts = s.currentUnit.id.split("/");
+                    const [mid, sid] = parts;
+                    if (mid && sid) {
+                        const regenerated = regenerateIfMissing(s.basePath, mid, sid, "PLAN");
+                        if (regenerated) {
+                            // Re-check after regeneration
+                            triggerArtifactVerified = verifyExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
+                            if (triggerArtifactVerified) {
+                                invalidateAllCaches();
+                            }
+                        }
+                    }
+                }
+                catch (e) {
+                    debugLog("postUnit", { phase: "regenerate-projection", error: String(e) });
+                }
+            }
             // When artifact verification fails for a unit type that has a known expected
             // artifact, return "retry" so the caller re-dispatches with failure context
             // instead of blindly re-dispatching the same unit (#1571).
@@ -432,18 +380,7 @@ export async function postUnitPreVerification(pctx, opts) {
             }
         }
         else {
-            // Hook unit completed — finalize its runtime record
-            try {
-                writeUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt, {
-                    phase: "finalized",
-                    progressCount: 1,
-                    lastProgressKind: "hook-completed",
-                });
-                clearUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id);
-            }
-            catch (e) {
-                debugLog("postUnit", { phase: "hook-finalize", error: String(e) });
-            }
+            // Hook unit completed — no additional processing needed
         }
     }
     return "continue";
@@ -517,15 +454,7 @@ export async function postUnitPostVerification(pctx) {
                             }
                         }
                     }
-                    // 3. Remove from s.completedUnits and flush to completed-units.json
-                    s.completedUnits = s.completedUnits.filter(u => !(u.type === trigger.unitType && u.id === trigger.unitId));
-                    try {
-                        const completedKeysPath = join(gsdRoot(s.basePath), "completed-units.json");
-                        const keys = s.completedUnits.map(u => `${u.type}/${u.id}`);
-                        atomicWriteSync(completedKeysPath, JSON.stringify(keys, null, 2));
-                    }
-                    catch { /* non-fatal: disk flush failure */ }
-                    // 4. Delete the retry_on artifact (e.g. NEEDS-REWORK.md)
+                    // 3. Delete the retry_on artifact (e.g. NEEDS-REWORK.md)
                     if (trigger.retryArtifact) {
                         const retryArtifactPath = resolveHookArtifactPath(s.basePath, trigger.unitId, trigger.retryArtifact);
                         if (existsSync(retryArtifactPath)) {

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

@@ -352,7 +352,6 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         });
         s.autoStartTime = Date.now();
         s.resourceVersionOnStart = readResourceVersion();
-        s.completedUnits = [];
         s.pendingQuickTasks = [];
         s.currentUnit = null;
         s.currentMilestoneId = state.activeMilestone?.id ?? null;
@@ -455,8 +454,8 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             ? `Will loop through ${pendingCount} milestones.`
             : "Will loop until milestone complete.";
         ctx.ui.notify(`${modeLabel} started. ${scopeMsg}`, "info");
-        updateSessionLock(lockBase(), "starting", s.currentMilestoneId ?? "unknown", 0);
-        writeLock(lockBase(), "starting", s.currentMilestoneId ?? "unknown", 0);
+        updateSessionLock(lockBase(), "starting", s.currentMilestoneId ?? "unknown");
+        writeLock(lockBase(), "starting", s.currentMilestoneId ?? "unknown");
         // Secrets collection gate
         const mid = state.activeMilestone.id;
         try {

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

@@ -17,6 +17,7 @@ import { createWorktree, removeWorktree, resolveGitDir, worktreePath, } from "./
 import { detectWorktreeName, nudgeGitBranchCache, } from "./worktree.js";
 import { MergeConflictError, readIntegrationBranch, RUNTIME_EXCLUSION_PATHS } from "./git-service.js";
 import { debugLog } from "./debug-logger.js";
+import { logWarning } from "./workflow-logger.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, } from "./native-git-bridge.js";
 // ─── Module State ──────────────────────────────────────────────────────────
@@ -615,7 +616,7 @@ export function createAutoWorktree(basePath, milestoneId) {
     const hookError = runWorktreePostCreateHook(basePath, info.path);
     if (hookError) {
         // Non-fatal — log but don't prevent worktree usage
-        console.error(`[GSD] ${hookError}`);
+        logWarning("reconcile", hookError, { worktree: info.name });
     }
     const previousCwd = process.cwd();
     try {
@@ -690,9 +691,9 @@ export function teardownAutoWorktree(originalBasePath, milestoneId, opts = {}) {
     // backslashes (#1436), leaving ~1 GB+ orphaned directories.
     const wtDir = worktreePath(originalBasePath, milestoneId);
     if (existsSync(wtDir)) {
-        console.error(`[GSD] WARNING: Worktree directory still exists after teardown: ${wtDir}\n` +
-            `  This is likely an orphaned directory consuming disk space.\n` +
-            `  Remove it manually with: rm -rf "${wtDir.replaceAll("\\", "/")}"`);
+        logWarning("reconcile", `Worktree directory still exists after teardown: ${wtDir}. ` +
+            `This is likely an orphaned directory consuming disk space. ` +
+            `Remove it manually with: rm -rf "${wtDir.replaceAll("\\", "/")}"`, { worktree: milestoneId });
         // Attempt a direct filesystem removal as a fallback
         try {
             rmSync(wtDir, { recursive: true, force: true });