gsd-pi 2.81.0-dev.3cddbbba2 → 2.81.0-dev.72a81bdf3

package/dist/resources/.managed-resources-content-hash

@@ -1 +1 @@
-f38fa6411e8b7897
+cec78fe13fe69412

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

@@ -31,6 +31,7 @@ import { withTimeout, FINALIZE_PRE_TIMEOUT_MS, FINALIZE_POST_TIMEOUT_MS } from "
 import { getEligibleSlices } from "../slice-parallel-eligibility.js";
 import { startSliceParallel } from "../slice-parallel-orchestrator.js";
 import { isDbAvailable, getMilestoneSlices } from "../gsd-db.js";
+import { reconcileBeforeSpawn } from "../state-reconciliation.js";
 import { ensurePlanV2Graph, isEmptyPlanV2GraphResult, isMissingFinalizedContextResult } from "../uok/plan-v2.js";
 import { resolveUokFlags } from "../uok/flags.js";
 import { UokGateRunner } from "../uok/gate-runner.js";
@@ -647,6 +648,13 @@ export async function runPreDispatch(ic, loopState) {
                         eligibleSlices: eligible.map(e => e.id),
                     });
                     ctx.ui.notify(`Slice-parallel: dispatching ${eligible.length} eligible slices for ${mid}.`, "info");
