gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0

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

@@ -1,6 +1,6 @@
 // GSD-2 + src/resources/extensions/gsd/auto/run-unit.ts - Runs one GSD auto-mode unit from session creation through agent completion.
 import { NEW_SESSION_TIMEOUT_MS } from "./session.js";
-import { _clearCurrentResolve, _setCurrentResolve, _setSessionSwitchInFlight } from "./resolve.js";
+import { _clearCurrentResolve, _consumePendingSwitchCancellation, _markSessionSwitchAbortGraceWindow, _setCurrentResolve, _setSessionSwitchInFlight, } from "./resolve.js";
 import { getCurrentTurnGeneration, runWithTurnGeneration, } from "./turn-epoch.js";
 import { debugLog } from "../debug-logger.js";
 import { logWarning } from "../workflow-logger.js";
@@ -19,44 +19,23 @@ let sessionSwitchGeneration = 0;
  */
 export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     debugLog("runUnit", { phase: "start", unitType, unitId });
-    // Ensure cwd matches basePath BEFORE newSession() captures it. The new
-    // session reads process.cwd() during construction to anchor its tool
-    // runtime and system prompt; if cwd has drifted (async_bash, background
-    // jobs, prior unit cleanup), the session would otherwise be rooted to
-    // the wrong directory. Must be synchronous — no awaits between chdir
-    // and newSession (#1389, #4762 follow-up).
-    try {
-        if (process.cwd() !== s.basePath) {
-            process.chdir(s.basePath);
-        }
-    }
-    catch (e) {
-        const msg = `Failed to chdir to basePath before newSession (basePath: ${s.basePath}): ${String(e)}`;
-        logWarning("engine", msg, { basePath: s.basePath, error: String(e) });
-        return {
-            status: "cancelled",
-            errorContext: {
-                message: msg,
-                category: "session-failed",
-                isTransient: true,
-            },
-        };
-    }
     // ── Session creation with timeout ──
     debugLog("runUnit", { phase: "session-create", unitType, unitId });
     let sessionResult;
     let sessionTimeoutHandle;
     const mySessionSwitchGeneration = ++sessionSwitchGeneration;
