gsd-pi 2.82.0-dev.2841a1e44 → 2.82.0-dev.3a3c6509d

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

@@ -23,7 +23,7 @@ import { rebuildState } from "./doctor.js";
 import { parseUnitId } from "./unit-id.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
 import { runTurnGitAction, } from "./git-service.js";
-import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceholder, diagnoseExpectedArtifact, } from "./auto-recovery.js";
+import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceholder, diagnoseExpectedArtifact, diagnoseWorktreeIntegrityFailure, } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
 import { WorktreeStateProjection } from "./worktree-state-projection.js";
 import { createWorkspace, scopeMilestone } from "./workspace.js";
@@ -125,7 +125,7 @@ async function buildTaskCommitContextForUnit(basePath, unitId) {
         sliceId: sid,
         sliceTitle: stripKnownIdPrefix(slice?.title, sid),
         oneLiner: summary?.oneLiner || task?.one_liner || undefined,
-        keyFiles: summary?.frontmatter.key_files?.filter(f => !f.includes("{{")) ??
+        keyFiles: summary?.frontmatter.key_files?.filter(f => !f.includes("{{") && f.trim() !== "(none)") ??
             task?.key_files ??
             undefined,
         issueNumber: ghIssueNumber,
@@ -303,6 +303,19 @@ export function buildStepCompleteMessage(nextState) {
     return `Step complete. Next: ${next.label}\n`
         + `Run /clear, then /gsd to continue (or /gsd auto to run continuously).`;
 }
+/**
+ * Decide whether step mode should stop at the step wizard after a unit finishes.
+ *
+ * @param currentUnitType The just-finished unit type, such as "execute-task" or
+ *   "complete-milestone"; may be null/undefined when no current unit is known.
+ * @param phaseAfterUnit The freshly derived next phase, such as "executing" or
+ *   "complete"; may be null/undefined if state derivation failed.
+ * @returns true to show the step wizard; false to keep the loop running so
+ *   terminal milestone completion can reach the merge/finalization path.
+ */
+export function shouldReturnStepWizardAfterUnit(currentUnitType, phaseAfterUnit) {
+    return currentUnitType !== "complete-milestone" && phaseAfterUnit !== "complete";
+}
 export const USER_DRIVEN_DEEP_UNITS = new Set([
     "discuss-project",
     "discuss-requirements",
@@ -318,6 +331,10 @@ function artifactValidationKind(unitType) {
     return null;
 }
 function describeArtifactVerificationFailure(unitType, unitId, basePath) {
+    const worktreeFailure = diagnoseWorktreeIntegrityFailure(basePath);
+    if (worktreeFailure) {
+        return `${worktreeFailure} Unit: ${unitType} ${unitId}.`;
+    }
     const artifactPath = resolveExpectedArtifactPath(unitType, unitId, basePath);
     if (!artifactPath) {
         return `Artifact verification failed: ${unitType} "${unitId}" has no resolvable artifact path.`;
@@ -362,7 +379,14 @@ export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
         return null;
     }
 }
-async function runCloseoutGitAction(pctx, unit) {
+/**
+ * Execute the turn-level git action (commit, snapshot, or status-only).
+ *
+ * @param opts.softFailure - Defaults to false. When true, retry git failures,
+ * warn, and continue without pausing auto-mode; use for best-effort deferred
+ * closeout work where a git failure should not block the run.
+ */
+async function runCloseoutGitAction(pctx, unit, opts) {
     const { s, ctx, pi, pauseAuto } = pctx;
     const prefs = loadEffectiveGSDPreferences()?.preferences;
     const uokFlags = resolveUokFlags(prefs);
@@ -390,13 +414,24 @@ async function runCloseoutGitAction(pctx, unit) {
             });
         }
         else {
-            const gitResult = runTurnGitAction({
+            const maxAttempts = opts?.softFailure ? 3 : 1;
+            let gitResult = runTurnGitAction({
                 basePath: s.basePath,
                 action: turnAction,
                 unitType: unit.type,
                 unitId: unit.id,
                 taskContext,
             });
+            for (let attempt = 1; gitResult.status === "failed" && attempt < maxAttempts; attempt++) {
+                await new Promise((resolve) => setTimeout(resolve, 250 * attempt));
+                gitResult = runTurnGitAction({
+                    basePath: s.basePath,
+                    action: turnAction,
+                    unitType: unit.type,
+                    unitId: unit.id,
+                    taskContext,
+                });
+            }
             if (uokFlags.gitops) {
                 writeTurnGitTransaction({
                     basePath: s.basePath,
@@ -444,12 +479,15 @@ async function runCloseoutGitAction(pctx, unit) {
                     });
                 }
                 const failureMsg = `Git ${turnAction} failed: ${(gitResult.error ?? "unknown error").split("\n")[0]}`;
-                ctx.ui.notify(failureMsg, "error");
+                ctx.ui.notify(failureMsg, opts?.softFailure ? "warning" : "error");
                 debugLog("postUnit", {
-                    phase: "git-action-failed-blocking",
+                    phase: opts?.softFailure ? "git-action-failed-soft" : "git-action-failed-blocking",
                     action: turnAction,
                     error: gitResult.error ?? "unknown error",
                 });
+                if (opts?.softFailure) {
+                    return "continue";
+                }
                 await pauseAuto(ctx, pi);
                 return "dispatched";
             }
@@ -467,7 +505,10 @@ async function runCloseoutGitAction(pctx, unit) {
         s.lastGitActionFailure = message;
         s.lastGitActionStatus = "failed";
         debugLog("postUnit", { phase: "git-action", error: message, action: turnAction });
-        ctx.ui.notify(`Git ${turnAction} failed: ${message.split("\n")[0]}`, uokFlags.gitops ? "error" : "warning");
+        ctx.ui.notify(`Git ${turnAction} failed: ${message.split("\n")[0]}`, opts?.softFailure ? "warning" : "error");
+        if (opts?.softFailure) {
+            return "continue";
+        }
         if (uokFlags.gitops) {
             await pauseAuto(ctx, pi);
             return "dispatched";
@@ -958,9 +999,25 @@ export async function postUnitPreVerification(pctx, opts) {
                 s.verificationRetryCount.delete(retryKey);
                 s.verificationRetryFailureHashes.delete(retryKey);
                 writeBlockerPlaceholder(s.currentUnit.type, s.currentUnit.id, s.basePath, reason);
-                ctx.ui.notify(`${s.currentUnit.type} ${s.currentUnit.id} — deterministic policy rejection, wrote blocker placeholder (no retries) (#4973)`, "warning");
+                ctx.ui.notify(`${s.currentUnit.type} ${s.currentUnit.id} — deterministic policy rejection, wrote blocker placeholder (no retries)`, "warning");
                 // Fall through to "continue" — do NOT enter the retry or db-unavailable paths.
             }
+            else if (!triggerArtifactVerified && diagnoseWorktreeIntegrityFailure(s.basePath)) {
+                const retryKey = `${s.currentUnit.type}:${s.currentUnit.id}`;
+                const worktreeFailure = diagnoseWorktreeIntegrityFailure(s.basePath);
+                s.pendingVerificationRetry = null;
+                s.verificationRetryCount.delete(retryKey);
+                s.verificationRetryFailureHashes.delete(retryKey);
+                debugLog("postUnit", {
+                    phase: "worktree-integrity-failure",
+                    unitType: s.currentUnit.type,
+                    unitId: s.currentUnit.id,
+                    basePath: s.basePath,
+                });
+                ctx.ui.notify(`${worktreeFailure} Retry ${s.currentUnit.id} after repair.`, "error");
+                await pauseAuto(ctx, pi);
+                return "dispatched";
+            }
             else if (!triggerArtifactVerified && !isDbAvailable()) {
                 debugLog("postUnit", { phase: "artifact-verify-skip-db-unavailable", unitType: s.currentUnit.type, unitId: s.currentUnit.id });
                 const dbSkipDiag = diagnoseExpectedArtifact(s.currentUnit.type, s.currentUnit.id, s.basePath);
@@ -1032,7 +1089,7 @@ export async function postUnitPostVerification(pctx) {
     const { s, ctx, pi, buildSnapshotOpts, lockBase, stopAuto, pauseAuto, updateProgressWidget } = pctx;
     if (s.currentUnit) {
         if (shouldDeferCloseoutGitAction(s.currentUnit.type)) {
-            const gitActionResult = await runCloseoutGitAction(pctx, s.currentUnit);
+            const gitActionResult = await runCloseoutGitAction(pctx, s.currentUnit, { softFailure: true });
             if (gitActionResult === "dispatched") {
                 return "stopped";
             }
@@ -1404,15 +1461,19 @@ export async function postUnitPostVerification(pctx) {
     // Without this notify(), /gsd in step mode finishes a unit and silently
     // exits the loop, leaving the user with no hint to /clear and /gsd again.
     if (s.stepMode) {
+        let phaseAfterUnit = null;
         try {
             const nextState = await deriveState(s.canonicalProjectRoot);
+            phaseAfterUnit = nextState.phase;
             ctx.ui.notify(buildStepCompleteMessage(nextState), "info");
         }
         catch (e) {
             debugLog("postUnit", { phase: "step-wizard-notify", error: String(e) });
             ctx.ui.notify(STEP_COMPLETE_FALLBACK_MESSAGE, "info");
         }
-        return "step-wizard";
+        return shouldReturnStepWizardAfterUnit(s.currentUnit?.type, phaseAfterUnit)
+            ? "step-wizard"
+            : "continue";
     }
     return "continue";
 }

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

@@ -14,7 +14,8 @@ import { clearParseCache } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from "./parsers-legacy.js";
 import { isDbAvailable, getTask, getSlice, getSliceTasks, getPendingGates, updateTaskStatus, updateSliceStatus, insertSlice, getMilestone, refreshOpenDatabaseFromDisk, getCompletedMilestoneTaskFileHints, getMilestoneCommitAttributionShas, recordMilestoneCommitAttribution } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
-import { logWarning } from "./workflow-logger.js";
+import { getErrorMessage } from "./error-utils.js";
+import { logWarning, logError } from "./workflow-logger.js";
 import { readIntegrationBranch } from "./git-service.js";
 import { isClosedStatus } from "./status-guards.js";
 import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildSliceFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
@@ -25,9 +26,33 @@ import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-a
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { validateArtifact } from "./schemas/validate.js";
 import { getProjectResearchStatus } from "./project-research-policy.js";
+import { isGsdWorktreePath } from "./worktree-root.js";
 // Re-export so existing consumers of auto-recovery.ts keep working.
 export { resolveExpectedArtifactPath, diagnoseExpectedArtifact };
 export { classifyMilestoneSummaryContent, } from "./milestone-summary-classifier.js";
+// ─── 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.`;
+    }
+}
 export function refreshRecoveryDbForArtifact(unitType, unitId) {
     if (unitType !== "plan-slice" && unitType !== "execute-task")
         return { ok: true };
@@ -137,9 +162,16 @@ export function hasImplementationArtifacts(basePath, milestoneId) {
         // Strategy: check `git diff --name-only` against the merge-base with the
         // main branch. This captures ALL files changed during the milestone's
         // lifetime while running on a milestone branch.
-        const integrationBranch = milestoneId
-            ? readIntegrationBranch(basePath, milestoneId) ?? detectMainBranch(basePath)
-            : detectMainBranch(basePath);
+        const recordedIntegrationBranch = milestoneId
+            ? readIntegrationBranch(basePath, milestoneId)
+            : null;
+        let integrationBranch;
+        if (recordedIntegrationBranch?.startsWith("milestone/")) {
+            integrationBranch = detectMainBranch(basePath);
+        }
+        else {
+            integrationBranch = recordedIntegrationBranch ?? detectMainBranch(basePath);
+        }
         const currentBranch = getCurrentBranch(basePath);
         const branchDiff = getChangedFilesSinceBranch(basePath, integrationBranch);
         if (!branchDiff.ok)
@@ -471,29 +503,49 @@ function commitMatchesMilestone(basePath, message, milestoneId, files) {
     // rather than Mxx/Sxx/Tyy. Bind those commits back to the milestone when
     // either the commit touched this milestone's artifacts, or — for projects
     // where .gsd/ is gitignored/external (#5033) — the message explicitly
-    // names the milestone or local GSD state proves the task belongs here.
+    // names the milestone, local GSD state proves the task belongs here, or the
+    // commit is implementation-bearing evidence itself (#5100).
     if (/^GSD-Task:\s*S[^/\s]+\/T\S+/m.test(message)) {
         if (files.some((file) => isMilestoneArtifactPath(file, milestoneId)))
             return true;
         if (commitMessageMentionsMilestone(message, milestoneId))
             return true;
-        if (commitTaskTrailerBelongsToMilestone(basePath, message, milestoneId))
+        const taskTrailerOwnership = getTaskOwnershipStatus(basePath, message, milestoneId);
+        if (taskTrailerOwnership === true)
+            return true;
+        if (taskTrailerOwnership === false)
+            return false;
+        // taskTrailerOwnership === null: unknown ownership. Apply fallback only
+        // in this case to avoid cross-milestone attribution.
+        if (MILESTONE_ID_RE.test(milestoneId) && classifyImplementationFiles(files) === "present")
             return true;
     }
     return false;
 }
-function commitTaskTrailerBelongsToMilestone(basePath, message, milestoneId) {
+/**
+ * Tri-state task ownership probe.
+ * true => DB or local files confirm this milestone owns the task.
+ * false => DB is available and this milestone is registered, but task is absent.
+ * null => ownership unknown (milestone not in DB yet, or no DB + no local files).
+ */
+function getTaskOwnershipStatus(basePath, message, milestoneId) {
     const match = message.match(/^GSD-Task:\s*(S[^/\s]+)\/(T[^\s]+)/m);
     if (!match)
-        return false;
+        return null;
     const [, sliceId, taskId] = match;
-    if (getTask(milestoneId, sliceId, taskId))
-        return true;
+    if (isDbAvailable()) {
+        if (!getMilestone(milestoneId))
+            return null;
+        return getTask(milestoneId, sliceId, taskId) ? true : false;
+    }
+    // DB unavailable: fallback to local task-file presence.
     const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId);
-    if (!tasksDir)
-        return false;
-    return existsSync(join(tasksDir, `${taskId}-PLAN.md`))
-        || existsSync(join(tasksDir, `${taskId}-SUMMARY.md`));
+    if (tasksDir
+        && (existsSync(join(tasksDir, `${taskId}-PLAN.md`))
+            || existsSync(join(tasksDir, `${taskId}-SUMMARY.md`)))) {
+        return true;
+    }
+    return null;
 }
 function commitMessageMentionsMilestone(message, milestoneId) {
     if (!MILESTONE_ID_RE.test(milestoneId))
@@ -673,6 +725,11 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
         return false;
     }
     if (!existsSync(absPath)) {
+        const worktreeFailure = diagnoseWorktreeIntegrityFailure(base);
+        if (worktreeFailure) {
+            logError("recovery", `${worktreeFailure} Unit: ${unitType} ${unitId}.`);
+            return false;
+        }
         logWarning("recovery", `verify-fail ${unitType} ${unitId}: existsSync false for ${absPath}`);
         return false;
     }

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

@@ -21,10 +21,10 @@ import { invalidateAllCaches } from "./cache.js";
 import { writeLock, clearLock } from "./crash-recovery.js";
 import { acquireSessionLock, releaseSessionLock, updateSessionLock, } from "./session-lock.js";
 import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
-import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeCheckoutBranch, nativeBranchList, nativeBranchListMerged, nativeBranchDelete, nativeWorktreeRemove, nativeCommitCountBetween, } from "./native-git-bridge.js";
+import { nativeIsRepo, nativeInit, nativeAddAll, nativeCommit, nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchList, nativeBranchExists, nativeBranchListMerged, nativeBranchDelete, nativeWorktreeRemove, nativeCommitCountBetween, } from "./native-git-bridge.js";
 import { GitServiceImpl } from "./git-service.js";
 import { captureIntegrationBranch, detectWorktreeName, setActiveMilestoneId, } from "./worktree.js";
-import { getAutoWorktreePath } from "./auto-worktree.js";
+import { getAutoWorktreePath, checkoutBranchWithStashGuard } from "./auto-worktree.js";
 import { readResourceVersion, cleanStaleRuntimeUnits } from "./auto-worktree.js";
 import { worktreePath as getWorktreeDir, isInsideWorktreesDir } from "./worktree-manager.js";
 import { emitWorktreeOrphaned } from "./worktree-telemetry.js";
@@ -33,7 +33,7 @@ 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, openDatabase, getDbStatus } from "./gsd-db.js";
+import { isDbAvailable, getMilestone, getAllMilestones, openDatabase, getDbStatus } from "./gsd-db.js";
 import { isClosedStatus } from "./status-guards.js";
 import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { auditOrphanedPreflightStashes } from "./orphan-stash-audit.js";
@@ -88,9 +88,11 @@ export function decideSurvivorAction(hasSurvivorBranch, phase) {
         return "finalize";
     return "none";
 }
-export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
+export function auditOrphanedMilestoneBranches(basePath, isolationMode, gitDeps = {}) {
     const recovered = [];
     const warnings = [];
+    const branchList = gitDeps.branchList ?? nativeBranchList;
+    const branchExists = gitDeps.branchExists ?? nativeBranchExists;
     // Skip in none mode — no milestone branches are created
     if (isolationMode === "none")
         return { recovered, warnings };
@@ -98,15 +100,16 @@ export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
     if (!isDbAvailable())
         return { recovered, warnings };
     let milestoneBranches;
+    let milestoneBranchListAvailable = true;
     try {
-        milestoneBranches = nativeBranchList(basePath, "milestone/*");
+        milestoneBranches = branchList(basePath, "milestone/*");
     }
     catch {
-        // git branch list failed — skip audit
-        return { recovered, warnings };
+        milestoneBranchListAvailable = false;
+        // git branch list failed — fall through with an empty branch set so the
+        // branch-less orphan pass can still run after per-milestone verification.
+        milestoneBranches = [];
     }
-    if (milestoneBranches.length === 0)
-        return { recovered, warnings };
     // Detect main branch for merge-check
     let mainBranch;
     try {
@@ -236,6 +239,71 @@ export function auditOrphanedMilestoneBranches(basePath, isolationMode) {
             }
         }
     }
+    // Second pass (#5879): catch worktree directories stranded by a previous
+    // audit that deleted the milestone/* branch but failed to remove the
+    // directory (or the dir was orphaned by a separate path entirely, e.g.
+    // postflight-stash-restore-failed during closeout). The branch-keyed loop
+    // above is invisible to these cases — `nativeBranchList` returns nothing
+    // for the milestone, so the dir-cleanup block at line ~310 is never
+    // reached.
+    //
+    // Keyed on milestones whose DB status is `complete`. We do not iterate
+    // over arbitrary directories under .gsd/worktrees/ to avoid touching
+    // dirs that belong to an in-progress milestone whose branch was deleted
+    // separately — those are handled by the in-progress orphan path above
+    // when the branch is present, and by `/gsd doctor` when it is not.
+    const seenMilestoneIds = new Set(milestoneBranches.map((branch) => branch.replace(/^milestone\//, "")));
+    let completedMilestones = [];
+    try {
+        completedMilestones = getAllMilestones();
+    }
+    catch {
+        // DB read failure — skip the second pass; the first pass is still useful.
+        completedMilestones = [];
+    }
+    for (const m of completedMilestones) {
+        if (m.status !== "complete")
+            continue;
+        if (seenMilestoneIds.has(m.id))
+            continue; // already processed in the branch loop
+        if (!milestoneBranchListAvailable) {
+            try {
+                if (branchExists(basePath, `milestone/${m.id}`))
+                    continue;
+            }
+            catch (err) {
+                warnings.push(`Could not verify whether milestone/${m.id} still exists; skipping branch-less worktree cleanup for safety: ${err instanceof Error ? err.message : String(err)}`);
+                continue;
+            }
+        }
+        const wtDir = getWorktreeDir(basePath, m.id);
+        if (!existsSync(wtDir))
+            continue;
+        if (!isInsideWorktreesDir(basePath, wtDir)) {
+            warnings.push(`Orphaned worktree directory for ${m.id} is outside .gsd/worktrees/ — skipping removal for safety.`);
+            continue;
+        }
+        // Try `git worktree remove` first in case the dir is still registered
+        // (defensive — usually it is not when we reach this branch-less pass).
+        try {
+            nativeWorktreeRemove(basePath, wtDir, true);
+        }
+        catch (e) {
+            logWarning("engine", `worktree remove failed (expected for branch-less orphans): ${e instanceof Error ? e.message : String(e)}`);
+        }
+        if (existsSync(wtDir)) {
+            try {
+                rmSync(wtDir, { recursive: true, force: true });
+                recovered.push(`Removed orphaned worktree directory for ${m.id} (branch already deleted).`);
+            }
+            catch (err) {
+                warnings.push(`Failed to remove orphaned worktree directory for ${m.id}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        else {
+            recovered.push(`Removed orphaned worktree directory for ${m.id} (branch already deleted).`);
+        }
+    }
     return { recovered, warnings };
 }
 /**
@@ -368,7 +436,7 @@ export function _mergeOrphanCompletedMilestone(lifecycle, orphanId, ui) {
     return { merged: false, error: err };
 }
 export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, deps, interrupted) {
-    const { shouldUseWorktreeIsolation, registerSigtermHandler, lockBase, buildLifecycle, } = deps;
+    const { shouldUseWorktreeIsolation, registerSigtermHandler, registerAutoWorkerForSession, lockBase, buildLifecycle, } = deps;
     const dirCheck = validateDirectory(base);
     if (dirCheck.severity === "blocked") {
         ctx.ui.notify(dirCheck.reason, "error");
@@ -523,6 +591,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // consult DB status and avoid clearing runtime units for milestones that
         // only have a failure-path SUMMARY on disk (#4663).
         await openProjectDbIfPresent(base);
+        registerAutoWorkerForSession(base);
         // Clean stale runtime unit files for completed milestones (#887).
         // DB-authoritative: when DB is available, require DB status to be closed
         // before clearing runtime units. A SUMMARY file alone is no longer
@@ -606,12 +675,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // worktree cleanup) was never run — the survivor branch must be merged.
         // Applies to both worktree and branch isolation modes.
         let hasSurvivorBranch = false;
-        if (state.activeMilestone &&
+        let survivorMilestoneId = state.activeMilestone?.id ?? null;
+        if (!survivorMilestoneId && state.phase === "complete") {
+            survivorMilestoneId = findUnmergedCompletedMilestone(base, getIsolationMode(base));
+        }
+        if (survivorMilestoneId &&
             (state.phase === "pre-planning" || state.phase === "complete") &&
             getIsolationMode(base) !== "none" &&
             !detectWorktreeName(base) &&
             !base.includes(`${pathSep}.gsd${pathSep}worktrees${pathSep}`)) {
-            const milestoneBranch = `milestone/${state.activeMilestone.id}`;
+            const milestoneBranch = `milestone/${survivorMilestoneId}`;
             const { nativeBranchExists } = await import("./native-git-bridge.js");
             hasSurvivorBranch = nativeBranchExists(base, milestoneBranch);
             if (hasSurvivorBranch) {
@@ -645,7 +718,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         // Re-evaluate via the helper — the discuss branch above may have cleared
         // hasSurvivorBranch after a successful promotion.
         if (decideSurvivorAction(hasSurvivorBranch, state.phase) === "finalize") {
-            const mid = state.activeMilestone.id;
+            const mid = survivorMilestoneId;
             // Commit 68ef58a3c made `_mergeBranchMode` throw on wrong-branch
             // instead of returning false silently. Wrap the call so the throw is
             // converted into an error notify + clean bootstrap abort, not an
@@ -828,7 +901,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 const integrationBranch = nativeDetectMainBranch(base);
                 const branchToCheckout = resolveIsolationNoneBranchCheckout(currentBranch, integrationBranch, isolationMode, isRepo);
                 if (branchToCheckout) {
-                    nativeCheckoutBranch(base, branchToCheckout);
+                    checkoutBranchWithStashGuard(base, branchToCheckout, "isolation-none-recovery");
                     logWarning("bootstrap", `Returned to "${branchToCheckout}" — HEAD was on stale milestone branch "${currentBranch}" (isolation: none does not use milestone branches).`);
                 }
             }

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

@@ -65,12 +65,25 @@ async function runValidateMilestonePostCheck(vctx, pauseAuto) {
     const { milestone: mid } = parseUnitId(s.currentUnit.id);
     if (!mid)
         return "continue";
+    const setToolFailureRetry = (message) => {
+        const retryKey = verificationRetryKey(s.currentUnit.type, s.currentUnit.id);
+        const attempt = (s.verificationRetryCount.get(retryKey) ?? 0) + 1;
+        s.verificationRetryCount.set(retryKey, attempt);
+        s.pendingVerificationRetry = {
+            unitId: s.currentUnit.id,
+            failureContext: message,
+            attempt,
+        };
+        return "retry";
+    };
     const validationFile = resolveMilestoneFile(s.basePath, mid, "VALIDATION");
-    if (!validationFile)
-        return "continue";
+    if (!validationFile) {
+        return setToolFailureRetry("You must call gsd_validate_milestone to persist the validation results. No VALIDATION.md was created.");
+    }
     const validationContent = await loadFile(validationFile);
-    if (!validationContent)
-        return "continue";
+    if (!validationContent) {
+        return setToolFailureRetry("You must call gsd_validate_milestone to persist the validation results. VALIDATION.md exists but is empty.");
+    }
     const verdict = extractVerdict(validationContent);
     if (verdict !== "needs-remediation") {
         await persistMilestoneValidationGate("pass", "none", `milestone validation verdict is ${verdict}; no remediation loop risk`, "", mid);