gsd-pi 2.77.0-dev.c9c8932c6 → 2.77.0-dev.cfd69e714

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -77,20 +77,21 @@ export function clearInFlightTools() {
 }
 // ─── Tool invocation error classification (#2883) ────────────────────────
 /**
- * Patterns that indicate a tool invocation failed due to malformed or truncated
- * JSON arguments — as opposed to a normal business-logic error from the tool
- * handler. When these errors occur, retrying the same unit will produce the same
- * failure, so the retry loop must be broken.
+ * Patterns that indicate a tool invocation failed deterministically before
+ * useful work could be completed — as opposed to a normal business-logic error
+ * from the tool handler. When these errors occur, retrying the same unit will
+ * produce the same failure, so the retry loop must be broken.
  */
 const TOOL_INVOCATION_ERROR_RE = /Validation failed for tool|Expected ',' or '\}'(?: after property value)?(?: in JSON)?|Unexpected end of JSON|Unexpected token.*in JSON/i;
+const DETERMINISTIC_POLICY_ERROR_RE = /(?:^|\b)(?:HARD BLOCK:|Blocked: \/gsd queue is a planning tool|Direct writes to \.gsd\/STATE\.md and \.gsd\/gsd\.db are blocked|This is a mechanical gate)/i;
 /**
- * Returns true if the error message indicates a tool invocation failure due to
- * malformed/truncated arguments (as opposed to a normal tool execution error).
+ * Returns true if the error message indicates a deterministic invocation or
+ * policy failure (as opposed to a normal tool execution error).
  */
 export function isToolInvocationError(errorMsg) {
     if (!errorMsg)
         return false;
-    return TOOL_INVOCATION_ERROR_RE.test(errorMsg);
+    return TOOL_INVOCATION_ERROR_RE.test(errorMsg) || isDeterministicPolicyError(errorMsg);
 }
 /**
  * Returns true if the error message indicates the tool was skipped because
@@ -102,3 +103,42 @@ export function isQueuedUserMessageSkip(errorMsg) {
         return false;
     return /^Skipped due to queued user message\.?$/i.test(errorMsg.trim());
 }
+// ─── Deterministic policy error classification (#4973, #4974) ──────────────
+/**
+ * Known deterministic policy error substrings. Each entry is a stable string
+ * that will appear in the tool error text content when the corresponding
+ * policy gate fires. Retrying these errors will always produce the same outcome.
+ *
+ * Add new entries here as new deterministic gates are introduced. Do NOT use
+ * regex — explicit substrings keep the list auditable.
+ */
+export const DETERMINISTIC_POLICY_ERROR_STRINGS = [
+    // gsd_summary_save write-gate: CONTEXT artifact blocked pending depth verification (#4973).
+    // Matches the fallback text in workflow-tool-executors.ts and the verbose reason
+    // from shouldBlockContextArtifactSaveInSnapshot at write-gate.ts:432-442.
+    "context write blocked",
+    "CONTEXT without depth verification",
+    // Raw write tool gate (#4973): shouldBlockContextWrite at write-gate.ts:390-399 emits
+    // "Cannot write to milestone CONTEXT.md without depth verification." for direct
+    // write tool calls to *-CONTEXT.md paths (different code path than gsd_summary_save).
+    "CONTEXT.md without depth verification",
+];
+/**
+ * Returns true if the error message indicates a deterministic policy gate
+ * blocked the tool call before execution. Retrying the same unit without
+ * changing behavior will hit the same gate, so auto-mode should pause instead
+ * of re-dispatching.
+ *
+ * Combines the regex-based gate set from #4974 (HARD BLOCK / queue planning /
+ * STATE.md / mechanical gate) and the substring-based set from #4973 (context
+ * write block / CONTEXT depth verification). Both branches landed on main
+ * independently and their parallel `isDeterministicPolicyError` declarations
+ * were not deduplicated at merge — this consolidated form preserves both
+ * matchers under a single export.
+ */
+export function isDeterministicPolicyError(errorMsg) {
+    if (!errorMsg)
+        return false;
+    return (DETERMINISTIC_POLICY_ERROR_RE.test(errorMsg) ||
+        DETERMINISTIC_POLICY_ERROR_STRINGS.some(s => errorMsg.includes(s)));
+}

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

