@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.72e3af2a

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

@@ -9,62 +9,25 @@
  * globals or AutoContext dependency.
  */
 import { parseUnitId } from "./unit-id.js";
-import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { appendEvent } from "./workflow-events.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { clearParseCache } from "./files.js";
-import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
-import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGatesForTurn, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, updateMilestoneStatus, transaction, } from "./gsd-db.js";
+import { isDbAvailable, getTask, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, updateMilestoneStatus, transaction, } from "./gsd-db.js";
 import { refreshWorkflowDatabaseFromDisk } from "./db-workspace.js";
-import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
-import { logWarning, logError } from "./workflow-logger.js";
+import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
-import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
+import { resolveSlicePath, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, clearPathCache, } from "./paths.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
-import { execFileSync } from "node:child_process";
-import { LAYOUT_SEGMENTS } from "./layout-policy.js";
-import { dirname, join, resolve } from "node:path";
+import { dirname } from "node:path";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-artifact-paths.js";
-import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
-import { hasVerdict } from "./verdict-parser.js";
-import { validateArtifact } from "./schemas/validate.js";
-import { getProjectResearchStatus } from "./project-research-policy.js";
-import { isGsdWorktreePath } from "./worktree-root.js";
-import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
-import { resolveWorktreeProjectRoot } from "./worktree-root.js";
-import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
-import { loadAllCaptures, loadPendingCaptures } from "./captures.js";
+import { resolveArtifactVerificationBase, } from "./artifact-verification.js";
 import { proveMilestoneCloseout, } from "./milestone-closeout-proof.js";
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
 export { classifyMilestoneSummaryContent, } from "./milestone-summary-classifier.js";
 export { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
-/**
- * Optional override for the legacy roadmap parser used by verifyExpectedArtifact.
- * Production leaves this null so the real parseLegacyRoadmap runs; tests inject
- * a throwing function to deterministically exercise the parse-failure catches
- * (auto-recovery.ts:515 plan-milestone and :622 complete-slice). Those catches
- * are otherwise unreachable because parseLegacyRoadmap is internally defensive
- * against every malformed input.
- * @internal
- */
-let _roadmapParserFn = null;
-/**
- * Inject an override for the legacy roadmap parser, returning a function that
- * restores the default (real parser) behavior. No production caller.
- * @internal
- */
-export function _setRoadmapParserFnForTests(fn) {
-    const previous = _roadmapParserFn;
-    _roadmapParserFn = fn;
-    return () => { _roadmapParserFn = previous; };
-}
-function parseRoadmapForRecovery(content) {
-    if (_roadmapParserFn)
-        return _roadmapParserFn(content);
-    return parseLegacyRoadmap(content);
-}
+export { verifyExpectedArtifact, diagnoseWorktreeIntegrityFailure, resolveArtifactVerificationBase, _setRoadmapParserFnForTests, } from "./artifact-verification.js";
 /**
  * Optional override for the detached GitHub milestone finalize invoked after DB
  * closeout in refreshRecoveryDbForArtifact. Production leaves this null so the
@@ -79,35 +42,6 @@ export function _setGithubFinalizeFnForTests(fn) {
     _githubFinalizeFn = fn;
     return () => { _githubFinalizeFn = previous; };
 }
-// ─── Artifact Resolution & Verification ───────────────────────────────────────
-export function diagnoseWorktreeIntegrityFailure(basePath) {
-    if (!isGsdWorktreePath(basePath))
-        return null;
-    if (!existsSync(basePath)) {
-        return `Worktree integrity failure: ${basePath} does not exist. Repair or recreate the worktree before retrying.`;
-    }
-    const gitPath = join(basePath, ".git");
-    if (!existsSync(gitPath)) {
-        return `Worktree integrity failure: ${basePath} is not a valid git worktree (.git missing). Repair or recreate the worktree before retrying.`;
-    }
-    try {
-        execFileSync("git", ["rev-parse", "--git-dir"], {
-            cwd: basePath,
-            stdio: ["ignore", "pipe", "pipe"],
-            encoding: "utf-8",
-        });
-        return null;
-    }
-    catch (err) {
-        return `Worktree integrity failure: ${basePath} is not a valid git worktree (git rev-parse failed: ${getErrorMessage(err).split("\n")[0]}). Repair or recreate the worktree before retrying.`;
-    }
-}
-function resolveArtifactVerificationBase(unitId, base) {
-    const { milestone } = parseUnitId(unitId);
-    if (!MILESTONE_ID_RE.test(milestone))
-        return base;
-    return resolveCanonicalMilestoneRoot(base, milestone);
-}
 function closeoutProofRecoveryReason(reason) {
     switch (reason) {
         case "slice-missing":
@@ -224,441 +158,6 @@ export function refreshRecoveryDbForArtifact(unitType, unitId, basePath) {
     }
     return { ok: true };
 }
-function hasCapturedWorkflowPrefs(base) {
-    const prefsPath = resolveExpectedArtifactPath("workflow-preferences", "WORKFLOW-PREFS", base);
-    if (!prefsPath || !existsSync(prefsPath))
-        return false;
-    const content = readFileSync(prefsPath, "utf-8");
-    const match = content.match(/^---\r?\n([\s\S]*?)\r?\n---/);
-    return !!match && /^workflow_prefs_captured:\s*true\s*$/m.test(match[1]);
-}
-function hasValidResearchDecision(base) {
-    const decisionPath = resolveExpectedArtifactPath("research-decision", "RESEARCH-DECISION", base);
-    if (!decisionPath || !existsSync(decisionPath))
-        return false;
-    try {
-        const cfg = JSON.parse(readFileSync(decisionPath, "utf-8"));
-        return cfg.decision === "research" || cfg.decision === "skip";
-    }
-    catch {
-        return false;
-    }
-}
-function hasCompleteProjectResearch(base) {
-    return getProjectResearchStatus(base).complete;
-}
-function escapeRegExp(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-function hasCheckedTaskCompletionOnDisk(base, mid, sid, tid) {
-    const slicePath = resolveSlicePath(base, mid, sid);
-    if (!slicePath)
-        return false;
-    const planAbs = resolveSliceFile(base, mid, sid, "PLAN");
-    if (!planAbs || !existsSync(planAbs))
-        return false;
-    const planContent = readFileSync(planAbs, "utf-8");
-    // Match legacy (`**T01: Title**`) and flat-phase (`**T01**: Title`) checkbox lines.
-    const cbRe = new RegExp(`^\\s*-\\s+\\[[xX]\\]\\s+\\*\\*${escapeRegExp(tid)}(?:\\*\\*)?:`, "m");
-    return cbRe.test(planContent);
-}
-/**
- * Check whether the expected artifact(s) for a unit exist on disk.
- * Returns true if all required artifacts exist, or if the unit type has no
- * single verifiable artifact (e.g., replan-slice).
- *
- * complete-slice requires both SUMMARY and UAT files — verifying only
- * the summary allowed the unit to be marked complete when the LLM
- * skipped writing the UAT file (see #176).
- */
-export function verifyExpectedArtifact(unitType, unitId, base) {
-    // Hook units have no standard artifact — always pass. Their lifecycle
-    // is managed by the hook engine, not the artifact verification system.
-    if (unitType.startsWith("hook/"))
-        return true;
-    // Clear stale directory listing cache AND parse cache so artifact checks see
-    // fresh disk state (#431). The parse cache must also be cleared because
-    // cacheKey() uses length + first/last 100 chars — when a checkbox changes
-    // from [ ] to [x], the key collides with the pre-edit version, returning
-    // stale parsed results (e.g., slice.done = false when it's actually true).
-    clearPathCache();
-    clearParseCache();
-    if (unitType === "rewrite-docs") {
-        const overridesPath = resolveGsdRootFile(base, "OVERRIDES");
-        if (!existsSync(overridesPath))
-            return true;
-        const content = readFileSync(overridesPath, "utf-8");
-        return !content.includes("**Scope:** active");
-    }
-    if (unitType === "workflow-preferences") {
-        return hasCapturedWorkflowPrefs(base);
-    }
-    if (unitType === "triage-captures") {
-        const pending = loadPendingCaptures(base);
-        if (pending.length === 0)
-            return true;
-        logWarning("recovery", `verify-fail triage-captures ${unitId}: ${pending.length} pending capture(s) remain in CAPTURES.md`);
-        return false;
-    }
-    if (unitType === "quick-task") {
-        const { slice: captureId } = parseUnitId(unitId);
-        const capture = captureId ? loadAllCaptures(base).find((entry) => entry.id === captureId) : undefined;
-        if (capture?.executed === true)
-            return true;
-        logWarning("recovery", `verify-fail quick-task ${unitId}: capture ${captureId ?? "(missing capture id)"} not found or not marked executed`);
-        return false;
-    }
-    if (unitType === "discuss-project") {
-        const projectPath = resolveExpectedArtifactPath(unitType, unitId, base);
-        return !!projectPath && existsSync(projectPath) && validateArtifact(projectPath, "project").ok;
-    }
-    if (unitType === "discuss-requirements") {
-        const requirementsPath = resolveExpectedArtifactPath(unitType, unitId, base);
-        return !!requirementsPath && existsSync(requirementsPath) && validateArtifact(requirementsPath, "requirements").ok;
-    }
-    if (unitType === "research-decision") {
-        return hasValidResearchDecision(base);
-    }
-    if (unitType === "research-project") {
-        return hasCompleteProjectResearch(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 { milestone: mid, slice: sid, task: batchPart } = parseUnitId(unitId);
-        if (!mid || !sid || !batchPart)
-            return false;
-        const blockerPath = resolveExpectedArtifactPath(unitType, unitId, base);
-        if (blockerPath && existsSync(blockerPath)) {
-            return true;
-        }
-        const slicePath = resolveSlicePath(base, mid, sid);
-        if (!slicePath)
-            return false;
-        const plusIdx = batchPart.indexOf("+");
-        if (plusIdx === -1) {
-            // Legacy format "reactive" without batch IDs — fall back to "any summary"
-            const tDir = resolveTasksDir(base, mid, sid) ?? slicePath;
-            const summaryFiles = resolveTaskFiles(tDir, "SUMMARY");
-            return summaryFiles.length > 0;
-        }
-        const batchIds = batchPart.slice(plusIdx + 1).split(",").filter(Boolean);
-        if (batchIds.length === 0)
-            return false;
-        const tDir = resolveTasksDir(base, mid, sid) ?? slicePath;
-        const existingSummaries = new Set(resolveTaskFiles(tDir, "SUMMARY").map((f) => f.replace(/-SUMMARY\.md$/i, "").toUpperCase()));
-        // Every dispatched task must have a summary file
-        for (const tid of batchIds) {
-            if (!existingSummaries.has(tid.toUpperCase()))
-                return false;
-        }
-        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 {
-            if (!isDbAvailable())
-                return false;
-            const pending = getPendingGatesForTurn(mid, sid, "gate-evaluate");
-            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 (err) {
-            // DB unavailable — treat as verified to avoid blocking
-            logWarning("recovery", `gate-evaluate DB check failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-        return true;
-    }
-    // #4414: research-slice parallel-research sentinel. The unitId
-    // `{mid}/parallel-research` is not a real slice — it triggers a single agent
-    // that fans out research across multiple slices. Verify success by checking
-    // that every slice which was "research-ready" in the roadmap now has a
-    // RESEARCH file. Without this, resolveExpectedArtifactPath returns null and
-    // the retry/escalation machinery silently re-dispatches forever.
-    //
-    // #4068: Also treat a PARALLEL-BLOCKER placeholder as a terminal completion
-    // so that timeout-recovery can write the blocker, have verifyExpectedArtifact
-    // return true, and let the dispatch loop advance past this unit.  Without
-    // this, the blocker is written but verification still returns false, the unit
-    // is never cleared from unitDispatchCount, and on the next iteration the
-    // dispatch rule (which correctly skips parallel-research when PARALLEL-BLOCKER
-    // exists) returns null — leaving the loop stuck re-deriving indefinitely.
-    //
-    // NOTE: this predicate mirrors the dispatch rule at
-    // auto-dispatch.ts parallel-research-slices — keep the two in sync.
-    if (unitType === "research-slice" && unitId.endsWith("/parallel-research")) {
-        const { milestone: mid } = parseUnitId(unitId);
-        if (!mid)
-            return false;
-        // #4068: PARALLEL-BLOCKER written by timeout-recovery is a terminal state.
-        const blockerPath = resolveExpectedArtifactPath(unitType, unitId, base);
-        if (blockerPath && existsSync(blockerPath)) {
-            return true;
-        }
-        const roadmapFile = resolveExpectedArtifactPath("plan-milestone", mid, base);
-        if (!roadmapFile || !existsSync(roadmapFile)) {
-            logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap missing`);
-            return false;
-        }
-        try {
-            const roadmap = parseRoadmapForRecovery(readFileSync(roadmapFile, "utf-8"));
-            const milestoneResearchFile = resolveExpectedArtifactPath("research-milestone", mid, base);
-            const hasMilestoneResearch = !!milestoneResearchFile && existsSync(milestoneResearchFile);
-            for (const slice of roadmap.slices) {
-                if (slice.done)
-                    continue;
-                if (hasMilestoneResearch && slice.id === "S01")
-                    continue;
-                const depsComplete = (slice.depends ?? []).every((depId) => {
-                    const summaryPath = resolveExpectedArtifactPath("complete-slice", `${mid}/${depId}`, base);
-                    return !!summaryPath && existsSync(summaryPath);
-                });
-                if (!depsComplete)
-                    continue;
-                const researchPath = resolveExpectedArtifactPath("research-slice", `${mid}/${slice.id}`, base);
-                if (!researchPath || !existsSync(researchPath)) {
-                    logWarning("recovery", `verify-fail ${unitType} ${unitId}: slice ${slice.id} missing RESEARCH`);
-                    return false;
-                }
-            }
-            return true;
-        }
-        catch (err) {
-            logWarning("recovery", `parallel-research verification failed: ${err instanceof Error ? err.message : String(err)}`);
-            return false;
-        }
-    }
-    const artifactBase = resolveArtifactVerificationBase(unitId, base);
-    let absPath = resolveExpectedArtifactPath(unitType, unitId, artifactBase);
-    // Worktree→project-root fallback: a milestone running in a worktree may not
-    // have its CONTEXT/ROADMAP/SUMMARY projected into the worktree yet (the
-    // worktree only has the META dir until planning writes its projections).
-    // When the worktree base yields null or a non-existent path, fall back to the
-    // project root — where the artifact genuinely lives. Without this, a
-    // discuss-milestone unit with CONTEXT at phases/NN-slug/ in the project root
-    // but not in the worktree resolves to null → "resolveExpectedArtifactPath
-    // returned null" → finalize-retry loop (#852).
-    if (artifactBase !== base) {
-        const projectRoot = resolve(resolveWorktreeProjectRoot(artifactBase));
-        if (projectRoot && projectRoot !== artifactBase) {
-            if (!absPath || !existsSync(absPath)) {
-                const projectPath = resolveExpectedArtifactPath(unitType, unitId, projectRoot);
-                if (projectPath && existsSync(projectPath)) {
-                    absPath = projectPath;
-                }
-            }
-        }
-    }
-    // For unit types with no registered artifact contract (null path), treat the
-    // completion state as stale so the key gets evicted (#313).
-    if (!absPath) {
-        logWarning("recovery", `verify-fail ${unitType} ${unitId}: resolveExpectedArtifactPath returned null (no artifact contract registered for this unit type)`);
-        return false;
-    }
-    if (!existsSync(absPath)) {
-        const worktreeFailure = diagnoseWorktreeIntegrityFailure(artifactBase);
-        if (worktreeFailure) {
-            logError("recovery", `${worktreeFailure} Unit: ${unitType} ${unitId}.`);
-            return false;
-        }
-        logWarning("recovery", `verify-fail ${unitType} ${unitId}: existsSync false for ${absPath}`);
-        return false;
-    }
-    if (unitType === "validate-milestone") {
-        const validationContent = readFileSync(absPath, "utf-8");
-        if (!isValidationTerminal(validationContent)) {
-            logWarning("recovery", `verify-fail ${unitType} ${unitId}: validation not terminal (len=${validationContent.length}) at ${absPath}`);
-            return false;
-        }
-    }
-    if (unitType === "run-uat") {
-        const assessmentContent = readFileSync(absPath, "utf-8");
-        if (!hasVerdict(assessmentContent)) {
-            logWarning("recovery", `verify-fail ${unitType} ${unitId}: assessment missing verdict at ${absPath}`);
-            return false;
-        }
-    }
-    if (unitType === "plan-milestone") {
-        try {
-            const roadmap = parseRoadmapForRecovery(readFileSync(absPath, "utf-8"));
-            if (roadmap.slices.length === 0) {
-                logWarning("recovery", `verify-fail ${unitType} ${unitId}: roadmap has zero slices at ${absPath}`);
-                return false;
-            }
-        }
-        catch (err) {
-            logWarning("recovery", `plan-milestone roadmap verification failed: ${err instanceof Error ? err.message : String(err)}`);
-            return false;
-        }
-    }
-    // plan-slice verification is DB-primary. The slice plan is a projection, so
-    // DB task rows prove the slice was planned even if the rendered markdown no
-    // longer uses legacy checkbox/heading syntax.
-    if (unitType === "plan-slice") {
-        const { milestone: mid, slice: sid } = parseUnitId(unitId);
-        if (mid && sid) {
-            try {
-                let taskIds = null;
-                let dbPrimary = false;
-                if (isDbAvailable()) {
-                    const refreshed = refreshWorkflowDatabaseFromDisk();
-                    if (refreshed) {
-                        const tasks = getSliceTasks(mid, sid);
-                        if (tasks.length > 0) {
-                            taskIds = tasks.map(t => t.id);
-                            dbPrimary = true;
-                        }
-                    }
-                }
-                if (!taskIds) {
-                    // LEGACY: DB unavailable or no tasks in DB. Require actual task
-                    // entries so an empty scaffold cannot advance the pipeline (#699).
-                    const planContent = readFileSync(absPath, "utf-8");
-                    const hasCheckboxTask = /^\s*- \[[xX ]\] \*\*T\d+/m.test(planContent);
-                    const hasHeadingTask = /^\s*#{2,4}\s+T\d+\s*(?:--|—|:)/m.test(planContent);
-                    if (!hasCheckboxTask && !hasHeadingTask) {
-                        logWarning("recovery", `verify-fail ${unitType} ${unitId}: plan has no task checkbox/heading (len=${planContent.length}) at ${absPath}`);
-                        return false;
-                    }
-                    const plan = parseLegacyPlan(planContent);
-                    if (plan.tasks.length > 0)
-                        taskIds = plan.tasks.map((t) => t.id);
-                }
-                // Per-task plan file check: applies when a tasks/ directory is present on
-                // disk (legacy layout), regardless of whether DB is primary. Flat-phase
-                // projects have no tasks/ dir, so the check is naturally skipped there.
-                // When DB is NOT primary and there is no tasks/ dir either, the missing
-                // dir itself is evidence of an incomplete plan (non-flat-phase projects must
-                // have a tasks/ dir).
-                if (taskIds && taskIds.length > 0) {
-                    const tasksDir = join(dirname(absPath), "tasks");
-                    if (existsSync(tasksDir)) {
-                        for (const tid of taskIds) {
-                            const taskPlanFile = join(tasksDir, `${tid}-PLAN.md`);
-                            if (!existsSync(taskPlanFile)) {
-                                logWarning("recovery", `verify-fail ${unitType} ${unitId}: task plan missing ${taskPlanFile}`);
-                                return false;
-                            }
-                        }
-                    }
-                    else if (!dbPrimary && !absPath.replace(/\\/g, "/").includes(`.gsd/${LAYOUT_SEGMENTS.level1}`)) {
-                        logWarning("recovery", `verify-fail ${unitType} ${unitId}: tasks dir missing at ${tasksDir}`);
-                        return false;
-                    }
-                }
-            }
-            catch (err) {
-                // Parse failure — don't block; slice plan may have non-standard format
-                logWarning("recovery", `plan-slice task plan verification failed: ${err instanceof Error ? err.message : String(err)}`);
-            }
-        }
-    }
-    // execute-task: DB status is authoritative. Fall back to checked-checkbox
-    // detection when the DB is unavailable (unmigrated projects), or when the
-    // disk artifacts already reflect completion but the DB replay is one beat
-    // behind the completion write.
-    if (unitType === "execute-task") {
-        const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-        if (mid && sid && tid) {
-            const dbTask = getTask(mid, sid, tid);
-            if (dbTask) {
-                if (dbTask.status !== "complete" && dbTask.status !== "done" && !hasCheckedTaskCompletionOnDisk(base, mid, sid, tid)) {
-                    return false;
-                }
-            }
-            else if (!isDbAvailable()) {
-                // LEGACY: Pre-migration fallback for projects without DB.
-                // Require a CHECKED checkbox — a bare heading or unchecked checkbox
-                // does not prove gsd_complete_task ran. Summary file on disk alone
-                // is not sufficient evidence (could be a rogue write) (#3607).
-                if (!hasCheckedTaskCompletionOnDisk(base, mid, sid, tid))
-                    return false;
-            }
-            else {
-                // DB available but task row not found — completion tool never ran (#3607)
-                return false;
-            }
-        }
-    }
-    // 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 { milestone: mid, slice: sid } = parseUnitId(unitId);
-        if (mid && sid) {
-            // resolveSliceFile only finds existing files; UAT may not exist yet.
-            // Fall back to the canonical expected location so a missing UAT always
-            // returns false (not a silent pass when resolveSliceFile returns null).
-            const uatPath = resolveSliceFile(base, mid, sid, "UAT")
-                ?? join(base, relSliceFile(base, mid, sid, "UAT"));
-            if (!existsSync(uatPath))
-                return false;
-            const dbSlice = getSlice(mid, sid);
-            if (dbSlice) {
-                // DB available — trust it
-                if (dbSlice.status !== "complete")
-                    return false;
-            }
-            else if (!isDbAvailable()) {
-                // LEGACY: Pre-migration fallback for projects without DB.
-                // Fall back to roadmap checkbox check via parsers-legacy
-                const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-                if (roadmapFile && existsSync(roadmapFile)) {
-                    try {
-                        const roadmapContent = readFileSync(roadmapFile, "utf-8");
-                        const roadmap = parseRoadmapForRecovery(roadmapContent);
-                        const slice = roadmap.slices.find((s) => s.id === sid);
-                        if (slice && !slice.done)
-                            return false;
-                    }
-                    catch (e) {
-                        logWarning("recovery", `roadmap parse failed: ${e.message}`);
-                        return false;
-                    }
-                }
-            }
-            // else: DB available but slice not found — summary + UAT exist,
-            // treat as verified (slice may not be imported yet)
-        }
-    }
-    // complete-milestone must have produced implementation artifacts (#1703).
-    // A milestone with only .gsd/ plan files and zero implementation code is
-    // not genuinely complete — the LLM wrote plan files but skipped actual work.
-    if (unitType === "complete-milestone") {
-        const { milestone: mid } = parseUnitId(unitId);
-        if (!mid)
-            return false;
-        const closeoutProof = proveMilestoneCloseout(mid, {
-            refreshFromDisk: true,
-            summaryArtifactBasePath: artifactBase,
-            implementationEvidence: {
-                basePath: base,
-                requirement: "not-absent",
-            },
-        });
-        if (!closeoutProof.ok) {
-            if (!isDbAvailable() && closeoutProof.reason === "db-unavailable") {
-                const summaryOutcome = classifyMilestoneSummaryContent(readFileSync(absPath, "utf-8"));
-                return summaryOutcome !== "failure" && hasImplementationArtifacts(base, mid) !== "absent";
-            }
-            return false;
-        }
-    }
-    return true;
-}
 /**
  * Terminal recovery for a failed reactive-execute batch.
  *

package/dist/resources/extensions/gsd/auto-runtime-state.js

@@ -7,7 +7,6 @@ import { isDeterministicPolicyError, isQueuedUserMessageSkip, isToolInvocationEr
 export { isInteractiveElicitationInFlight } from "./auto-tool-tracking.js";
 import { createToolSurfaceSnapshot, } from "./tool-surface-snapshot.js";
 export const autoSession = new AutoSession();
-let currentToolSurfaceSnapshot = null;
 export function getAutoRuntimeSnapshot() {
     const orchestrationStatus = autoSession.orchestration?.getStatus();
     return {
@@ -18,15 +17,15 @@ export function getAutoRuntimeSnapshot() {
         orchestrationPhase: orchestrationStatus?.phase,
         orchestrationTransitionCount: orchestrationStatus?.transitionCount,
         orchestrationLastTransitionAt: orchestrationStatus?.lastTransitionAt,
-        toolSurface: autoSession.active || autoSession.paused ? currentToolSurfaceSnapshot : null,
+        toolSurface: autoSession.active || autoSession.paused ? autoSession.toolSurfaceSnapshot : null,
     };
 }
 export function recordAutoToolSurfaceSnapshot(input) {
-    currentToolSurfaceSnapshot = createToolSurfaceSnapshot(input);
-    return currentToolSurfaceSnapshot;
+    autoSession.toolSurfaceSnapshot = createToolSurfaceSnapshot(input);
+    return autoSession.toolSurfaceSnapshot;
 }
 export function clearAutoToolSurfaceSnapshot() {
-    currentToolSurfaceSnapshot = null;
+    autoSession.toolSurfaceSnapshot = null;
 }
 export function isAutoActive() {
     return autoSession.active;

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

@@ -4,7 +4,7 @@
  * and blocker placeholder generation.
  */
 import { readUnitRuntimeRecord, writeUnitRuntimeRecord, formatExecuteTaskRecoveryStatus, inspectExecuteTaskDurability, } from "./unit-runtime.js";
-import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, writeBlockerPlaceholder, } from "./auto-recovery.js";
+import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, verifyExpectedArtifact, writeBlockerPlaceholder, } from "./auto-recovery.js";
 import { existsSync } from "node:fs";
 import { bumpAndResolveSynthetic } from "./auto/resolve.js";
 import { finalizeProjectResearchTimeout } from "./project-research-policy.js";
@@ -128,10 +128,10 @@ export async function recoverTimedOutUnit(ctx, pi, unitType, unitId, reason, rct
         bumpAndResolveSynthetic(`timeout-recovery:${reason}:${unitType}/${unitId}`);
         return "recovered";
     }
-    // Check if the artifact already exists on disk — agent may have written it
+    // Check if the artifact is already valid on disk — agent may have written it
     // without signaling completion.
     const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
-    if (artifactPath && existsSync(artifactPath)) {
+    if (artifactPath && existsSync(artifactPath) && verifyExpectedArtifact(unitType, unitId, basePath)) {
         writeUnitRuntimeRecord(basePath, unitType, unitId, currentUnitStartedAt, {
             phase: "finalized",
             recoveryAttempts: recoveryAttempts + 1,