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

package/src/resources/extensions/gsd/auto-recovery.ts

@@ -14,7 +14,6 @@ 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,
@@ -72,6 +71,9 @@ 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,
   type CloseoutProofFailureReason,
@@ -84,35 +86,12 @@ export {
   type MilestoneSummaryOutcome,
 } 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: ((content: string) => { slices: Array<{ id: string; done: boolean; depends?: string[] }> }) | null = 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: ((content: string) => { slices: Array<{ id: string; done: boolean; depends?: string[] }> }) | null,
-): () => void {
-  const previous = _roadmapParserFn;
-  _roadmapParserFn = fn;
-  return () => { _roadmapParserFn = previous; };
-}
-
-function parseRoadmapForRecovery(content: string): ReturnType<NonNullable<typeof _roadmapParserFn>> {
-  if (_roadmapParserFn) return _roadmapParserFn(content);
-  return parseLegacyRoadmap(content) as unknown as ReturnType<NonNullable<typeof _roadmapParserFn>>;
-}
+export {
+  verifyExpectedArtifact,
+  diagnoseWorktreeIntegrityFailure,
+  resolveArtifactVerificationBase,
+  _setRoadmapParserFnForTests,
+} from "./artifact-verification.js";
 
 /**
  * Optional override for the detached GitHub milestone finalize invoked after DB
@@ -132,36 +111,7 @@ export function _setGithubFinalizeFnForTests(
   return () => { _githubFinalizeFn = previous; };
 }
 
-// ─── Artifact Resolution & Verification ───────────────────────────────────────
-
-export function diagnoseWorktreeIntegrityFailure(basePath: string): string | null {
-  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: string, base: string): string {
-  const { milestone } = parseUnitId(unitId);
-  if (!MILESTONE_ID_RE.test(milestone)) return base;
-  return resolveCanonicalMilestoneRoot(base, milestone);
-}
+// ─── Recovery DB refresh ──────────────────────────────────────────────────────
 
 export type ArtifactRecoveryDbRefreshResult =
   | { ok: true }
@@ -295,454 +245,6 @@ export function refreshRecoveryDbForArtifact(
   return { ok: true };
 }
 
-function hasCapturedWorkflowPrefs(base: string): boolean {
-  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: string): boolean {
-  const decisionPath = resolveExpectedArtifactPath("research-decision", "RESEARCH-DECISION", base);
-  if (!decisionPath || !existsSync(decisionPath)) return false;
-  try {
-    const cfg = JSON.parse(readFileSync(decisionPath, "utf-8")) as Record<string, unknown>;
-    return cfg.decision === "research" || cfg.decision === "skip";
-  } catch {
-    return false;
-  }
-}
-
-function hasCompleteProjectResearch(base: string): boolean {
-  return getProjectResearchStatus(base).complete;
-}
-
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function hasCheckedTaskCompletionOnDisk(base: string, mid: string, sid: string, tid: string): boolean {
-  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: string,
-  unitId: string,
-  base: string,
-): boolean {
-  // 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<string>(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: string[] | null = 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: { id: string }) => 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 as Error).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;
-}
-
 export interface ReactiveExecuteBlockerRecovery {
   blockerPath: string;
   completedTaskIds: string[];

package/src/resources/extensions/gsd/auto-runtime-state.ts

@@ -25,7 +25,6 @@ export type {
 } from "./tool-surface-snapshot.js";
 
 export const autoSession = new AutoSession();
-let currentToolSurfaceSnapshot: ToolSurfaceSnapshot | null = null;
 
 export type AutoRuntimeSnapshot = {
   active: boolean;
@@ -48,17 +47,17 @@ export function getAutoRuntimeSnapshot(): AutoRuntimeSnapshot {
     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: ToolSurfaceSnapshotInput): ToolSurfaceSnapshot {
-  currentToolSurfaceSnapshot = createToolSurfaceSnapshot(input);
-  return currentToolSurfaceSnapshot;
+  autoSession.toolSurfaceSnapshot = createToolSurfaceSnapshot(input);
+  return autoSession.toolSurfaceSnapshot;
 }
 
 export function clearAutoToolSurfaceSnapshot(): void {
-  currentToolSurfaceSnapshot = null;
+  autoSession.toolSurfaceSnapshot = null;
 }
 
 export function isAutoActive(): boolean {

package/src/resources/extensions/gsd/auto-timeout-recovery.ts

@@ -14,6 +14,7 @@ import {
 import {
   resolveExpectedArtifactPath,
   diagnoseExpectedArtifact,
+  verifyExpectedArtifact,
   writeBlockerPlaceholder,
 } from "./auto-recovery.js";
 import { existsSync } from "node:fs";
@@ -194,10 +195,10 @@ export async function recoverTimedOutUnit(
     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,