gsd-pi 2.45.0-dev.fdcf73c → 2.46.0-dev.cc9d310

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

@@ -11,13 +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.
@@ -179,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) {
@@ -368,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",
@@ -588,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,
@@ -703,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,
@@ -720,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];
@@ -765,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 } };
             }
         }
@@ -776,27 +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 (e) {
-            logWarning("engine", "Failed to flush completed-units to disk", { error: String(e) });
-        }
-        deps.clearUnitRuntimeRecord(s.basePath, unitType, unitId);
         s.unitDispatchCount.delete(`${unitType}/${unitId}`);
         s.unitRecoveryCount.delete(`${unitType}/${unitId}`);
     }
@@ -829,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/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.js

@@ -19,13 +19,11 @@ import { clearActivityLogState } from "./activity-log.js";
 import { synthesizeCrashRecovery, getDeepDiagnostic, } from "./session-forensics.js";
 import { writeLock, clearLock, readCrashLock, isLockProcessAlive, } from "./crash-recovery.js";
 import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
-import { clearUnitRuntimeRecord, readUnitRuntimeRecord, writeUnitRuntimeRecord, } from "./unit-runtime.js";
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
 import { sendDesktopNotification } from "./notifications.js";
 import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, } from "./auto-budget.js";
 import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
-import { selfHealRuntimeRecords } from "./auto-recovery.js";
 import { selectAndApplyModel, resolveModelId } from "./auto-model-selection.js";
 import { syncProjectRootToWorktree, checkResourcesStale, escapeStaleWorktree, } from "./auto-worktree-sync.js";
 import { resetRoutingHistory, recordOutcome } from "./routing-history.js";
@@ -44,7 +42,7 @@ import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
 import { createAutoWorktree, enterAutoWorktree, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, syncWorktreeStateBack, } from "./auto-worktree.js";
 import { pruneQueueOrder } from "./queue-order.js";
 import { debugLog, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
-import { verifyExpectedArtifact, reconcileMergeState, } from "./auto-recovery.js";
+import { reconcileMergeState, } from "./auto-recovery.js";
 import { resolveDispatch, DISPATCH_RULES } from "./auto-dispatch.js";
 import { initRegistry, convertDispatchRules } from "./rule-registry.js";
 import { emitJournalEvent as _emitJournalEvent } from "./journal.js";
@@ -145,7 +143,6 @@ export function getAutoDashboardData() {
             ? (s.autoStartTime > 0 ? Date.now() - s.autoStartTime : 0)
             : 0,
         currentUnit: s.currentUnit ? { ...s.currentUnit } : null,
-        completedUnits: [...s.completedUnits],
         basePath: s.basePath,
         totalCost: totals?.cost ?? 0,
         totalTokens: totals?.tokens.total ?? 0,
@@ -244,7 +241,6 @@ export function checkRemoteAutoSession(projectRoot) {
         unitType: lock.unitType,
         unitId: lock.unitId,
         startedAt: lock.startedAt,
-        completedUnits: lock.completedUnits,
     };
 }
 export function isStepMode() {
@@ -269,16 +265,12 @@ function clearUnitTimeout() {
     }
     clearInFlightTools();
 }
-/** Build snapshot metric opts, enriching with continueHereFired from the runtime record. */
-function buildSnapshotOpts(unitType, unitId) {
-    const runtime = s.currentUnit
-        ? readUnitRuntimeRecord(s.basePath, unitType, unitId)
-        : null;
+/** Build snapshot metric opts. */
+function buildSnapshotOpts(_unitType, _unitId) {
     return {
         promptCharCount: s.lastPromptCharCount,
         baselineCharCount: s.lastBaselineCharCount,
         ...(s.currentUnitRouting ?? {}),
-        ...(runtime?.continueHereFired ? { continueHereFired: true } : {}),
     };
 }
 function handleLostSessionLock(ctx, lockStatus) {
@@ -586,12 +578,6 @@ export async function pauseAuto(ctx, _pi) {
         catch {
             // Non-fatal — best-effort closeout on pause
         }
-        try {
-            clearUnitRuntimeRecord(s.basePath, s.currentUnit.type, s.currentUnit.id);
-        }
-        catch {
-            // Non-fatal
-        }
         s.currentUnit = null;
     }
     if (lockBase()) {
@@ -710,9 +696,6 @@ function buildLoopDeps() {
         getMainBranch,
         // Unit closeout + runtime records
         closeoutUnit,
-        verifyExpectedArtifact,
-        clearUnitRuntimeRecord,
-        writeUnitRuntimeRecord,
         recordOutcome,
         writeLock,
         captureAvailableSkills,
@@ -861,15 +844,6 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             });
         }
         invalidateAllCaches();
-        // Clean stale runtime records left from the paused session
-        try {
-            await selfHealRuntimeRecords(s.basePath, ctx);
-        }
-        catch (e) {
-            debugLog("resume-self-heal-runtime-failed", {
-                error: e instanceof Error ? e.message : String(e),
-            });
-        }
         if (s.pausedSessionFile) {
             const activityDir = join(gsdRoot(s.basePath), "activity");
             const recovery = synthesizeCrashRecovery(s.basePath, s.currentUnit?.type ?? "unknown", s.currentUnit?.id ?? "unknown", s.pausedSessionFile ?? undefined, activityDir);
@@ -879,11 +853,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             }
             s.pausedSessionFile = null;
         }
-        updateSessionLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown", s.completedUnits.length);
-        writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown", s.completedUnits.length);
+        updateSessionLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
+        writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
         logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "progress");