-    // #3731: Cancellation controller for newSession(). When the session-creation
-    // timeout fires, we abort this controller so that the still-in-flight
-    // newSession() discards itself after await this.abort() completes, preventing
-    // it from capturing the (now-root) process.cwd() and rebuilding the tool
-    // runtime with the wrong cwd.
+    // #3731: Cancellation controller for newSession(). When session creation
+    // times out, abort before a late session switch can rebuild the tool runtime
+    // against a stale workspace root.
     const sessionAbortController = new AbortController();
     _setSessionSwitchInFlight(true);
     try {
-        const sessionPromise = s.cmdCtx.newSession({ abortSignal: sessionAbortController.signal }).finally(() => {
+        const sessionPromise = s.cmdCtx.newSession({
+            abortSignal: sessionAbortController.signal,
+            workspaceRoot: s.basePath,
+        }).finally(() => {
             if (sessionSwitchGeneration === mySessionSwitchGeneration) {
+                _markSessionSwitchAbortGraceWindow();
                 _setSessionSwitchInFlight(false);
             }
         });
@@ -71,6 +50,7 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     catch (sessionErr) {
         if (sessionTimeoutHandle)
             clearTimeout(sessionTimeoutHandle);
+        _consumePendingSwitchCancellation();
         const msg = sessionErr instanceof Error ? sessionErr.message : String(sessionErr);
         debugLog("runUnit", {
             phase: "session-error",
@@ -83,15 +63,18 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     if (sessionTimeoutHandle)
         clearTimeout(sessionTimeoutHandle);
     if (sessionResult.cancelled) {
+        _consumePendingSwitchCancellation();
         debugLog("runUnit-session-timeout", { unitType, unitId });
         return { status: "cancelled", errorContext: { message: "Session creation timed out", category: "timeout", isTransient: true } };
     }
     if (!s.active) {
+        _consumePendingSwitchCancellation();
         return { status: "cancelled" };
     }
     if (s.currentUnitModel && typeof pi.setModel === "function") {
         const restored = await pi.setModel(s.currentUnitModel, { persist: false });
         if (!restored) {
+            _consumePendingSwitchCancellation();
             const message = `Failed to restore configured model ${s.currentUnitModel.provider}/${s.currentUnitModel.id} after session creation`;
             ctx.ui.notify(`${message}. Cancelling unit before dispatch.`, "warning");
             return {
@@ -107,10 +90,19 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     // ── Create the agent_end promise (per-unit one-shot) ──
     // This happens after newSession completes so session-switch agent_end events
     // from the previous session cannot resolve the new unit.
+    _markSessionSwitchAbortGraceWindow();
     _setSessionSwitchInFlight(false);
     const unitPromise = new Promise((resolve) => {
         _setCurrentResolve(resolve);
     });
+    const pendingSwitchCancellation = _consumePendingSwitchCancellation();
+    if (pendingSwitchCancellation) {
+        _clearCurrentResolve();
+        return {
+            status: "cancelled",
+            ...(pendingSwitchCancellation.errorContext ? { errorContext: pendingSwitchCancellation.errorContext } : {}),
+        };
+    }
     // ── Provider request-readiness pre-check (#4555) ──
     // Verify the provider can accept requests before dispatching. If the token
     // has expired since bootstrap, return cancelled immediately so the unit is

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

@@ -44,7 +44,7 @@ export class AutoSession {
     workerId = null;
     /**
      * Active milestone lease fencing token, set by claimMilestoneLease() inside
-     * worktree-resolver.enterMilestone(). Threaded into recordDispatchClaim()
+     * WorktreeLifecycle.enterMilestone(). Threaded into recordDispatchClaim()
      * as milestone_lease_token so out-of-band dispatches by a stale worker
      * are detectable.
      */
@@ -106,6 +106,13 @@ export class AutoSession {
      * stale context bleeding into unrelated slices.
      */
     lastPreExecFailure = null;
+    /**
+     * Tracks how many consecutive times each slice unit has failed pre-execution
+     * checks. Keyed by unitId (e.g. "M001/S01"). Used to break the infinite
+     * plan-slice → pre-exec fail → re-dispatch loop when the planner cannot fix
+     * the issues after MAX_PRE_EXEC_RETRIES re-attempts.
+     */
+    preExecRetryCount = new Map();
     // ── Tool invocation errors (#2883) ──────────────────────────────────
     /** Set when a GSD tool execution ends with isError due to malformed/truncated
      *  JSON arguments. Checked by postUnitPreVerification to break retry loops. */
@@ -258,6 +265,7 @@ export class AutoSession {
         this.rewriteAttemptCount = 0;
         this.consecutiveCompleteBootstraps = 0;
         this.lastPreExecFailure = null;
+        this.preExecRetryCount.clear();
         this.lastToolInvocationError = null;
         this.lastUnitAgentEndMessages = null;
         this.lastGitActionFailure = null;

package/dist/resources/extensions/gsd/auto/unit-runner-events.js

@@ -0,0 +1,7 @@
+// GSD-2 + src/resources/extensions/gsd/auto/unit-runner-events.ts - Classifies agent lifecycle events before Unit settlement.
+export function isInternalSessionTransitionAbortEvent(event) {
+    return event.abortOrigin === "session-transition";
+}
+export function shouldIgnoreAgentEndForActiveUnit(event) {
+    return isInternalSessionTransitionAbortEvent(event);
+}

package/dist/resources/extensions/gsd/auto/workflow-dispatch-claim.js

@@ -1,7 +1,39 @@
 // Project/App: GSD-2
 // File Purpose: Best-effort unit dispatch claim adapter for auto-mode loop.
+export function ensureDispatchLease(s, milestoneId, deps, opts = {}) {
+    if (!s.workerId)
+        return { kind: "degraded", reason: "missing-worker" };
+    if (!milestoneId)
+        return { kind: "degraded", reason: "missing-milestone" };
+    if (!opts.forceReclaim && typeof s.milestoneLeaseToken === "number") {
+        return { kind: "ready", token: s.milestoneLeaseToken, recovered: false };
+    }
+    s.milestoneLeaseToken = null;
+    try {
+        const claim = deps.claimMilestoneLease(s.workerId, milestoneId);
+        if (!claim.ok) {
+            const reason = `Milestone ${milestoneId} is held by worker ${claim.byWorker} until ${claim.expiresAt}.`;
+            deps.logLeaseRecoveryFailed({ milestoneId, workerId: s.workerId, reason });
+            return { kind: "blocked", reason };
+        }
+        s.currentMilestoneId = milestoneId;
+        s.milestoneLeaseToken = claim.token;
+        deps.logLeaseRecovered({
+            milestoneId,
+            workerId: s.workerId,
+            token: claim.token,
+            recovered: opts.forceReclaim === true,
+        });
+        return { kind: "ready", token: claim.token, recovered: opts.forceReclaim === true };
+    }
+    catch (err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        deps.logLeaseRecoveryFailed({ milestoneId, workerId: s.workerId, reason });
+        return { kind: "failed", reason };
+    }
+}
 export function openDispatchClaim(s, flowId, turnId, iterData, deps) {
-    if (!s.workerId || s.milestoneLeaseToken === null)
+    if (!s.workerId || typeof s.milestoneLeaseToken !== "number")
         return { kind: "degraded" };
     const mid = iterData.mid;
     if (!mid)

package/dist/resources/extensions/gsd/auto/workflow-worker-heartbeat.js

@@ -6,7 +6,15 @@ export function maintainWorkerHeartbeat(session, deps) {
     try {
         deps.heartbeatAutoWorker(session.workerId);
         if (session.currentMilestoneId && session.milestoneLeaseToken) {
-            deps.refreshMilestoneLease(session.workerId, session.currentMilestoneId, session.milestoneLeaseToken);
+            const refreshed = deps.refreshMilestoneLease(session.workerId, session.currentMilestoneId, session.milestoneLeaseToken);
+            if (!refreshed) {
+                deps.logLeaseRefreshMiss?.({
+                    workerId: session.workerId,
+                    milestoneId: session.currentMilestoneId,
+                    fencingToken: session.milestoneLeaseToken,
+                });
+                session.milestoneLeaseToken = null;
+            }
         }
     }
     catch (err) {

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

@@ -468,6 +468,20 @@ export function _resetWidgetModeForTests() {
 export function updateProgressWidget(ctx, unitType, unitId, state, accessors, tierBadge) {
     if (!ctx.hasUI)
         return;
+    // Welcome header is a startup-only banner — permanently suppress it once
+    // auto-mode activates. The dashboard widget owns all status from here.
+    // Note: setHeader(undefined) restores the built-in header (logo +
+    // instructions). To actually render zero lines, install an empty header.
+    if (typeof ctx.ui?.setHeader === "function") {
+        ctx.ui.setHeader(() => ({
+            render() { return []; },
+            invalidate() { },
+        }));
+    }
+    // Clear wizard step badge — auto-mode owns the UI from this point
+    if (typeof ctx.ui?.setStatus === "function") {
+        ctx.ui.setStatus("gsd-step", undefined);
+    }
     const verb = unitVerb(unitType);
     const phaseLabel = unitPhaseLabel(unitType);
     const mid = state.activeMilestone;
@@ -857,6 +871,10 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                         ? lastCommit.message.slice(0, maxCommitLen - 1) + "…"
                         : lastCommit.message
                     : "";
+                // Step-mode guidance — shown above keyboard hints when auto is paused
+                if (accessors.isStepMode()) {
+                    lines.push(`${pad}${theme.fg("accent", "→")} ${theme.fg("dim", "Ctrl+N to advance to next step  ·  /gsd status for overview")}`);
+                }
                 // Hints line
                 const hintParts = [];
                 hintParts.push("esc pause");

package/dist/resources/extensions/gsd/auto-direct-dispatch.js

@@ -11,7 +11,6 @@ import { buildResearchSlicePrompt, buildResearchMilestonePrompt, buildPlanSliceP
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
 import { resolveCanonicalMilestoneRoot } from "./worktree-manager.js";
-import { logWarning } from "./workflow-logger.js";
 import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, } from "./workflow-mcp.js";
 export async function dispatchDirectPhase(ctx, pi, phase, base) {
     const state = await deriveState(base);
@@ -231,36 +230,10 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
         return;
     }
     ctx.ui.notify(`Dispatching ${unitType} for ${unitId}...`, "info");
-    const originalCwd = process.cwd();
-    try {
-        // Ensure cwd matches dispatchBase BEFORE newSession() captures it. Synchronous —
-        // no awaits between chdir and newSession.
-        try {
-            if (process.cwd() !== dispatchBase) {
-                process.chdir(dispatchBase);
-            }
-        }
-        catch (err) {
-            const msg = `Failed to chdir before direct-dispatch newSession (basePath: ${dispatchBase}): ${err instanceof Error ? err.message : String(err)}`;
-            logWarning("engine", msg, { file: "auto-direct-dispatch.ts", basePath: dispatchBase, error: err instanceof Error ? err.message : String(err) });
-            ctx.ui.notify(`${msg}. Cancelling dispatch to avoid running in the wrong directory.`, "error");
-            return;
-        }
-        const result = await ctx.newSession();
-        if (result.cancelled) {
-            ctx.ui.notify("Session creation cancelled.", "warning");
-            return;
-        }
-        pi.sendMessage({ customType: "gsd-dispatch", content: prompt, display: false }, { triggerTurn: true });
-    }
-    finally {
-        try {
-            if (process.cwd() !== originalCwd) {
-                process.chdir(originalCwd);
-            }
-        }
-        catch (err) {
-            logWarning("engine", `Failed to restore cwd after direct dispatch: ${err instanceof Error ? err.message : String(err)}`, { file: "auto-direct-dispatch.ts", basePath: originalCwd });
-        }
+    const result = await ctx.newSession({ workspaceRoot: dispatchBase });
+    if (result.cancelled) {
+        ctx.ui.notify("Session creation cancelled.", "warning");
+        return;
     }
+    pi.sendMessage({ customType: "gsd-dispatch", content: prompt, display: false }, { triggerTurn: true });
 }

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

@@ -791,6 +791,22 @@ export const DISPATCH_RULES = [
             const unitId = `${mid}/${sid}`;
             let priorPreExecFailure;
             if (session?.lastPreExecFailure?.unitId === unitId) {
+                // Circuit breaker: stop re-dispatching after 2 failed retries. The
+                // planner has had multiple attempts with injected failure context and
+                // still cannot produce a valid plan — human review is required.
+                const MAX_PRE_EXEC_RETRIES = 2;
+                const retryCount = session.preExecRetryCount?.get(unitId) ?? 0;
+                if (retryCount >= MAX_PRE_EXEC_RETRIES) {
+                    const findings = session.lastPreExecFailure.blockingFindings.join("; ");
+                    session.lastPreExecFailure = null;
+                    session.preExecRetryCount?.delete(unitId);
+                    return {
+                        action: "stop",
+                        reason: `Pre-execution checks failed ${retryCount} times for ${unitId} — manual intervention required. Blocking findings: ${findings}. Fix the plan manually, then run /gsd auto to resume.`,
+                        level: "error",
+                        matchedRule: "planning → plan-slice",
+                    };
+                }
                 priorPreExecFailure = {
                     blockingFindings: session.lastPreExecFailure.blockingFindings,
                     verdictExcerpt: session.lastPreExecFailure.verdictExcerpt,

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

@@ -1,3 +1,5 @@
+// Project/App: GSD-2
+// File Purpose: Auto-mode post-unit git, verification, projection, and hook processing.
 /**
  * Post-unit processing for auto-loop — auto-commit, doctor run,
  * state rebuild, projection checks, DB tool closeout, hooks, triage, and
@@ -23,7 +25,8 @@ import { closeoutUnit } from "./auto-unit-closeout.js";
 import { runTurnGitAction, } from "./git-service.js";
 import { verifyExpectedArtifact, resolveExpectedArtifactPath, writeBlockerPlaceholder, diagnoseExpectedArtifact, } from "./auto-recovery.js";
 import { regenerateIfMissing } from "./workflow-projections.js";
-import { syncStateToProjectRoot } from "./auto-worktree.js";
+import { WorktreeStateProjection } from "./worktree-state-projection.js";
+import { createWorkspace, scopeMilestone } from "./workspace.js";
 import { normalizeWorktreePathForCompare } from "./worktree-root.js";
 import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter, getVerificationEvidence } from "./gsd-db.js";
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
@@ -57,6 +60,8 @@ import { validateArtifact } from "./schemas/validate.js";
 function isSamePathLocal(a, b) {
     return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
 }
+/** Stateless WorktreeStateProjection — methods are pure functions of MilestoneScope. */
+const _worktreeProjection = new WorktreeStateProjection();
 /** Maximum verification retry attempts before escalating to blocker placeholder (#2653). */
 const MAX_VERIFICATION_RETRIES = 3;
 /** Keep failure toasts short while still showing concrete examples. */
@@ -70,6 +75,62 @@ function formatPreExecutionCheckDetail(check) {
 }
 const COMPLETE_MILESTONE_DB_SETTLE_MS = 1500;
 const COMPLETE_MILESTONE_DB_SETTLE_POLL_MS = 100;
+function stripKnownIdPrefix(value, id) {
+    const raw = String(value ?? "").trim();
+    if (!raw)
+        return undefined;
+    const lower = raw.toLowerCase();
+    const idLower = id.toLowerCase();
+    if (lower.startsWith(`${idLower}:`))
+        return raw.slice(id.length + 1).trim() || undefined;
+    return raw;
+}
+async function buildTaskCommitContextForUnit(basePath, unitId) {
+    const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
+    if (!mid || !sid || !tid)
+        return undefined;
+    const milestone = isDbAvailable() ? getMilestone(mid) : null;
+    const slice = isDbAvailable() ? getSlice(mid, sid) : null;
+    const task = isDbAvailable() ? getTask(mid, sid, tid) : null;
+    let summary = null;
+    const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+    if (summaryPath) {
+        try {
+            const summaryContent = await loadFile(summaryPath);
+            if (summaryContent)
+                summary = parseSummary(summaryContent);
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
+        }
+    }
+    if (!summary && !task)
+        return undefined;
+    let ghIssueNumber;
+    try {
+        const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
+        ghIssueNumber = getTaskIssueNumberForCommit(basePath, mid, sid, tid) ?? undefined;
+    }
+    catch (err) {
+        logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    return {
+        taskId: `${sid}/${tid}`,
+        taskDisplayId: tid,
+        taskTitle: stripKnownIdPrefix(summary?.title, tid) ??
+            stripKnownIdPrefix(task?.title, tid) ??
+            tid,
+        milestoneId: mid,
+        milestoneTitle: stripKnownIdPrefix(milestone?.title, mid),
+        sliceId: sid,
+        sliceTitle: stripKnownIdPrefix(slice?.title, sid),
+        oneLiner: summary?.oneLiner || task?.one_liner || undefined,
+        keyFiles: summary?.frontmatter.key_files?.filter(f => !f.includes("{{")) ??
+            task?.key_files ??
+            undefined,
+        issueNumber: ghIssueNumber,
+    };
+}
 async function waitForMilestoneDbClose(mid) {
     const deadline = Date.now() + COMPLETE_MILESTONE_DB_SETTLE_MS;
     while (Date.now() < deadline) {
@@ -96,6 +157,19 @@ function enqueueSidecar(s, ctx, entry, debugExtra, notification) {
         ctx.ui.notify(notification, "info");
     return "continue";
 }
+export function _shouldDispatchTriageForTest(state) {
+    return !state.stepMode &&
+        !!state.currentUnit &&
+        !state.currentUnit.type.startsWith("hook/") &&
+        state.currentUnit.type !== "triage-captures" &&
+        state.currentUnit.type !== "quick-task";
+}
+export function _shouldDispatchQuickTaskForTest(state) {
+    return !state.stepMode &&
+        state.pendingQuickTasks.length > 0 &&
+        !!state.currentUnit &&
+        state.currentUnit.type !== "quick-task";
+}
 /** Unit types that only touch `.gsd/` internal state files (no code changes).
  *  Auto-commit is skipped for these — their state files are picked up by the
  *  next actual task commit via `smartStage()`. */
@@ -216,7 +290,7 @@ export function detectRogueFileWrites(unitType, unitId, basePath) {
  * in auto-verification.ts. Exceeding this limit pauses auto-mode instead of
  * looping indefinitely (#2007).
  */
-const MAX_ARTIFACT_VERIFICATION_RETRIES = 3;
+export const MAX_ARTIFACT_VERIFICATION_RETRIES = 3;
 export const STEP_COMPLETE_FALLBACK_MESSAGE = "Step complete. Run /clear, then /gsd to continue (or /gsd auto to run continuously).";
 export function buildStepCompleteMessage(nextState) {
     if (nextState.phase === "complete") {
@@ -267,36 +341,7 @@ export async function autoCommitUnit(basePath, unitType, unitId, ctx) {
     try {
         let taskContext;
         if (unitType === "execute-task") {
-            const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
-            if (mid && sid && tid) {
-                const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
-                if (summaryPath) {
-                    try {
-                        const summaryContent = await loadFile(summaryPath);
-                        if (summaryContent) {
-                            const summary = parseSummary(summaryContent);
-                            let ghIssueNumber;
-                            try {
-                                const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
-                                ghIssueNumber = getTaskIssueNumberForCommit(basePath, mid, sid, tid) ?? undefined;
-                            }
-                            catch (err) {
-                                logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-                            }
-                            taskContext = {
-                                taskId: `${sid}/${tid}`,
-                                taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
-                                oneLiner: summary.oneLiner || undefined,
-                                keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
-                                issueNumber: ghIssueNumber,
-                            };
-                        }
-                    }
-                    catch (e) {
-                        debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
-                    }
-                }
-            }
+            taskContext = await buildTaskCommitContextForUnit(basePath, unitId);
         }
         _resetHasChangesCache();
         if (LIFECYCLE_ONLY_UNITS.has(unitType)) {
@@ -359,38 +404,7 @@ export async function postUnitPreVerification(pctx, opts) {
         try {
             let taskContext;
             if (turnAction === "commit" && s.currentUnit.type === "execute-task") {
-                const { milestone: mid, slice: sid, task: tid } = parseUnitId(s.currentUnit.id);
-                if (mid && sid && tid) {
-                    const summaryPath = resolveTaskFile(s.basePath, mid, sid, tid, "SUMMARY");
-                    if (summaryPath) {
-                        try {
-                            const summaryContent = await loadFile(summaryPath);
-                            if (summaryContent) {
-                                const summary = parseSummary(summaryContent);
-                                // Look up GitHub issue number for commit linking
-                                let ghIssueNumber;
-                                try {
-                                    const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
-                                    ghIssueNumber = getTaskIssueNumberForCommit(s.basePath, mid, sid, tid) ?? undefined;
-                                }
-                                catch (err) {
-                                    // GitHub sync not available — skip
-                                    logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-                                }
-                                taskContext = {
-                                    taskId: `${sid}/${tid}`,
-                                    taskTitle: summary.title?.replace(/^T\d+:\s*/, "") || tid,
-                                    oneLiner: summary.oneLiner || undefined,
-                                    keyFiles: summary.frontmatter.key_files?.filter(f => !f.includes("{{")) || undefined,
-                                    issueNumber: ghIssueNumber,
-                                };
-                            }
-                        }
-                        catch (e) {
-                            debugLog("postUnit", { phase: "task-summary-parse", error: String(e) });
-                        }
-                    }
-                }
+                taskContext = await buildTaskCommitContextForUnit(s.basePath, s.currentUnit.id);
             }
             // Invalidate the nativeHasChanges cache before auto-commit (#1853).
             // The cache has a 10-second TTL and is keyed by basePath.  A stale
@@ -518,7 +532,20 @@ export async function postUnitPreVerification(pctx, opts) {
         // Sync worktree state back to project root (skipped for lightweight sidecars)
         if (!opts?.skipWorktreeSync && s.originalBasePath && !isSamePathLocal(s.originalBasePath, s.basePath)) {
             await runSafely("postUnit", "worktree-sync", () => {
-                syncStateToProjectRoot(s.basePath, s.originalBasePath, s.currentMilestoneId);
+                let scope = s.scope;
+                if (!scope && s.currentMilestoneId) {
+                    try {
+                        scope = scopeMilestone(createWorkspace(s.basePath), s.currentMilestoneId);
+                    }
+                    catch {
+                        // Non-fatal: scope construction can fail on synthetic test paths;
+                        // skipping the projection mirrors the prior path-string variant's
+                        // early-return behaviour for missing milestone/path inputs.
+                        scope = null;
+                    }
+                }
+                if (scope)
+                    _worktreeProjection.projectWorktreeToRoot(scope);
             });
         }
         // Rewrite-docs completion
@@ -1123,8 +1150,12 @@ export async function postUnitPostVerification(pctx) {
                     return;
                 }
                 const strictMode = prefs?.enhanced_verification_strict === true;
-                // Run pre-execution checks
-                const result = await runPreExecutionChecks(tasks, s.basePath);
+                // Run pre-execution checks against s.basePath — the actual checkout
+                // where prior-slice files were created.  In worktree isolation,
+                // s.canonicalProjectRoot is the project root and lacks files that a
+                // prior slice wrote to the worktree but hasn't merged to main yet.
+                const preExecutionBasePath = s.basePath;
+                const result = await runPreExecutionChecks(tasks, preExecutionBasePath);
                 // Log summary to stderr in existing verification output format
                 const emoji = result.status === "pass" ? "✅" : result.status === "warn" ? "⚠️" : "❌";
                 process.stderr.write(`gsd-pre-exec: ${emoji} Pre-execution checks ${result.status} for ${mid}/${sid} (${result.durationMs}ms)\n`);
@@ -1134,12 +1165,12 @@ export async function postUnitPostVerification(pctx) {
                     process.stderr.write(`gsd-pre-exec:   ${checkEmoji} [${check.category}] ${check.target}: ${check.message}\n`);
                 }
                 // Write evidence JSON to slice artifacts directory
-                const slicePath = resolveSlicePath(s.basePath, mid, sid);
+                const slicePath = resolveSlicePath(preExecutionBasePath, mid, sid);
                 const evidenceFileName = `${sid}-PRE-EXEC-VERIFY.json`;
                 let evidencePath = join(".gsd", "milestones", mid, "slices", sid, evidenceFileName);
                 if (slicePath) {
                     writePreExecutionEvidence(result, slicePath, mid, sid);
-                    evidencePath = relative(s.basePath, join(slicePath, evidenceFileName)) || evidenceFileName;
+                    evidencePath = relative(preExecutionBasePath, join(slicePath, evidenceFileName)) || evidenceFileName;
                 }
                 if (uokFlags.gates) {
                     const failedChecks = result.checks
@@ -1187,6 +1218,9 @@ export async function postUnitPostVerification(pctx) {
                         blockingFindings: blockingChecks.map(c => `[${c.category}] ${c.target}: ${c.message}`),
                         verdictExcerpt: `status=${result.status}; ${blockingCount} blocking issue${blockingCount === 1 ? "" : "s"} detected`,
                     };
+                    // Track consecutive pre-exec failures per slice for loop detection.
+                    const retryKey = currentUnit.id;
+                    s.preExecRetryCount.set(retryKey, (s.preExecRetryCount.get(retryKey) ?? 0) + 1);
                     preExecPauseNeeded = true;
                 }
                 else if (result.status === "warn") {
@@ -1199,9 +1233,16 @@ export async function postUnitPostVerification(pctx) {
                             blockingFindings: warnChecks.map(c => `[${c.category}] ${c.target}: ${c.message}`),
                             verdictExcerpt: `status=${result.status} (strict mode); ${warnChecks.length} warning${warnChecks.length === 1 ? "" : "s"} treated as blocking`,
                         };
+                        const retryKey = currentUnit.id;
+                        s.preExecRetryCount.set(retryKey, (s.preExecRetryCount.get(retryKey) ?? 0) + 1);
                         preExecPauseNeeded = true;
                     }
                 }
+                // Reset the retry counter when checks pass — a successful re-plan
+                // should not carry over a stale failure count into future slices.
+                if (result.status === "pass") {
+                    s.preExecRetryCount.delete(currentUnit.id);
+                }
                 debugLog("postUnitPostVerification", {
                     phase: "pre-execution-checks",
                     status: result.status,
@@ -1253,11 +1294,7 @@ export async function postUnitPostVerification(pctx) {
         }
     }
     // ── Triage check ──
-    if (!s.stepMode &&
-        s.currentUnit &&
-        !s.currentUnit.type.startsWith("hook/") &&
-        s.currentUnit.type !== "triage-captures" &&
-        s.currentUnit.type !== "quick-task") {
+    if (_shouldDispatchTriageForTest(s)) {
         try {
             if (hasPendingCaptures(s.basePath)) {
                 const pending = loadPendingCaptures(s.basePath);
@@ -1295,10 +1332,7 @@ export async function postUnitPostVerification(pctx) {
         }
     }
     // ── Quick-task dispatch ──
-    if (!s.stepMode &&
-        s.pendingQuickTasks.length > 0 &&
-        s.currentUnit &&
-        s.currentUnit.type !== "quick-task") {
+    if (_shouldDispatchQuickTaskForTest(s)) {
         try {
             const capture = s.pendingQuickTasks.shift();
             const { buildQuickTaskPrompt } = await import("./triage-resolution.js");