+                    // ADR-017 #5707: reconcile before spawning so each worker doesn't
+                    // independently race on the same drift. Failure aborts the spawn.
+                    const spawnGate = await reconcileBeforeSpawn(s.basePath);
+                    if (!spawnGate.ok) {
+                        ctx.ui.notify(`Slice-parallel: aborting spawn — ${spawnGate.reason}`, "error");
+                        return { action: "break", reason: `slice-parallel-reconciliation-failed: ${spawnGate.reason}` };
+                    }
                     const result = await startSliceParallel(s.basePath, mid, eligible, {
                         maxWorkers: prefs.slice_parallel.max_workers ?? 2,
                         useExecutionGraph: uokFlags.executionGraph,
@@ -971,118 +979,115 @@ export async function runDispatch(ic, preData, loopState) {
         return worktreeSafetyBlock;
     // ── Sliding-window stuck detection with graduated recovery ──
     const derivedKey = `${unitType}/${unitId}`;
-    // Always record this dispatch in the sliding window so detectStuck() has
-    // accurate history. Skipping the push when pendingVerificationRetry is set
-    // caused infinite artifact-retry loops to be invisible to stuck detection
-    // (#2007). Only the *response* to a stuck signal is suppressed during retries.
+    // Always record this dispatch in the sliding window and run detection so
+    // Rules 1/3/4 can catch retry loops with repeated failure content (#5719).
+    // Rules 2/2b suppress legitimate retry backoff through the dispatch ledger.
     loopState.recentUnits.push({ key: derivedKey });
     if (loopState.recentUnits.length > STUCK_WINDOW_SIZE)
         loopState.recentUnits.shift();
-    if (!s.pendingVerificationRetry) {
-        const stuckSignal = detectStuck(loopState.recentUnits);
-        if (stuckSignal) {
-            debugLog("autoLoop", {
-                phase: "stuck-check",
-                unitType,
-                unitId,
-                reason: stuckSignal.reason,
-                recoveryAttempts: loopState.stuckRecoveryAttempts,
-            });
-            if (loopState.stuckRecoveryAttempts === 0) {
-                // Level 1: try verifying the artifact, then cache invalidation + retry
-                loopState.stuckRecoveryAttempts++;
-                const artifactExists = verifyExpectedArtifact(unitType, unitId, s.basePath);
-                if (artifactExists) {
-                    if (unitType === "complete-milestone") {
-                        const stuckDiag = diagnoseExpectedArtifact(unitType, unitId, s.basePath);
-                        const stuckParts = [
-                            `Detected ${unitType} ${unitId} output on disk, but the same unit is still being derived.`,
-                            "This usually means the milestone summary exists while the DB row still does not mark the milestone complete.",
-                        ];
-                        if (stuckDiag)
-                            stuckParts.push(`Expected: ${stuckDiag}`);
-                        ctx.ui.notify(stuckParts.join(" "), "warning");
-                        await deps.pauseAuto(ctx, pi);
-                        return { action: "break", reason: "complete-milestone-artifact-db-mismatch" };
-                    }
-                    debugLog("autoLoop", {
-                        phase: "stuck-recovery",
-                        level: 1,
-                        action: "artifact-found",
-                    });
-                    const recoveryDb = refreshRecoveryDbForArtifact(unitType, unitId);
-                    if (!recoveryDb.ok) {
-                        ctx.ui.notify(recoveryDb.fatal
-                            ? `${recoveryDb.message} Pausing auto-mode for manual recovery.`
-                            : `${recoveryDb.message} Keeping stuck state for retry.`, "warning");
-                        if (recoveryDb.fatal) {
-                            await deps.pauseAuto(ctx, pi);
-                            return { action: "break", reason: recoveryDb.reason };
-                        }
-                        return { action: "continue" };
-                    }
-                    ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk. Invalidating caches.`, "info");
-                    deps.invalidateAllCaches();
-                    loopState.recentUnits.length = 0;
-                    loopState.stuckRecoveryAttempts = 0;
-                    return { action: "continue" };
+    const stuckSignal = detectStuck(loopState.recentUnits);
+    if (stuckSignal) {
+        debugLog("autoLoop", {
+            phase: "stuck-check",
+            unitType,
+            unitId,
+            reason: stuckSignal.reason,
+            recoveryAttempts: loopState.stuckRecoveryAttempts,
+        });
+        if (loopState.stuckRecoveryAttempts === 0) {
+            // Level 1: try verifying the artifact, then cache invalidation + retry
+            loopState.stuckRecoveryAttempts++;
+            const artifactExists = verifyExpectedArtifact(unitType, unitId, s.basePath);
+            if (artifactExists) {
+                if (unitType === "complete-milestone") {
+                    const stuckDiag = diagnoseExpectedArtifact(unitType, unitId, s.basePath);
+                    const stuckParts = [
+                        `Detected ${unitType} ${unitId} output on disk, but the same unit is still being derived.`,
+                        "This usually means the milestone summary exists while the DB row still does not mark the milestone complete.",
+                    ];
+                    if (stuckDiag)
+                        stuckParts.push(`Expected: ${stuckDiag}`);
+                    ctx.ui.notify(stuckParts.join(" "), "warning");
+                    await deps.pauseAuto(ctx, pi);
+                    return { action: "break", reason: "complete-milestone-artifact-db-mismatch" };
                 }
-                ctx.ui.notify(`Stuck on ${unitType} ${unitId} (${stuckSignal.reason}). Invalidating caches and retrying.`, "warning");
-                deps.invalidateAllCaches();
-            }
-            else {
-                // Level 2: hard stop — genuinely stuck
-                deps.invalidateAllCaches();
-                const artifactExists = verifyExpectedArtifact(unitType, unitId, s.basePath);
-                if (artifactExists && unitType !== "complete-milestone") {
-                    debugLog("autoLoop", {
-                        phase: "stuck-recovery",
-                        level: 2,
-                        action: "artifact-found",
-                    });
-                    const recoveryDb = refreshRecoveryDbForArtifact(unitType, unitId);
-                    if (recoveryDb.ok) {
-                        ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk after cache invalidation. Continuing.`, "info");
-                        loopState.recentUnits.length = 0;
-                        loopState.stuckRecoveryAttempts = 0;
-                        return { action: "continue" };
-                    }
+                debugLog("autoLoop", {
+                    phase: "stuck-recovery",
+                    level: 1,
+                    action: "artifact-found",
+                });
+                const recoveryDb = refreshRecoveryDbForArtifact(unitType, unitId);
+                if (!recoveryDb.ok) {
                     ctx.ui.notify(recoveryDb.fatal
                         ? `${recoveryDb.message} Pausing auto-mode for manual recovery.`
-                        : `${recoveryDb.message} Stopping for manual recovery.`, "warning");
+                        : `${recoveryDb.message} Keeping stuck state for retry.`, "warning");
                     if (recoveryDb.fatal) {
                         await deps.pauseAuto(ctx, pi);
                         return { action: "break", reason: recoveryDb.reason };
                     }
+                    return { action: "continue" };
                 }
-                debugLog("autoLoop", {
-                    phase: "stuck-detected",
-                    unitType,
-                    unitId,
-                    reason: stuckSignal.reason,
-                });
-                const stuckDiag = diagnoseExpectedArtifact(unitType, unitId, s.basePath);
-                const stuckRemediation = buildLoopRemediationSteps(unitType, unitId, s.basePath);
-                const stuckParts = [`Stuck on ${unitType} ${unitId} — ${stuckSignal.reason}.`];
-                if (stuckDiag)
-                    stuckParts.push(`Expected: ${stuckDiag}`);
-                if (stuckRemediation)
-                    stuckParts.push(`To recover:\n${stuckRemediation}`);
-                ctx.ui.notify(stuckParts.join(" "), "error");
-                await deps.stopAuto(ctx, pi, `Stuck: ${stuckSignal.reason}`);
-                return { action: "break", reason: "stuck-detected" };
+                ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk. Invalidating caches.`, "info");
+                deps.invalidateAllCaches();
+                loopState.recentUnits.length = 0;
+                loopState.stuckRecoveryAttempts = 0;
+                return { action: "continue" };
             }
+            ctx.ui.notify(`Stuck on ${unitType} ${unitId} (${stuckSignal.reason}). Invalidating caches and retrying.`, "warning");
+            deps.invalidateAllCaches();
         }
         else {
-            // Progress detected — reset recovery counter
-            if (loopState.stuckRecoveryAttempts > 0) {
+            // Level 2: hard stop — genuinely stuck
+            deps.invalidateAllCaches();
+            const artifactExists = verifyExpectedArtifact(unitType, unitId, s.basePath);
+            if (artifactExists && unitType !== "complete-milestone") {
                 debugLog("autoLoop", {
-                    phase: "stuck-counter-reset",
-                    from: loopState.recentUnits[loopState.recentUnits.length - 2]?.key ?? "",
-                    to: derivedKey,
+                    phase: "stuck-recovery",
+                    level: 2,
+                    action: "artifact-found",
                 });
-                loopState.stuckRecoveryAttempts = 0;
+                const recoveryDb = refreshRecoveryDbForArtifact(unitType, unitId);
+                if (recoveryDb.ok) {
+                    ctx.ui.notify(`Stuck recovery: artifact for ${unitType} ${unitId} found on disk after cache invalidation. Continuing.`, "info");
+                    loopState.recentUnits.length = 0;
+                    loopState.stuckRecoveryAttempts = 0;
+                    return { action: "continue" };
+                }
+                ctx.ui.notify(recoveryDb.fatal
+                    ? `${recoveryDb.message} Pausing auto-mode for manual recovery.`
+                    : `${recoveryDb.message} Stopping for manual recovery.`, "warning");
+                if (recoveryDb.fatal) {
+                    await deps.pauseAuto(ctx, pi);
+                    return { action: "break", reason: recoveryDb.reason };
+                }
             }
+            debugLog("autoLoop", {
+                phase: "stuck-detected",
+                unitType,
+                unitId,
+                reason: stuckSignal.reason,
+            });
+            const stuckDiag = diagnoseExpectedArtifact(unitType, unitId, s.basePath);
+            const stuckRemediation = buildLoopRemediationSteps(unitType, unitId, s.basePath);
+            const stuckParts = [`Stuck on ${unitType} ${unitId} — ${stuckSignal.reason}.`];
+            if (stuckDiag)
+                stuckParts.push(`Expected: ${stuckDiag}`);
+            if (stuckRemediation)
+                stuckParts.push(`To recover:\n${stuckRemediation}`);
+            ctx.ui.notify(stuckParts.join(" "), "error");
+            await deps.stopAuto(ctx, pi, `Stuck: ${stuckSignal.reason}`);
+            return { action: "break", reason: "stuck-detected" };
+        }
+    }
+    else {
+        // Progress detected — reset recovery counter
+        if (loopState.stuckRecoveryAttempts > 0) {
+            debugLog("autoLoop", {
+                phase: "stuck-counter-reset",
+                from: loopState.recentUnits[loopState.recentUnits.length - 2]?.key ?? "",
+                to: derivedKey,
+            });
+            loopState.stuckRecoveryAttempts = 0;
         }
     }
     return {

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

@@ -14,13 +14,11 @@ 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 { getErrorMessage } from "./error-utils.js";
-import { logWarning, logError } from "./workflow-logger.js";
+import { logWarning } from "./workflow-logger.js";
 import { readIntegrationBranch } from "./git-service.js";
 import { isClosedStatus } from "./status-guards.js";
-import { nativeConflictFiles, nativeCommit, nativeCheckoutTheirs, nativeAddPaths, nativeMergeAbort, nativeRebaseAbort, nativeResetHard, } from "./native-git-bridge.js";
 import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildSliceFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
-import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, writeFileSync, } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { dirname, join } from "node:path";
 import { resolveExpectedArtifactPath, diagnoseExpectedArtifact, } from "./auto-artifact-paths.js";
@@ -932,183 +930,10 @@ export function writeBlockerPlaceholder(unitType, unitId, base, reason) {
     return diagnoseExpectedArtifact(unitType, unitId, base);
 }
 // ─── Merge State Reconciliation ───────────────────────────────────────────────
-/**
- * Best-effort abort of a pending merge/squash and hard-reset to HEAD.
- * Handles both real merges (MERGE_HEAD) and squash merges (SQUASH_MSG).
- */
-function abortAndResetMerge(basePath, hasMergeHead, squashMsgPath) {
-    if (hasMergeHead) {
-        try {
-            nativeMergeAbort(basePath);
-        }
-        catch (err) {
-            /* best-effort */
-            logWarning("recovery", `git merge-abort failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    else if (squashMsgPath) {
-        try {
-            unlinkSync(squashMsgPath);
-        }
-        catch (err) {
-            /* best-effort */
-            logWarning("recovery", `file unlink failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
-    }
-    try {
-        nativeResetHard(basePath);
-    }
-    catch (err) {
-        /* best-effort */
-        logError("recovery", `git reset failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
-}
-/**
- * Detect and abort other in-progress git operations left behind by a SIGKILL'd
- * worker (rebase, cherry-pick, revert). Without this, a killed worker mid-rebase
- * leaves `.git/rebase-merge/` or `.git/CHERRY_PICK_HEAD` and the worktree is
- * wedged until the user manually runs the matching `--abort`.
- *
- * Called before merge-state reconciliation because these states block any
- * subsequent merge/commit operation. (Issue #4980 HIGH-7)
- */
-function reconcileOtherInProgressGitOps(basePath, ctx) {
-    const gitDir = join(basePath, ".git");
-    const states = [
-        {
-            label: "rebase",
-            indicators: [join(gitDir, "rebase-merge"), join(gitDir, "rebase-apply")],
-            abort: () => nativeRebaseAbort(basePath),
-        },
-        {
-            label: "cherry-pick",
-            indicators: [join(gitDir, "CHERRY_PICK_HEAD")],
-            abort: () => {
-                // No native helper; fall back to git CLI.
-                try {
-                    execFileSync("git", ["cherry-pick", "--abort"], {
-                        cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8",
-                    });
-                }
-                catch (err) {
-                    logWarning("recovery", `cherry-pick --abort failed: ${getErrorMessage(err)}`);
-                }
-            },
-        },
-        {
-            label: "revert",
-            indicators: [join(gitDir, "REVERT_HEAD")],
-            abort: () => {
-                try {
-                    execFileSync("git", ["revert", "--abort"], {
-                        cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8",
-                    });
-                }
-                catch (err) {
-                    logWarning("recovery", `revert --abort failed: ${getErrorMessage(err)}`);
-                }
-            },
-        },
-    ];
-    let reconciled = false;
-    for (const s of states) {
-        const present = s.indicators.some((p) => existsSync(p));
-        if (!present)
-            continue;
-        try {
-            s.abort();
-            ctx.ui.notify(`Detected leftover ${s.label} state from prior session — aborted.`, "warning");
-            reconciled = true;
-        }
-        catch (err) {
-            logError("recovery", `${s.label} abort failed: ${getErrorMessage(err)}`);
-            ctx.ui.notify(`Detected leftover ${s.label} state but auto-abort failed. ` +
-                `Run \`git ${s.label} --abort\` manually before retrying.`, "error");
-            return "blocked";
-        }
-    }
-    return reconciled ? "reconciled" : "clean";
-}
-/**
- * Detect leftover merge state from a prior session and reconcile it.
- * If MERGE_HEAD or SQUASH_MSG exists, check whether conflicts are resolved.
- * If resolved: finalize the commit. If only .gsd conflicts remain: auto-resolve.
- * If code conflicts remain: fail safe without modifying the worktree.
- */
-export function reconcileMergeState(basePath, ctx) {
-    // First, abort any rebase/cherry-pick/revert left over from a SIGKILL'd
-    // worker. Doing this before the merge-state check unblocks any merge that
-    // would otherwise refuse with "you have unfinished operation". (HIGH-7)
-    const otherOpsResult = reconcileOtherInProgressGitOps(basePath, ctx);
-    if (otherOpsResult === "blocked")
-        return "blocked";
-    const mergeHeadPath = join(basePath, ".git", "MERGE_HEAD");
-    const squashMsgPath = join(basePath, ".git", "SQUASH_MSG");
-    const hasMergeHead = existsSync(mergeHeadPath);
-    const hasSquashMsg = existsSync(squashMsgPath);
-    if (!hasMergeHead && !hasSquashMsg) {
-        // If we cleaned up another op type, return "reconciled" so the caller
-        // re-derives state from a known-good baseline.
-        return otherOpsResult === "reconciled" ? "reconciled" : "clean";
-    }
-    const conflictedFiles = nativeConflictFiles(basePath);
-    if (conflictedFiles.length === 0) {
-        // All conflicts resolved — finalize the merge/squash commit
-        try {
-            const commitSha = nativeCommit(basePath, "chore(gsd): reconcile merge state");
-            if (commitSha) {
-                const mode = hasMergeHead ? "merge" : "squash commit";
-                ctx.ui.notify(`Finalized leftover ${mode} from prior session.`, "info");
-            }
-            else {
-                ctx.ui.notify("No new commit needed for leftover merge/squash state — already committed.", "info");
-            }
-        }
-        catch (err) {
-            const errorMessage = getErrorMessage(err);
-            ctx.ui.notify(`Failed to finalize leftover merge/squash commit: ${errorMessage}`, "error");
-            return "blocked";
-        }
-    }
-    else {
-        // Still conflicted — try auto-resolving .gsd/ state file conflicts (#530)
-        const gsdConflicts = conflictedFiles.filter((f) => f.startsWith(".gsd/"));
-        const codeConflicts = conflictedFiles.filter((f) => !f.startsWith(".gsd/"));
-        if (gsdConflicts.length > 0 && codeConflicts.length === 0) {
-            // All conflicts are in .gsd/ state files — auto-resolve by accepting theirs
-            let resolved = true;
-            try {
-                nativeCheckoutTheirs(basePath, gsdConflicts);
-                nativeAddPaths(basePath, gsdConflicts);
-            }
-            catch (e) {
-                logError("recovery", `auto-resolve .gsd/ conflicts failed: ${e.message}`);
-                resolved = false;
-            }
-            if (resolved) {
-                try {
-                    nativeCommit(basePath, "chore: auto-resolve .gsd/ state file conflicts");
-                    ctx.ui.notify(`Auto-resolved ${gsdConflicts.length} .gsd/ state file conflict(s) from prior merge.`, "info");
-                }
-                catch (e) {
-                    logError("recovery", `auto-commit .gsd/ conflict resolution failed: ${e.message}`);
-                    resolved = false;
-                }
-            }
-            if (!resolved) {
-                abortAndResetMerge(basePath, hasMergeHead, squashMsgPath);
-                ctx.ui.notify("Detected leftover merge state — auto-resolve failed, cleaned up. Re-deriving state.", "warning");
-            }
-        }
-        else {
-            // Code conflicts present — fail safe and preserve any manual resolution
-            // work instead of discarding it with merge --abort/reset --hard.
-            ctx.ui.notify("Detected leftover merge state with unresolved code conflicts. Auto-mode will pause without modifying the worktree so manual conflict resolution is preserved.", "error");
-            return "blocked";
-        }
-    }
-    return "reconciled";
-}
+// Body relocated to state-reconciliation/drift/merge-state.ts (ADR-017 #5701).
+// Re-exported here for backward compatibility with existing call sites:
+// auto.ts, auto/loop-deps.ts, tests/integration/auto-recovery.test.ts.
+export { reconcileMergeState, } from "./state-reconciliation/drift/merge-state.js";
 // ─── Loop Remediation ─────────────────────────────────────────────────────────
 /**
  * Build concrete, manual remediation steps for a loop-detected unit failure.

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

@@ -1399,16 +1399,19 @@ export function createWiredAutoOrchestrationModule(ctx, _pi, dispatchBasePath, r
         stateReconciliation: {
             async reconcileBeforeDispatch() {
                 const result = await reconcileBeforeDispatch(dispatchBasePath);
-                if (!result.ok) {
+                if (result.blockers.length > 0) {
                     return {
                         ok: false,
-                        reason: result.reason,
+                        reason: result.blockers[0],
                         stateSnapshot: result.stateSnapshot,
                     };
                 }
+                const repairedKinds = result.repaired.map((d) => d.kind);
                 return {
                     ok: true,
-                    reason: result.repaired.join(", "),
+                    reason: repairedKinds.length > 0
+                        ? `repaired: ${repairedKinds.join(", ")}`
+                        : "clean",
                     stateSnapshot: result.stateSnapshot,
                 };
             },

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -116,8 +116,7 @@ export function isBareClaudeCodeStreamAbortPlaceholder(lastMsg) {
  * Claude Code abort markers are intentionally ignored when the abort fires
  * while the session-switch is in flight: the abort is the expected side-effect
  * of the transition, not a user signal. Other branches (genuine `stopReason
- * === "aborted"` with diagnostic content/errorMessage) preserve the prior
- * behavior.
+ * === "aborted"` with explicit errorMessage) preserve the prior behavior.
  */
 export function _handleSessionSwitchAgentEnd(lastMsg, resolveCancelled) {
     if (!lastMsg || typeof lastMsg !== "object")
@@ -136,10 +135,8 @@ export function _handleSessionSwitchAgentEnd(lastMsg, resolveCancelled) {
         return;
     }
     if (m.stopReason === "aborted") {
-        const content = m.content;
-        const hasEmptyContent = Array.isArray(content) && content.length === 0;
         const hasErrorMessage = !!m.errorMessage;
-        if (!hasEmptyContent || hasErrorMessage) {
+        if (hasErrorMessage) {
             resolveCancelled(_buildAbortedPauseContext(m));
         }
     }

package/dist/resources/extensions/gsd/commands/handlers/parallel.js

@@ -2,6 +2,7 @@ import { getOrchestratorState, getWorkerStatuses, isParallelActive, pauseWorker,
 import { formatEligibilityReport } from "../../parallel-eligibility.js";
 import { formatMergeResults, mergeAllCompleted, mergeCompletedMilestone } from "../../parallel-merge.js";
 import { loadEffectiveGSDPreferences, resolveParallelConfig } from "../../preferences.js";
+import { reconcileBeforeSpawn } from "../../state-reconciliation.js";
 import { projectRoot } from "../context.js";
 function emitParallelMessage(pi, content) {
     pi.sendMessage({ customType: "gsd-parallel", content, display: true });
@@ -26,6 +27,14 @@ export async function handleParallelCommand(trimmed, _ctx, pi) {
             emitParallelMessage(pi, `${report}\n\nNo milestones are eligible for parallel execution.`);
             return true;
         }
+        // ADR-017 #5707: reconcile before spawning so workers don't independently
+        // race on the same drift. Failures abort the spawn with an actionable
+        // user-visible message.
+        const gate = await reconcileBeforeSpawn(root);
+        if (!gate.ok) {
+            emitParallelMessage(pi, `${report}\n\nParallel orchestration aborted before spawn — ${gate.reason}`);
+            return true;
+        }
         const result = await startParallel(root, candidates.eligible.map((candidate) => candidate.milestoneId), loaded?.preferences);
         const lines = ["Parallel orchestration started.", `Workers: ${result.started.join(", ")}`];
         if (result.errors.length > 0) {

package/dist/resources/extensions/gsd/gsd-db.js

@@ -977,32 +977,16 @@ export function setSliceSketchFlag(milestoneId, sliceId, isSketch) {
     currentDb.prepare(`UPDATE slices SET is_sketch = :is_sketch WHERE milestone_id = :mid AND id = :sid`).run({ ":is_sketch": isSketch ? 1 : 0, ":mid": milestoneId, ":sid": sliceId });
 }
 /**
- * ADR-011 auto-heal: reconcile stale is_sketch=1 rows whose PLAN already exists.
- *
- * Callers pass a predicate that resolves whether a plan file exists for a slice.
- * The predicate MUST use the canonical path resolver (`resolveSliceFile`, etc.)
- * to keep path logic in one place — do not hand-roll the path inside the callback.
- *
- * Recovers from two scenarios:
- *   1. Crash between `gsd_plan_slice` write and the sketch flag flip.
- *   2. Flag-OFF downgrade path: when `progressive_planning` is off, the dispatch
- *      rule routes sketch slices to plan-slice, which writes PLAN.md but leaves
- *      `is_sketch=1` — the next state derivation auto-heals it to 0 here.
- *
- * Not aggressive in practice: PLAN.md is only written via the DB-backed
- * `gsd_plan_slice` tool (which also inserts tasks), so a "stale PLAN.md with
- * is_sketch=1" is extremely unlikely to indicate anything other than the two
- * recovery scenarios above.
+ * ADR-017 raw primitive: returns slice IDs in a milestone whose is_sketch flag
+ * is still 1. The stale-sketch-flag drift handler at
+ * `state-reconciliation/drift/sketch-flag.ts` composes this with PLAN.md
+ * existence checks to detect drift, then writes via `setSliceSketchFlag`.
  */
-export function autoHealSketchFlags(milestoneId, hasPlanFile) {
+export function getSketchedSliceIds(milestoneId) {
     if (!currentDb)
-        return;
+        return [];
     const rows = currentDb.prepare(`SELECT id FROM slices WHERE milestone_id = :mid AND is_sketch = 1`).all({ ":mid": milestoneId });
-    for (const row of rows) {
-        if (hasPlanFile(row.id)) {
-            setSliceSketchFlag(milestoneId, row.id, false);
-        }
-    }
+    return rows.map((r) => r.id);
 }
 export function upsertSlicePlanning(milestoneId, sliceId, planning) {
     if (!currentDb)