@opengsd/gsd-pi 1.2.0-dev.844675c9 → 1.2.0-dev.955e4da0

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

@@ -25,15 +25,13 @@ import {
   updateSliceStatus,
   insertSlice,
   getMilestone,
-  getMilestoneSlices,
-  getLatestAssessmentByScope,
   updateMilestoneStatus,
-  refreshOpenDatabaseFromDisk,
   getCompletedMilestoneTaskFileHints,
   getMilestoneCommitAttributionShas,
   recordMilestoneCommitAttribution,
   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";
@@ -72,7 +70,10 @@ import { isGsdWorktreePath } from "./worktree-root.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { hasImplementationArtifacts } from "./milestone-implementation-evidence.js";
 import { loadAllCaptures, loadPendingCaptures } from "./captures.js";
-import { checkCloseoutConsistencyGate } from "./closeout-consistency-gate.js";
+import {
+  proveMilestoneCloseout,
+  type CloseoutProofFailureReason,
+} from "./milestone-closeout-proof.js";
 
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
@@ -117,6 +118,19 @@ export type ArtifactRecoveryDbRefreshResult =
   | { ok: true }
   | { ok: false; fatal: boolean; message: string; reason: string };
 
+function closeoutProofRecoveryReason(reason: CloseoutProofFailureReason): string {
+  switch (reason) {
+    case "slice-missing":
+      return "complete-milestone-slices-missing";
+    case "summary-artifact-missing":
+      return "complete-milestone-summary-missing";
+    case "summary-artifact-failed":
+      return "complete-milestone-summary-failed";
+    default:
+      return `complete-milestone-${reason}`;
+  }
+}
+
 export function refreshRecoveryDbForArtifact(
   unitType: string,
   unitId: string,
@@ -125,7 +139,7 @@ export function refreshRecoveryDbForArtifact(
   if (unitType !== "plan-slice" && unitType !== "execute-task" && unitType !== "complete-milestone") return { ok: true };
   if (!isDbAvailable()) return { ok: true };
 
-  if (!refreshOpenDatabaseFromDisk()) {
+  if (!refreshWorkflowDatabaseFromDisk()) {
     return {
       ok: false,
       fatal: unitType === "execute-task" || unitType === "complete-milestone",
@@ -156,52 +170,29 @@ export function refreshRecoveryDbForArtifact(
     }
     if (isClosedStatus(milestone.status)) return { ok: true };
 
-    const validation = getLatestAssessmentByScope(mid, "milestone-validation");
-    if (validation?.status !== "pass") {
-      return {
-        ok: false,
-        fatal: true,
-        reason: "complete-milestone-validation-not-pass",
-        message: `Stuck recovery found complete-milestone ${unitId} artifacts, but milestone-validation is "${validation?.status ?? "absent"}" in the DB.`,
-      };
-    }
-
-    const slices = getMilestoneSlices(mid);
-    if (slices.length === 0) {
-      return {
-        ok: false,
-        fatal: true,
-        reason: "complete-milestone-slices-missing",
-        message: `Stuck recovery found complete-milestone ${unitId} artifacts, but no slices exist in the DB.`,
-      };
-    }
-    const openSlice = slices.find((slice) => !isClosedStatus(slice.status));
-    if (openSlice) {
-      return {
-        ok: false,
-        fatal: true,
-        reason: "complete-milestone-slice-open",
-        message: `Stuck recovery found complete-milestone ${unitId} artifacts, but slice ${openSlice.id} is still "${openSlice.status}" in the DB.`,
-      };
-    }
-    for (const slice of slices) {
-      const openTask = getSliceTasks(mid, slice.id).find((task) => !isClosedStatus(task.status));
-      if (openTask) {
+    const artifactBasePath = resolveArtifactVerificationBase(unitId, basePath);
+    const closeoutProof = proveMilestoneCloseout(mid, {
+      allowOpenMilestone: true,
+      summaryArtifactBasePath: artifactBasePath,
+      implementationEvidence: {
+        basePath,
+        requirement: "present",
+      },
+    });
+    if (!closeoutProof.ok) {
+      if (closeoutProof.reason === "implementation-evidence-missing") {
         return {
           ok: false,
           fatal: true,
-          reason: "complete-milestone-task-open",
-          message: `Stuck recovery found complete-milestone ${unitId} artifacts, but task ${slice.id}/${openTask.id} is still "${openTask.status}" in the DB.`,
+          reason: "complete-milestone-implementation-missing",
+          message: `Stuck recovery found complete-milestone ${unitId} artifacts, but implementation evidence is not present.`,
         };
       }
-    }
-
-    if (hasImplementationArtifacts(basePath, mid) !== "present") {
       return {
         ok: false,
         fatal: true,
-        reason: "complete-milestone-implementation-missing",
-        message: `Stuck recovery found complete-milestone ${unitId} artifacts, but implementation evidence is not present.`,
+        reason: closeoutProofRecoveryReason(closeoutProof.reason),
+        message: `Stuck recovery found complete-milestone ${unitId} artifacts, but ${closeoutProof.message}`,
       };
     }
 
@@ -535,7 +526,7 @@ export function verifyExpectedArtifact(
       try {
         let taskIds: string[] | null = null;
         if (isDbAvailable()) {
-          const refreshed = refreshOpenDatabaseFromDisk();
+          const refreshed = refreshWorkflowDatabaseFromDisk();
           if (refreshed) {
             const tasks = getSliceTasks(mid, sid);
             if (tasks.length > 0) taskIds = tasks.map(t => t.id);
@@ -642,14 +633,23 @@ export function verifyExpectedArtifact(
   // 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 summaryOutcome = classifyMilestoneSummaryContent(readFileSync(absPath, "utf-8"));
-    if (summaryOutcome === "failure") return false;
     const { milestone: mid } = parseUnitId(unitId);
-    if (mid && isDbAvailable()) {
-      const closeoutGate = checkCloseoutConsistencyGate(mid, { refreshFromDisk: true });
-      if (!closeoutGate.ok) return false;
+    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;
     }
-    if (hasImplementationArtifacts(base, mid) === "absent") return false;
   }
 
   return true;

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

@@ -9,8 +9,23 @@ import {
   markToolEnd as markTrackedToolEnd,
   markToolStart as markTrackedToolStart,
 } from "./auto-tool-tracking.js";
+// Re-exported as a pure pass-through. Must stay UNGATED (no autoSession.active
+// argument, unlike markToolStart at the bottom of this file) so it is true in
+// foreground where the foreground approval-gate pause consults it.
+export { isInteractiveElicitationInFlight } from "./auto-tool-tracking.js";
+import {
+  createToolSurfaceSnapshot,
+  type ToolSurfaceSnapshot,
+  type ToolSurfaceSnapshotInput,
+} from "./tool-surface-snapshot.js";
+
+export type {
+  ToolSurfaceSnapshot,
+  ToolSurfaceSnapshotInput,
+} from "./tool-surface-snapshot.js";
 
 export const autoSession = new AutoSession();
+let currentToolSurfaceSnapshot: ToolSurfaceSnapshot | null = null;
 
 export type AutoRuntimeSnapshot = {
   active: boolean;
@@ -20,6 +35,7 @@ export type AutoRuntimeSnapshot = {
   orchestrationPhase?: "idle" | "running" | "paused" | "stopped" | "error";
   orchestrationTransitionCount?: number;
   orchestrationLastTransitionAt?: number;
+  toolSurface: ToolSurfaceSnapshot | null;
 };
 
 export function getAutoRuntimeSnapshot(): AutoRuntimeSnapshot {
@@ -32,9 +48,19 @@ export function getAutoRuntimeSnapshot(): AutoRuntimeSnapshot {
     orchestrationPhase: orchestrationStatus?.phase,
     orchestrationTransitionCount: orchestrationStatus?.transitionCount,
     orchestrationLastTransitionAt: orchestrationStatus?.lastTransitionAt,
+    toolSurface: autoSession.active || autoSession.paused ? currentToolSurfaceSnapshot : null,
   };
 }
 
+export function recordAutoToolSurfaceSnapshot(input: ToolSurfaceSnapshotInput): ToolSurfaceSnapshot {
+  currentToolSurfaceSnapshot = createToolSurfaceSnapshot(input);
+  return currentToolSurfaceSnapshot;
+}
+
+export function clearAutoToolSurfaceSnapshot(): void {
+  currentToolSurfaceSnapshot = null;
+}
+
 export function isAutoActive(): boolean {
   return autoSession.active;
 }

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

@@ -16,6 +16,7 @@ import type {
   ExtensionCommandContext,
 } from "@gsd/pi-coding-agent";
 import { deriveState } from "./state.js";
+import { findWorktreeSegment, isGsdWorktreePath } from "./worktree-root.js";
 import { loadFile, getManifestStatus } from "./files.js";
 import type { InterruptedSessionAssessment } from "./interrupted-session.js";
 import {
@@ -66,7 +67,13 @@ import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
 import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactive.js";
 import { snapshotSkills } from "./skill-discovery.js";
-import { isDbAvailable, getMilestone, getAllMilestones, insertMilestone, openDatabase, getDbStatus, updateMilestoneStatus } from "./gsd-db.js";
+import { isDbAvailable, getMilestone, getAllMilestones, insertMilestone, updateMilestoneStatus } from "./gsd-db.js";
+import {
+  getWorkflowDatabaseStatus,
+  openExistingWorkflowDatabase,
+  openWorkflowDatabase,
+  resolveProjectRootDbPath,
+} from "./db-workspace.js";
 import { isClosedStatus } from "./status-guards.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { extractVerdict } from "./verdict-parser.js";
@@ -90,9 +97,7 @@ import {
   rmSync,
 } from "node:fs";
 import { join } from "node:path";
-import { sep as pathSep } from "node:path";
 
-import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
 import { validateDirectory } from "./validate-directory.js";
 import {
   isCustomProvider,
@@ -150,10 +155,9 @@ export async function openProjectDbIfPresent(basePath: string): Promise<void> {
   const gsdDbPath = resolveProjectRootDbPath(basePath);
   if (!existsSync(gsdDbPath) || isDbAvailable()) return;
 
-  try {
-    openDatabase(gsdDbPath);
-  } catch (err) {
-    logWarning("engine", `gsd-db: failed to open existing database: ${err instanceof Error ? err.message : String(err)}`);
+  const result = openExistingWorkflowDatabase(basePath);
+  if (!result.ok && result.reason === "open-failed") {
+    logWarning("engine", `gsd-db: failed to open existing database: ${result.error?.message ?? "open failed"}`);
   }
 }
 
@@ -597,7 +601,7 @@ export function auditOrphanedMilestoneBranches(
               warnings.push(`Failed to remove worktree directory for ${milestoneId}: ${err2 instanceof Error ? err2.message : String(err2)}`);
             }
           } else {
-            warnings.push(`Orphaned worktree directory for ${milestoneId} is outside .gsd/worktrees/ — skipping removal for safety.`);
+            warnings.push(`Orphaned worktree directory for ${milestoneId} is outside the GSD worktrees containers — skipping removal for safety.`);
           }
         } else {
           pushAction({
@@ -713,7 +717,7 @@ export function auditOrphanedMilestoneBranches(
     if (!existsSync(wtDir)) continue;
     if (!isInsideWorktreesDir(basePath, wtDir)) {
       warnings.push(
-        `Orphaned worktree directory for ${m.id} is outside .gsd/worktrees/ — skipping removal for safety.`,
+        `Orphaned worktree directory for ${m.id} is outside the GSD worktrees containers — skipping removal for safety.`,
       );
       continue;
     }
@@ -1321,7 +1325,7 @@ export async function bootstrapAutoSession(
       (state.phase === "pre-planning" || state.phase === "complete") &&
       survivorIsolationMode !== "none" &&
       !detectWorktreeName(base) &&
-      !base.includes(`${pathSep}.gsd${pathSep}worktrees${pathSep}`)
+      !isGsdWorktreePath(base)
     ) {
       const milestoneBranch = `milestone/${survivorMilestoneId}`;
       const { nativeBranchExists } = await import("./native-git-bridge.js");
@@ -1606,16 +1610,10 @@ export async function bootstrapAutoSession(
     // live here is gone.
 
     const isUnderGsdWorktrees = (p: string): boolean => {
-      // Direct layout: /.gsd/worktrees/
-      const marker = `${pathSep}.gsd${pathSep}worktrees${pathSep}`;
-      if (p.includes(marker)) return true;
-      const worktreesSuffix = `${pathSep}.gsd${pathSep}worktrees`;
-      if (p.endsWith(worktreesSuffix)) return true;
-      // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/
-      const symlinkRe = new RegExp(
-        `\\${pathSep}\\.gsd\\${pathSep}projects\\${pathSep}[a-f0-9]+\\${pathSep}worktrees(?:\\${pathSep}|$)`,
-      );
-      return symlinkRe.test(p);
+      const normalized = p.replaceAll("\\", "/");
+      if (findWorktreeSegment(normalized) !== null) return true;
+      // The container directory itself (no trailing worktree name).
+      return normalized.endsWith("/.gsd/worktrees") || normalized.endsWith("/.gsd-worktrees");
     };
 
     if (
@@ -1673,21 +1671,14 @@ export async function bootstrapAutoSession(
 
     // ── DB lifecycle ──
     const gsdDbPath = resolveProjectRootDbPath(s.basePath);
-    const gsdDirPath = join(s.basePath, ".gsd");
-    if (existsSync(gsdDirPath) && !existsSync(gsdDbPath)) {
-      try {
-        const { openDatabase: openDb } = await import("./gsd-db.js");
-        openDb(gsdDbPath);
-      } catch (err) {
-        logError("engine", `failed to initialize project database: ${(err as Error).message}`);
-      }
+    const initialDbOpen = openWorkflowDatabase(s.basePath);
+    if (!initialDbOpen.ok && initialDbOpen.reason === "open-failed") {
+      logError("engine", `failed to initialize project database: ${initialDbOpen.error?.message ?? "open failed"}`);
     }
     if (_shouldAbortBootstrapForUnavailableDbForTest(gsdDbPath, isDbAvailable())) {
-      try {
-        const { openDatabase: openDb } = await import("./gsd-db.js");
-        openDb(gsdDbPath);
-      } catch (err) {
-        logError("engine", `failed to open existing database: ${(err as Error).message}`);
+      const retryDbOpen = openWorkflowDatabase(s.basePath);
+      if (!retryDbOpen.ok && retryDbOpen.reason === "open-failed") {
+        logError("engine", `failed to open existing database: ${retryDbOpen.error?.message ?? "open failed"}`);
       }
     }
 
@@ -1697,7 +1688,7 @@ export async function bootstrapAutoSession(
     // call returns "db_unavailable", triggering artifact-retry which
     // re-dispatches the same task — producing an infinite loop (#2419).
     if (existsSync(gsdDbPath) && !isDbAvailable()) {
-      const dbStatus = getDbStatus();
+      const dbStatus = getWorkflowDatabaseStatus();
       const phaseHint = dbStatus.lastPhase === "open"
         ? "The database file could not be opened"
         : dbStatus.lastPhase === "initSchema"

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

@@ -287,10 +287,23 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
   }, 15000);
 
   // ── 3. Hard timeout ──
-  s.unitTimeoutHandle = setTimeout(async () => {
+  const hardTimeoutBody = async () => {
     try {
       s.unitTimeoutHandle = null;
       if (!s.active) return;
+      // User-interactive tools (ask_user_questions, secure_env_collect) block
+      // waiting for human input by design. Unlike the idle watchdog (above),
+      // the hard timeout had no interactive exemption, so a long human
+      // deliberation crossing the hard cap would still closeout + recover
+      // (triggerTurn) and abort the turn hosting the elicitation, reintroducing
+      // the self-cancel loop on slow answers (#2676). Re-arm instead of firing
+      // while a human is being asked, mirroring the idle watchdog's
+      // refresh-and-return. Conditional on hasInteractiveToolInFlight(), so a
+      // genuinely hung non-interactive unit still hits the hard cap.
+      if (getInFlightToolCount() > 0 && hasInteractiveToolInFlight()) {
+        s.unitTimeoutHandle = setTimeout(hardTimeoutBody, hardTimeoutMs);
+        return;
+      }
       const expectedCurrentUnit = s.currentUnit
         ? { type: s.currentUnit.type, id: s.currentUnit.id, startedAt: s.currentUnit.startedAt }
         : null;
@@ -323,7 +336,8 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
         logWarning("timer", `notification failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
-  }, hardTimeoutMs);
+  };
+  s.unitTimeoutHandle = setTimeout(hardTimeoutBody, hardTimeoutMs);
 
   // ── 4. Context-pressure continue-here monitor ──
   if (s.continueHereHandle) {

package/src/resources/extensions/gsd/auto-tool-tracking.ts

@@ -19,6 +19,17 @@ const inFlightTools = new Map<string, InFlightTool>();
  */
 const INTERACTIVE_TOOLS = new Set(["ask_user_questions", "secure_env_collect"]);
 
+/**
+ * Mode-agnostic refcount of in-flight interactive elicitations that are an
+ * active human boundary (the model ASKED via ask_user_questions). Unlike the
+ * `inFlightTools` Map, this is NOT gated by auto-session.active, so it is true
+ * in FOREGROUND (where s.active is false). Kept SEPARATE from inFlightTools so
+ * getInFlightToolCount()/getOldestInFlightToolAgeMs()/hasInteractiveToolInFlight()
+ * and the auto-watchdog accounting are byte-for-byte unchanged. A refcount (not
+ * a boolean) handles nested/back-to-back elicitations in a single turn.
+ */
+let interactiveElicitationDepth = 0;
+
 /**
  * Mark a tool execution as in-flight.
  * Records start time and tool name so the idle watchdog can detect tools
@@ -36,6 +47,29 @@ export function markToolEnd(toolCallId: string): void {
   inFlightTools.delete(toolCallId);
 }
 
+/**
+ * Mark an interactive elicitation (the model asking via ask_user_questions) as
+ * in flight. Ungated by auto-session.active so it is observable in foreground.
+ */
+export function markInteractiveElicitationStart(): void {
+  interactiveElicitationDepth++;
+}
+
+/**
+ * Mark an interactive elicitation as completed. Idempotent below zero.
+ */
+export function markInteractiveElicitationEnd(): void {
+  if (interactiveElicitationDepth > 0) interactiveElicitationDepth--;
+}
+
+/**
+ * Returns true if any interactive elicitation is currently the active human
+ * boundary. True in ALL modes (foreground and auto) while one is in flight.
+ */
+export function isInteractiveElicitationInFlight(): boolean {
+  return interactiveElicitationDepth > 0;
+}
+
 /**
  * Returns the age (ms) of the oldest currently in-flight tool, or 0 if none.
  */
@@ -84,6 +118,7 @@ export function hasInteractiveToolInFlight(): boolean {
  */
 export function clearInFlightTools(): void {
   inFlightTools.clear();
+  interactiveElicitationDepth = 0;
 }
 
 // ─── Tool invocation error classification (#2883) ────────────────────────

package/src/resources/extensions/gsd/auto-unit-tool-scope.ts

@@ -3,32 +3,18 @@ import {
   AUTO_UNIT_SCOPED_TOOLS,
   getForbiddenGsdToolReason,
 } from "./unit-tool-contracts.js";
+import {
+  WORKFLOW_TOOL_ALIAS_PAIRS,
+  canonicalWorkflowSurfaceToolName,
+  isWorkflowSurfaceAliasTool,
+  stripMcpToolPrefix,
+} from "./workflow-tool-surface.js";
 
 export {
   AUTO_UNIT_SCOPED_TOOLS,
   RUN_UAT_BROWSER_TOOL_NAMES,
 } from "./unit-tool-contracts.js";
 
-const WORKFLOW_TOOL_ALIASES: Record<string, string> = {
-  gsd_save_decision: "gsd_decision_save",
-  gsd_update_requirement: "gsd_requirement_update",
-  gsd_save_requirement: "gsd_requirement_save",
-  gsd_save_summary: "gsd_summary_save",
-  gsd_generate_milestone_id: "gsd_milestone_generate_id",
-  gsd_milestone_plan: "gsd_plan_milestone",
-  gsd_slice_plan: "gsd_plan_slice",
-  gsd_task_plan: "gsd_plan_task",
-  gsd_slice_replan: "gsd_replan_slice",
-  gsd_complete_slice: "gsd_slice_complete",
-  gsd_milestone_complete: "gsd_complete_milestone",
-  gsd_milestone_validate: "gsd_validate_milestone",
-  gsd_roadmap_reassess: "gsd_reassess_roadmap",
-  gsd_complete_task: "gsd_task_complete",
-  gsd_reopen_task: "gsd_task_reopen",
-  gsd_reopen_slice: "gsd_slice_reopen",
-  gsd_reopen_milestone: "gsd_milestone_reopen",
-};
-
 const EXECUTE_TASK_UNIT_TYPES = new Set([
   "execute-task",
   "execute-task-simple",
@@ -55,7 +41,7 @@ const EXTRA_SCOPED_GSD_LIFECYCLE_TOOLS = [
 const SCOPED_GSD_LIFECYCLE_TOOLS = new Set(
   [
     ...Object.values(AUTO_UNIT_SCOPED_TOOLS).flat(),
-    ...Object.values(WORKFLOW_TOOL_ALIASES),
+    ...WORKFLOW_TOOL_ALIAS_PAIRS.map(({ canonical }) => canonical),
     ...EXTRA_SCOPED_GSD_LIFECYCLE_TOOLS,
   ]
     .filter((tool) => tool.startsWith("gsd_"))
@@ -72,19 +58,12 @@ type AutoUnitToolScopeResult = {
   displayReason?: string;
 };
 
-function stripMcpToolPrefix(toolName: string): string {
-  if (!toolName.startsWith("mcp__")) return toolName;
-  const toolSeparator = toolName.indexOf("__", "mcp__".length);
-  return toolSeparator >= 0 ? toolName.slice(toolSeparator + 2) : toolName;
-}
-
 export function canonicalWorkflowToolName(toolName: string): string {
-  const base = stripMcpToolPrefix(toolName);
-  return WORKFLOW_TOOL_ALIASES[base] ?? base;
+  return canonicalWorkflowSurfaceToolName(toolName);
 }
 
 export function isWorkflowAliasTool(toolName: string): boolean {
-  return Object.prototype.hasOwnProperty.call(WORKFLOW_TOOL_ALIASES, stripMcpToolPrefix(toolName));
+  return isWorkflowSurfaceAliasTool(toolName);
 }
 
 function hardBlockReason(unitType: string, what: string): string {

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

@@ -16,13 +16,13 @@
 import type { ExtensionContext, ExtensionAPI } from "@gsd/pi-coding-agent";
 import { existsSync, mkdirSync, readFileSync, readdirSync, writeFileSync } from "node:fs";
 import { gsdProjectionRoot, resolveSliceFile, resolveSlicePath, resolveMilestoneFile } from "./paths.js";
+import { resolveMilestoneValidationVerdict } from "./milestone-validation-verdict.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
 import { parseUnitId } from "./unit-id.js";
 import { isDbAvailable, getTask, getSliceTasks, getMilestoneSlices } from "./gsd-db.js";
 import type { TaskRow } from "./db-task-slice-rows.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import type { GSDPreferences } from "./preferences-types.js";
-import { extractVerdict } from "./verdict-parser.js";
 import { isClosedStatus } from "./status-guards.js";
 import { loadFile } from "./files.js";
 import { parseRoadmap } from "./parsers-legacy.js";
@@ -269,28 +269,27 @@ async function runValidateMilestonePostCheck(
     mid,
     `${mid}-VALIDATION.md`,
   );
-  if (!validationFile) {
+  const validationContent = await loadFile(validationFile);
+  if (validationContent !== null && validationContent.trim() === "") {
     if (await reassessmentInvalidatedValidation()) {
       clearValidationRetry();
       return "continue";
     }
     return setToolFailureRetry(
-      "You must call gsd_validate_milestone to persist the validation results. No VALIDATION.md was created.",
+      "You must call gsd_validate_milestone to persist the validation results. VALIDATION.md exists but is empty.",
     );
   }
 
-  const validationContent = await loadFile(validationFile);
-  if (!validationContent) {
+  const verdict = await resolveMilestoneValidationVerdict(s.basePath, mid);
+  if (!verdict) {
     if (await reassessmentInvalidatedValidation()) {
       clearValidationRetry();
       return "continue";
     }
     return setToolFailureRetry(
-      "You must call gsd_validate_milestone to persist the validation results. VALIDATION.md exists but is empty.",
+      "You must call gsd_validate_milestone to persist the validation results. No VALIDATION.md was created.",
     );
   }
-
-  const verdict = extractVerdict(validationContent);
   if (verdict === "needs-attention") {
     ctx.ui.notify(
       `Milestone ${mid} validation returned verdict=needs-attention. Pausing for human review.`,

package/src/resources/extensions/gsd/auto-worktree-repair.ts

@@ -5,6 +5,7 @@ import { existsSync, lstatSync, readdirSync, type Stats } from "node:fs";
 import { join } from "node:path";
 
 import { worktreePath } from "./worktree-manager.js";
+import { worktreesDirs } from "./worktree-placement.js";
 import { normalizeWorktreePathForCompare } from "./worktree-root.js";
 import type { WorktreeSafetyResult } from "./worktree-safety.js";
 
@@ -39,6 +40,16 @@ export function expectedAutoWorktreePath(
   return worktreePath(projectRoot, id);
 }
 
+/** Every path the milestone worktree may legitimately live at (canonical + legacy). */
+function candidateAutoWorktreePaths(
+  projectRoot: string,
+  milestoneId: string | null | undefined,
+): string[] {
+  const id = milestoneId?.trim();
+  if (!id || !isValidMilestoneId(id)) return [];
+  return worktreesDirs(projectRoot).map((dir) => join(dir, id));
+}
+
 export function resolvePausedAutoWorktreePath(input: {
   basePath: string;
   originalBasePath?: string | null;
@@ -82,8 +93,8 @@ export function assessAutoWorktreeRepairTarget(input: {
   if (!expectedPath) {
     return { ok: false, reason: "missing expected worktree path" };
   }
-  const computedExpectedPath = expectedAutoWorktreePath(input.projectRoot, input.milestoneId);
-  if (!computedExpectedPath || !samePath(expectedPath, computedExpectedPath)) {
+  const candidatePaths = candidateAutoWorktreePaths(input.projectRoot, input.milestoneId);
+  if (candidatePaths.length === 0 || !candidatePaths.some((candidate) => samePath(expectedPath, candidate))) {
     return { ok: false, reason: "expected worktree path does not match milestone" };
   }
   if (!samePath(input.activeRoot, input.projectRoot) && !samePath(input.activeRoot, expectedPath)) {