-        // Clear orphaned runtime records from prior process deaths before entering the loop
-        await selfHealRuntimeRecords(s.basePath, ctx);
         await autoLoop(ctx, pi, s, buildLoopDeps());
         cleanupAfterLoopExit(ctx);
         return;
@@ -905,8 +877,6 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         // Best-effort only — sidebar sync must never block auto-mode startup
     }
     logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, requestedStepMode ? "Step-mode started." : "Auto-mode started.", "progress");
-    // Clear orphaned runtime records from prior process deaths before entering the loop
-    await selfHealRuntimeRecords(s.basePath, ctx);
     // Dispatch the first unit
     await autoLoop(ctx, pi, s, buildLoopDeps());
     cleanupAfterLoopExit(ctx);
@@ -1005,7 +975,6 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         s.basePath = targetBasePath;
         s.autoStartTime = Date.now();
         s.currentUnit = null;
-        s.completedUnits = [];
         s.pendingQuickTasks = [];
     }
     const hookUnitType = `hook/${hookName}`;
@@ -1025,14 +994,6 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         id: triggerUnitId,
         startedAt: hookStartedAt,
     };
-    writeUnitRuntimeRecord(s.basePath, hookUnitType, triggerUnitId, hookStartedAt, {
-        phase: "dispatched",
-        wrapupWarningSent: false,
-        timeoutAt: null,
-        lastProgressAt: hookStartedAt,
-        progressCount: 0,
-        lastProgressKind: "dispatch",
-    });
     if (hookModel) {
         const availableModels = ctx.modelRegistry.getAvailable();
         const match = resolveModelId(hookModel, availableModels, ctx.model?.provider);
@@ -1050,7 +1011,7 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         }
     }
     const sessionFile = ctx.sessionManager.getSessionFile();
-    writeLock(lockBase(), hookUnitType, triggerUnitId, s.completedUnits.length, sessionFile);
+    writeLock(lockBase(), hookUnitType, triggerUnitId, sessionFile);
     clearUnitTimeout();
     const supervisor = resolveAutoSupervisorConfig();
     const hookHardTimeoutMs = (supervisor.hard_timeout_minutes ?? 30) * 60 * 1000;
@@ -1058,12 +1019,6 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         s.unitTimeoutHandle = null;
         if (!s.active)
             return;
-        if (s.currentUnit) {
-            writeUnitRuntimeRecord(s.basePath, hookUnitType, triggerUnitId, hookStartedAt, {
-                phase: "timeout",
-                timeoutAt: Date.now(),
-            });
-        }
         ctx.ui.notify(`Hook ${hookName} exceeded ${supervisor.hard_timeout_minutes ?? 30}min timeout. Pausing auto-mode.`, "warning");
         resetHookState();
         await pauseAuto(ctx, pi);
@@ -1086,4 +1041,5 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
 // Direct phase dispatch → auto-direct-dispatch.ts
 export { dispatchDirectPhase } from "./auto-direct-dispatch.js";
 // Re-export recovery functions for external consumers
-export { resolveExpectedArtifactPath, verifyExpectedArtifact, writeBlockerPlaceholder, buildLoopRemediationSteps, } from "./auto-recovery.js";
+export { buildLoopRemediationSteps, } from "./auto-recovery.js";
+export { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -4,6 +4,7 @@ import { buildMilestoneFileName, resolveMilestonePath, resolveSliceFile, resolve
 import { buildBeforeAgentStartResult } from "./system-context.js";
 import { handleAgentEnd } from "./agent-end-recovery.js";
 import { isDepthVerified, isQueuePhaseActive, markDepthVerified, resetWriteGateState, shouldBlockContextWrite } from "./write-gate.js";
+import { isBlockedStateFile, isBashWriteToStateFile, BLOCKED_WRITE_ERROR } from "../write-intercept.js";
 import { getDiscussionMilestoneId } from "../guided-flow.js";
 import { loadToolApiKeys } from "../commands-config.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
@@ -128,6 +129,23 @@ export function registerHooks(pi) {
         if (loopCheck.block) {
             return { block: true, reason: loopCheck.reason };
         }
+        // ── Single-writer engine: block direct writes to STATE.md ──────────
+        // Covers write, edit, and bash tools to prevent bypass vectors.
+        if (isToolCallEventType("write", event)) {
+            if (isBlockedStateFile(event.input.path)) {
+                return { block: true, reason: BLOCKED_WRITE_ERROR };
+            }
+        }
+        if (isToolCallEventType("edit", event)) {
+            if (isBlockedStateFile(event.input.path)) {
+                return { block: true, reason: BLOCKED_WRITE_ERROR };
+            }
+        }
+        if (isToolCallEventType("bash", event)) {
+            if (isBashWriteToStateFile(event.input.command)) {
+                return { block: true, reason: BLOCKED_WRITE_ERROR };
+            }
+        }
         if (!isToolCallEventType("write", event))
             return;
         const result = shouldBlockContextWrite(event.toolName, event.input.path, getDiscussionMilestoneId(), isDepthVerified(), isQueuePhaseActive());