@@ -20,9 +20,18 @@ export async function closeoutUnit(ctx, basePath, unitType, unitId, startedAt, o
             const { buildMemoryLLMCall, extractMemoriesFromUnit } = await import('./memory-extractor.js');
             const llmCallFn = buildMemoryLLMCall(ctx);
             if (llmCallFn) {
-                extractMemoriesFromUnit(activityFile, unitType, unitId, llmCallFn).catch((err) => {
+                // Awaited: a fire-and-forget here lets memory-extractor writes land in
+                // .gsd/ after closeoutUnit returns but before the milestone merge
+                // runs, which made the working tree appear dirty to `git merge
+                // --squash` (root cause class of #4704). Completion latency is now
+                // bounded by the extractor's LLM call, which is the acceptable price
+                // for not racing the merge boundary.
+                try {
+                    await extractMemoriesFromUnit(activityFile, unitType, unitId, llmCallFn);
+                }
+                catch (err) {
                     logWarning("engine", `memory extraction failed for ${unitType}/${unitId}: ${err.message}`);
-                });
+                }
             }
         }
         catch (err) { /* non-fatal */

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

@@ -9,7 +9,7 @@ import { existsSync, cpSync, readFileSync, readdirSync, mkdirSync, realpathSync,
 import { isAbsolute, join, sep as pathSep } from "node:path";
 import { homedir } from "node:os";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
-import { reconcileWorktreeDb, isDbAvailable, getMilestone, getMilestoneSlices, } from "./gsd-db.js";
+import { reconcileWorktreeDb, isDbAvailable, getMilestone, getMilestoneSlices, closeDatabase, openDatabase, getDbPath, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { execFileSync } from "node:child_process";
 import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
@@ -45,6 +45,67 @@ const ROOT_STATE_FILES = [
     // Back-sync (worktree → main) must NEVER overwrite the project root's copy
     // because the project root is authoritative for preferences (#2684).
 ];
+/**
+ * Pop a stash entry by tracking the unique marker embedded in its message so
+ * concurrent stash operations against the same project root cannot cause us to
+ * pop the wrong entry.
+ *
+ * If `stashMarker` is null or no longer present in the stash list (e.g. a
+ * concurrent process popped/dropped it), leaves the stash list untouched and
+ * returns null.
+ *
+ * Throws on pop failure so callers can handle conflict cases the same way
+ * they would with the prior `git stash pop` form. When throwing after a
+ * targeted pop attempt, the error is annotated with the targeted stash ref.
+ *
+ * (Issue #4980 HIGH-6)
+ */
+function popStashByRef(basePath, stashMarker) {
+    let popArg = null;
+    if (stashMarker) {
+        try {
+            const list = execFileSync("git", ["stash", "list", "--format=%gd%x00%s"], {
+                cwd: basePath,
+                stdio: ["ignore", "pipe", "pipe"],
+                encoding: "utf-8",
+            }).trim().split("\n").filter(Boolean);
+            for (const entry of list) {
+                const [ref, subject] = entry.split("\0");
+                if (ref && subject?.includes(stashMarker)) {
+                    popArg = ref;
+                    break;
+                }
+            }
+        }
+        catch (err) {
+            logWarning("worktree", `stash list lookup failed; leaving stash untouched: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (!popArg) {
+        logWarning("worktree", "recorded stash entry could not be resolved; skipping automatic pop");
+        return null;
+    }
+    try {
+        execFileSync("git", ["stash", "pop", popArg], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+        });
+    }
+    catch (err) {
+        if (err && typeof err === "object") {
+            err.stashRef = popArg;
+        }
+        throw err;
+    }
+    return popArg;
+}
+function stashRefFromError(err) {
+    if (!err || typeof err !== "object")
+        return null;
+    const stashRef = err.stashRef;
+    return typeof stashRef === "string" && stashRef.length > 0 ? stashRef : null;
+}
 /**
  * Check if two filesystem paths resolve to the same real location.
  * Returns false if either path cannot be resolved (e.g. doesn't exist).
@@ -828,6 +889,27 @@ export function enterBranchModeForMilestone(basePath, milestoneId) {
         const startPoint = integrationBranch ??
             validatedPrefBranch ??
             nativeDetectMainBranch(basePath);
+        // TOCTOU ancestry guard (Issue #4980 HIGH-3).
+        //
+        // The outer `branchExists` check at line 1012 is racy: a concurrent
+        // process (parallel-orchestrator worker, side-by-side `gsd` instance,
+        // or manual `git branch` invocation) may have created the branch with
+        // real commits between that check and this point. `nativeBranchForceReset`
+        // does `git branch -f`, which silently overwrites the branch ref —
+        // orphaning any commits not reachable from `startPoint`. Re-check
+        // immediately before the destructive call and refuse if the branch
+        // suddenly exists with non-ancestor commits.
+        //
+        // Note: under single-threaded execution this is rarely reached, but it
+        // is NOT dead code — it is the only barrier against a TOCTOU-induced
+        // commit loss in this code path.
+        const concurrentlyCreated = nativeBranchExists(basePath, branch);
+        if (concurrentlyCreated &&
+            !nativeIsAncestor(basePath, branch, startPoint)) {
+            throw new GSDError(GSD_GIT_ERROR, `Branch "${branch}" was created concurrently with commits not reachable from "${startPoint}". ` +
+                `Refusing to force-reset — would orphan prior work. ` +
+                `Resume the existing milestone or run \`git branch -D ${branch}\` to discard.`);
+        }
         // nativeBranchForceReset creates (or resets) branch at startPoint,
         // then checkout switches HEAD to it.
         nativeBranchForceReset(basePath, branch, startPoint);
@@ -1345,7 +1427,17 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     clearProjectRootStateFiles(originalBasePath_, milestoneId);
     // 5. Checkout integration branch (skip if already current — avoids git error
     //    when main is already checked out in the project-root worktree, #757)
+    //
+    // Refuse to proceed if the project root is in detached HEAD state. Silently
+    // running `nativeCheckoutBranch(mainBranch)` on a detached HEAD would
+    // abandon the user's deliberately-checked-out commit (mid-bisect, reviewing
+    // a tag, CI checkout-sha) without warning. (Issue #4980 HIGH-10)
     const currentBranchAtBase = nativeGetCurrentBranch(originalBasePath_);
+    if (!currentBranchAtBase || currentBranchAtBase.length === 0) {
+        process.chdir(previousCwd);
+        throw new GSDError(GSD_GIT_ERROR, `Project root is in detached HEAD state — cannot perform milestone merge. ` +
+            `Checkout an integration branch (e.g. \`git checkout ${mainBranch}\`) before resuming.`);
+    }
     if (currentBranchAtBase !== mainBranch) {
         nativeCheckoutBranch(originalBasePath_, mainBranch);
     }
@@ -1433,26 +1525,53 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     const milestonesDir = join(gsdRoot(originalBasePath_), "milestones");
     const shelterDir = join(gsdRoot(originalBasePath_), ".milestone-shelter");
     const shelteredDirs = [];
+    let shelterRestored = false;
     // Helper: restore sheltered milestone directories (#2505).
     // Called on both success and error paths to ensure queued CONTEXT files
-    // are never permanently lost.
+    // are never permanently lost. Idempotent — the error path may fire after
+    // the success path has already restored and removed the shelter dir; a
+    // second call is a no-op instead of logging a misleading "shelter restore
+    // failed: ENOENT" error for shelter sources that were cleaned up legitimately.
     const restoreShelter = () => {
+        if (shelterRestored)
+            return;
+        shelterRestored = true;
         if (shelteredDirs.length === 0)
             return;
+        let restoreFailed = false;
         for (const dirName of shelteredDirs) {
+            const src = join(shelterDir, dirName);
+            // If the shelter source is missing the restore cannot proceed for this
+            // entry. Distinguish "legitimately missing" (shelter dir removed by a
+            // prior successful restore or never copied) from a surprising ENOENT
+            // inside an otherwise-populated shelter.
+            if (!existsSync(src)) {
+                logWarning("worktree", `shelter source missing for ${dirName}; skipping restore (shelter already cleaned or entry never staged)`);
+                continue;
+            }
             try {
                 mkdirSync(milestonesDir, { recursive: true });
-                cpSync(join(shelterDir, dirName), join(milestonesDir, dirName), { recursive: true, force: true });
+                cpSync(src, join(milestonesDir, dirName), { recursive: true, force: true });
             }
             catch (err) { /* best-effort */
-                logError("worktree", `shelter restore failed: ${err instanceof Error ? err.message : String(err)}`);
+                restoreFailed = true;
+                logError("worktree", `shelter restore failed (${dirName}): ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        try {
-            rmSync(shelterDir, { recursive: true, force: true });
+        // Preserve the shelter if any per-entry restore failed — it is the only
+        // surviving copy of the queued milestone dirs (sources were deleted during
+        // shelter). Deleting it here would permanently lose those files (#2505).
+        if (restoreFailed) {
+            logWarning("worktree", `shelter retained at ${shelterDir} — manual recovery required for unrestored entries`);
+            return;
         }
-        catch (err) { /* best-effort */
-            logWarning("worktree", `shelter cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+        if (existsSync(shelterDir)) {
+            try {
+                rmSync(shelterDir, { recursive: true, force: true });
+            }
+            catch (err) { /* best-effort */
+                logWarning("worktree", `shelter cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     };
     try {
@@ -1491,7 +1610,27 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     //     entries (e.g. a gitignored `.gsd` symlink under ADR-002) (#4573).
     //     Queued CONTEXT files under `.gsd/milestones/*` are already sheltered
     //     in step 7 above, so they won't be swept into the stash.
+    // On Windows, SQLite holds mandatory file locks on the gsd.db WAL/SHM
+    // sidecars while the connection is open. `git stash --include-untracked`
+    // walks those files and fails with EBUSY (#4704). Close the DB before
+    // stashing so Windows releases the handles; reopen after. No-op on
+    // POSIX, where advisory locks don't block git.
+    const needsDbCycle = process.platform === "win32" && isDbAvailable();
+    const dbPathToReopen = needsDbCycle ? getDbPath() : null;
+    if (needsDbCycle) {
+        try {
+            closeDatabase();
+        }
+        catch (err) {
+            logWarning("worktree", `pre-stash db close failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     let stashed = false;
+    // Embed a unique marker in the stash message so subsequent pop/drop targets
+    // the entry we created, not whatever happens to be at stash@{0} (concurrent
+    // milestone merges share the project-root stash list and can shift positions).
+    // (Issue #4980 HIGH-6)
+    let stashMarker = null;
     try {
         const status = execFileSync("git", ["status", "--porcelain"], {
             cwd: originalBasePath_,
@@ -1499,7 +1638,8 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             encoding: "utf-8",
         }).trim();
         if (status) {
-            execFileSync("git", ["stash", "push", "--include-untracked", "-m", `gsd: pre-merge stash for ${milestoneId}`], { cwd: originalBasePath_, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
+            stashMarker = `gsd-pre-merge:${milestoneId}:${process.pid}:${Date.now()}:${process.hrtime.bigint().toString(36)}`;
+            execFileSync("git", ["stash", "push", "--include-untracked", "-m", `gsd: pre-merge stash for ${milestoneId} [${stashMarker}]`], { cwd: originalBasePath_, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" });
             stashed = true;
         }
     }
@@ -1508,6 +1648,14 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         // report the dirty tree if it fails.
         logWarning("worktree", `git stash failed: ${err instanceof Error ? err.message : String(err)}`);
     }
+    if (needsDbCycle && dbPathToReopen) {
+        try {
+            openDatabase(dbPathToReopen);
+        }
+        catch (err) {
+            logWarning("worktree", `post-stash db reopen failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
     // 7b. Clean up stale merge state before attempting squash merge (#2912).
     // A leftover MERGE_HEAD (from a previous failed merge, libgit2 native path,
     // or interrupted operation) causes `git merge --squash` to refuse with
@@ -1547,11 +1695,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             // Pop stash before throwing so local work is not lost.
             if (stashed) {
                 try {
-                    execFileSync("git", ["stash", "pop"], {
-                        cwd: originalBasePath_,
-                        stdio: ["ignore", "pipe", "pipe"],
-                        encoding: "utf-8",
-                    });
+                    popStashByRef(originalBasePath_, stashMarker);
                 }
                 catch (err) { /* stash pop conflict is non-fatal */
                     logWarning("worktree", `git stash pop failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -1619,11 +1763,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
                 // Pop stash before throwing so local work is not lost (#2151).
                 if (stashed) {
                     try {
-                        execFileSync("git", ["stash", "pop"], {
-                            cwd: originalBasePath_,
-                            stdio: ["ignore", "pipe", "pipe"],
-                            encoding: "utf-8",
-                        });
+                        popStashByRef(originalBasePath_, stashMarker);
                     }
                     catch (err) { /* stash pop conflict is non-fatal */
                         logWarning("worktree", `git stash pop failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -1666,14 +1806,12 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     // or the commit content.  Conflict on pop is non-fatal — the stash entry is
     // preserved and the user can resolve manually with `git stash pop`.
     if (stashed) {
+        let stashRefForDrop = null;
         try {
-            execFileSync("git", ["stash", "pop"], {
-                cwd: originalBasePath_,
-                stdio: ["ignore", "pipe", "pipe"],
-                encoding: "utf-8",
-            });
+            stashRefForDrop = popStashByRef(originalBasePath_, stashMarker);
         }
         catch (e) {
+            stashRefForDrop = stashRefFromError(e);
             logWarning("worktree", `git stash pop failed, attempting conflict resolution: ${e.message}`);
             // Stash pop after squash merge can conflict on .gsd/ state files that
             // diverged between branches.  Left unresolved, these UU entries block
@@ -1701,25 +1839,33 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
                     }
                 }
             }
-            if (nonGsdUU.length === 0) {
+            if (gsdUU.length > 0 && nonGsdUU.length === 0) {
                 // All conflicts were .gsd/ files — safe to drop the stash
-                try {
-                    execFileSync("git", ["stash", "drop"], {
-                        cwd: originalBasePath_,
-                        stdio: ["ignore", "pipe", "pipe"],
-                        encoding: "utf-8",
-                    });
+                if (stashRefForDrop) {
+                    try {
+                        execFileSync("git", ["stash", "drop", stashRefForDrop], {
+                            cwd: originalBasePath_,
+                            stdio: ["ignore", "pipe", "pipe"],
+                            encoding: "utf-8",
+                        });
+                    }
+                    catch (err) { /* stash may already be consumed */
+                        logWarning("worktree", `git stash drop failed: ${err instanceof Error ? err.message : String(err)}`);
+                    }
                 }
-                catch (err) { /* stash may already be consumed */
-                    logWarning("worktree", `git stash drop failed: ${err instanceof Error ? err.message : String(err)}`);
+                else {
+                    logWarning("worktree", "recorded stash entry could not be resolved; skipping automatic drop");
                 }
             }
-            else {
+            else if (nonGsdUU.length > 0) {
                 // Non-.gsd conflicts remain — leave stash for manual resolution
                 logWarning("reconcile", "Stash pop conflict on non-.gsd files after merge", {
                     files: nonGsdUU.join(", "),
                 });
             }
+            else {
+                logWarning("worktree", "git stash pop failed without resolvable conflict files; leaving stash for manual recovery");
+            }
         }
     }
     // 9a-iii. Restore sheltered queued milestone directories (#2505).

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

@@ -24,9 +24,9 @@ import { acquireSessionLock, getSessionLockStatus, releaseSessionLock, updateSes
 import { resolveAutoSupervisorConfig, loadEffectiveGSDPreferences, getIsolationMode, } from "./preferences.js";
 import { sendDesktopNotification } from "./notifications.js";
 import { getBudgetAlertLevel, getNewBudgetAlertLevel, getBudgetEnforcementAction, } from "./auto-budget.js";
-import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, isQueuedUserMessageSkip, } from "./auto-tool-tracking.js";
+import { markToolStart as _markToolStart, markToolEnd as _markToolEnd, getOldestInFlightToolAgeMs as _getOldestInFlightToolAgeMs, clearInFlightTools, isToolInvocationError, isQueuedUserMessageSkip, isDeterministicPolicyError, } from "./auto-tool-tracking.js";
 import { closeoutUnit } from "./auto-unit-closeout.js";
-import { selectAndApplyModel, resolveModelId } from "./auto-model-selection.js";
+import { selectAndApplyModel, resolveModelId, clearToolBaseline } from "./auto-model-selection.js";
 import { resetRoutingHistory, recordOutcome } from "./routing-history.js";
 import { resetHookState, runPreDispatchHooks, restoreHookState, clearPersistedHookState, } from "./post-unit-hooks.js";
 import { runGSDDoctor, rebuildState } from "./doctor.js";
@@ -51,6 +51,7 @@ import { pruneQueueOrder } from "./queue-order.js";
 import { startCommandPolling as _startCommandPolling, isRemoteConfigured } from "../remote-questions/manager.js";
 import { debugLog, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
 import { reconcileMergeState, } from "./auto-recovery.js";
+import { classifyMilestoneSummaryContent } from "./milestone-summary-classifier.js";
 import { resolveDispatch, DISPATCH_RULES } from "./auto-dispatch.js";
 import { getErrorMessage } from "./error-utils.js";
 import { recoverFailedMigration } from "./migrate-external.js";
@@ -81,7 +82,7 @@ import { WorktreeResolver, } from "./worktree-resolver.js";
 import { reorderForCaching } from "./prompt-ordering.js";
 // ─── Session State ─────────────────────────────────────────────────────────
 import { AutoSession, } from "./auto/session.js";
-export { MAX_UNIT_DISPATCHES, STUB_RECOVERY_THRESHOLD, MAX_LIFETIME_DISPATCHES, NEW_SESSION_TIMEOUT_MS, } from "./auto/session.js";
+export { STUB_RECOVERY_THRESHOLD, NEW_SESSION_TIMEOUT_MS, } from "./auto/session.js";
 // ── ENCAPSULATION INVARIANT ─────────────────────────────────────────────────
 // ALL mutable auto-mode state lives in the AutoSession class (auto/session.ts).
 // This file must NOT declare module-level `let` or `var` variables for state.
@@ -162,6 +163,13 @@ function normalizeSessionFilePath(raw) {
         return null;
     return candidate;
 }
+function synthesizePausedSessionRecovery(basePath, unitType, unitId, sessionFile) {
+    const activityDir = join(gsdRoot(basePath), "activity");
+    return synthesizeCrashRecovery(basePath, unitType, unitId, sessionFile, activityDir);
+}
+export function _synthesizePausedSessionRecoveryForTest(basePath, unitType, unitId, sessionFile) {
+    return synthesizePausedSessionRecovery(basePath, unitType, unitId, sessionFile);
+}
 export function startAutoDetached(ctx, pi, base, verboseMode, options) {
     void startAuto(ctx, pi, base, verboseMode, options).catch((err) => {
         const message = getErrorMessage(err);
@@ -274,6 +282,10 @@ export function getAutoDashboardData() {
 export function isAutoActive() {
     return s.active;
 }
+/** Test-only seam for validating auto-mode guards (#4704). Do not use in production code. */
+export function _setAutoActiveForTest(active) {
+    s.active = active;
+}
 export function isAutoPaused() {
     return s.paused;
 }
@@ -315,13 +327,15 @@ export function markToolEnd(toolCallId) {
 /**
  * Record a tool invocation error on the current session (#2883).
  * Called from tool_execution_end when a GSD tool fails with isError.
- * Only stores the error if it matches the tool-invocation-error pattern
- * (malformed/truncated JSON), not normal business-logic errors.
+ * Stores the error if it matches:
+ *   - tool-invocation-error pattern (malformed/truncated JSON)
+ *   - queued-user-message skip pattern
+ *   - deterministic policy rejection (#4973, e.g. context_write_blocked)
  */
 export function recordToolInvocationError(toolName, errorMsg) {
     if (!s.active)
         return;
-    if (isToolInvocationError(errorMsg) || isQueuedUserMessageSkip(errorMsg)) {
+    if (isToolInvocationError(errorMsg) || isQueuedUserMessageSkip(errorMsg) || isDeterministicPolicyError(errorMsg)) {
         s.lastToolInvocationError = `${toolName}: ${errorMsg}`;
     }
 }
@@ -523,6 +537,40 @@ export async function stopAuto(ctx, pi, reason) {
         return;
     const loadedPreferences = loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences;
     const reasonSuffix = reason ? ` — ${reason}` : "";
+    // #4764 — telemetry: record the exit reason and whether the current milestone
+    // was merged before we entered stopAuto. This is the producer-side signal for
+    // the #4761 orphan class: milestoneMerged=false + currentMilestoneId present
+    // is exactly the pattern that strands work.
+    try {
+        const { emitAutoExit } = await import("./worktree-telemetry.js");
+        // Normalize the free-form reason to a closed set so the telemetry
+        // aggregator buckets stably. Raw detail is preserved in the phases.ts
+        // notification and the notify'd error string.
+        const rawReason = reason ?? "stop";
+        const normalizedReason = rawReason.startsWith("Blocked:")
+            ? "blocked"
+            : rawReason.startsWith("Merge conflict")
+                ? "merge-conflict"
+                : rawReason.startsWith("Merge error") || rawReason.startsWith("Merge failed")
+                    ? "merge-failed"
+                    : rawReason.startsWith("slice-merge-conflict")
+                        ? "slice-merge-conflict"
+                        : rawReason === "All milestones complete"
+                            ? "all-complete"
+                            : rawReason === "No active milestone"
+                                ? "no-active-milestone"
+                                : rawReason === "stop" || rawReason === "pause"
+                                    ? rawReason
+                                    : "other";
+        emitAutoExit(s.originalBasePath || s.basePath, {
+            reason: normalizedReason,
+            milestoneId: s.currentMilestoneId ?? undefined,
+            milestoneMerged: s.milestoneMergedInPhases === true,
+        });
+    }
+    catch (err) {
+        logWarning("engine", `auto-exit telemetry failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     try {
         // ── Step 1: Timers and locks ──
         try {
@@ -774,6 +822,12 @@ export async function stopAuto(ctx, pi, reason) {
             initHealthWidget(ctx);
         restoreProjectRootEnv();
         restoreMilestoneLockEnv();
+        // Drop the active-tool baseline so a subsequent /gsd auto run on the
+        // same `pi` instance recaptures from the live tool set rather than
+        // restoring this session's snapshot and silently undoing any tool
+        // changes the user made between sessions (#4959 / CodeRabbit).
+        if (pi)
+            clearToolBaseline(pi);
         // Reset all session state in one call
         s.reset();
     }
@@ -1021,6 +1075,15 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         debugLog("startAuto", { phase: "already-active", skipping: true });
         return;
     }
+    // On a *fresh* start, drop any stale active-tool baseline left by a prior
+    // auto session that didn't run stopAuto cleanly.  Skip on resume: pauseAuto
+    // leaves the last provider-trimmed active tools in place, so clearing here
+    // would let the next selectAndApplyModel recapture that already-narrowed
+    // set as the new baseline — exactly the cross-unit poisoning this PR is
+    // fixing (#4959 / CodeRabbit Major).  The pre-pause baseline survives in
+    // the WeakMap keyed by `pi`.
+    if (!s.paused)
+        clearToolBaseline(pi);
     const requestedStepMode = options?.step ?? false;
     const interruptedAssessment = options?.interrupted ?? null;
     if (options?.milestoneLock !== undefined) {
@@ -1080,7 +1143,16 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                     // Validate the milestone still exists and isn't already complete (#1664).
                     const mDir = resolveMilestonePath(base, meta.milestoneId);
                     const summaryFile = resolveMilestoneFile(base, meta.milestoneId, "SUMMARY");
-                    if (!mDir || summaryFile) {
+                    let summaryIsTerminal = false;
+                    if (summaryFile) {
+                        try {
+                            summaryIsTerminal = classifyMilestoneSummaryContent(readFileSync(summaryFile, "utf-8")) !== "failure";
+                        }
+                        catch {
+                            summaryIsTerminal = false;
+                        }
+                    }
+                    if (!mDir || summaryIsTerminal) {
                         try {
                             unlinkSync(pausedPath);
                         }
@@ -1169,18 +1241,6 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             ctx.ui.notify(`Cannot resume: ${resumeLock.reason}`, "error");
             return;
         }
-        // Lock acquired — now safe to delete the pause file
-        if (s.pausedSessionFile) {
-            try {
-                unlinkSync(s.pausedSessionFile);
-            }
-            catch (err) {
-                if (err.code !== "ENOENT") {
-                    logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-                }
-            }
-            s.pausedSessionFile = null;
-        }
         s.paused = false;
         s.active = true;
         s.verbose = verboseMode;
@@ -1269,8 +1329,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         }
         invalidateAllCaches();
         if (s.pausedSessionFile) {
-            const activityDir = join(gsdRoot(s.basePath), "activity");
-            const recovery = synthesizeCrashRecovery(s.basePath, s.currentUnit?.type ?? s.pausedUnitType ?? "unknown", s.currentUnit?.id ?? s.pausedUnitId ?? "unknown", s.pausedSessionFile ?? undefined, activityDir);
+            const recovery = synthesizePausedSessionRecovery(s.basePath, s.currentUnit?.type ?? s.pausedUnitType ?? "unknown", s.currentUnit?.id ?? s.pausedUnitId ?? "unknown", s.pausedSessionFile);
             if (recovery && recovery.trace.toolCallCount > 0) {
                 s.pendingCrashRecovery = recovery.prompt;
                 ctx.ui.notify(`Recovered ${recovery.trace.toolCallCount} tool calls from paused session. Resuming with context.`, "info");

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

@@ -1,5 +1,6 @@
 import { logWarning } from "../workflow-logger.js";
 import { checkAutoStartAfterDiscuss, maybeHandleReadyPhraseWithoutFiles, maybeHandleEmptyIntentTurn, resetEmptyTurnCounter, } from "../guided-flow.js";
+import { clearPathCache } from "../paths.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto, setCurrentDispatchedModelId } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
@@ -11,7 +12,15 @@ import { classifyError, createRetryState, resetRetryState, isTransient, } from "
 import { blockModel, isModelBlocked } from "../blocked-models.js";
 const retryState = createRetryState();
 const MAX_NETWORK_RETRIES = 2;
-const MAX_TRANSIENT_AUTO_RESUMES = 8;
+/**
+ * Cap on auto-resume attempts for sustained transient-provider errors.
+ *
+ * Exported so tests assert against the shared constant instead of
+ * regex-scraping the source literal (see #4837). Raising this value to
+ * handle longer provider overloads should update the single constant; the
+ * test in provider-errors.test.ts consumes it directly.
+ */
+export const MAX_TRANSIENT_AUTO_RESUMES = 8;
 /**
  * Reset the module-level retry state so a resumed auto-session starts fresh.
  * Called by provider-error-resume.ts before startAuto() — without this, the
@@ -49,6 +58,15 @@ async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit)
     });
 }
 export async function handleAgentEnd(pi, event, ctx) {
+    // #4648 — Invalidate the directory-listing cache before any artifact-existence
+    // checks. The LLM may have written milestone files (CONTEXT.md, ROADMAP.md,
+    // PROJECT.md, REQUIREMENTS.md) via tool calls during the turn that just
+    // ended. `paths.ts` caches readdir() results without a TTL, so without this
+    // flush, `resolveMilestoneFile` returns the pre-write listing and the guards
+    // below (`checkAutoStartAfterDiscuss` and `maybeHandleReadyPhraseWithoutFiles`)
+    // falsely report files as missing — producing a spurious "ready signal
+    // rejected" loop even though the files are on disk.
+    clearPathCache();
     if (checkAutoStartAfterDiscuss()) {
         clearDiscussionFlowState();
         return;