gsd-pi 2.78.1-dev.b6a389b66 → 2.78.1-dev.d8826a445

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

@@ -1 +1 @@
-cc8431019a2c8873
+3cb2810818585c65

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

@@ -12,7 +12,7 @@ import { MAX_RECOVERY_CHARS, BUDGET_THRESHOLDS, MAX_FINALIZE_TIMEOUTS, } from ".
 import { detectStuck } from "./detect-stuck.js";
 import { runUnit } from "./run-unit.js";
 import { debugLog } from "../debug-logger.js";
-import { resolveWorktreeProjectRoot } from "../worktree-root.js";
+import { resolveWorktreeProjectRoot, normalizeWorktreePathForCompare } from "../worktree-root.js";
 import { PROJECT_FILES, hasProjectFileInAncestor } from "../detection.js";
 import { MergeConflictError } from "../git-service.js";
 import { setCurrentPhase, clearCurrentPhase } from "../../shared/gsd-phase-state.js";
@@ -37,6 +37,11 @@ import { parseUnitId } from "../unit-id.js";
 import { createCheckpoint, cleanupCheckpoint, rollbackToCheckpoint } from "../safety/git-checkpoint.js";
 import { resolveSafetyHarnessConfig } from "../safety/safety-harness.js";
 import { getWorkflowTransportSupportError, getRequiredWorkflowToolsForAutoUnit, supportsStructuredQuestions, } from "../workflow-mcp.js";
+// ─── Path Comparison Helper ───────────────────────────────────────────────
+/** Compare two paths for physical identity, tolerating trailing slashes and symlinks. */
+function isSamePathLocal(a, b) {
+    return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
+}
 // ─── Session timeout auto-resume state ────────────────────────────────────────
 let consecutiveSessionTimeouts = 0;
 const MAX_SESSION_TIMEOUT_AUTO_RESUMES = 3;
@@ -280,7 +285,7 @@ export async function runPreDispatch(ic, loopState) {
     }
     // Sync project root artifacts into worktree
     if (s.originalBasePath &&
-        s.basePath !== s.originalBasePath &&
+        !isSamePathLocal(s.basePath, s.originalBasePath) &&
         s.currentMilestoneId) {
         deps.syncProjectRootToWorktree(s.originalBasePath, s.basePath, s.currentMilestoneId);
     }

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

@@ -32,6 +32,8 @@ export class AutoSession {
     // ── Paths ────────────────────────────────────────────────────────────────
     basePath = "";
     originalBasePath = "";
+    // TODO(C8): remove basePath/originalBasePath once all readers use s.scope
+    scope = null;
     previousProjectRootEnv = null;
     hadProjectRootEnv = false;
     projectRootEnvCaptured = false;
@@ -173,6 +175,7 @@ export class AutoSession {
         // Paths
         this.basePath = "";
         this.originalBasePath = "";
+        this.scope = null;
         this.previousProjectRootEnv = null;
         this.hadProjectRootEnv = false;
         this.projectRootEnvCaptured = false;

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

@@ -31,6 +31,7 @@ import { ensureWorkflowPreferencesCaptured } from "./planning-depth.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { PROJECT_RESEARCH_INFLIGHT_MARKER, } from "./project-research-policy.js";
 import { isWorkflowPrefsCaptured, resolveDeepProjectSetupState, } from "./deep-project-setup-policy.js";
+import { annotateBackgroundable } from "./delegation-policy.js";
 let reassessmentChecker = checkNeedsReassessment;
 let researchProjectPromptBuilder = buildResearchProjectPrompt;
 function shouldBypassMilestoneDepthGateInAuto(prefs) {
@@ -1152,7 +1153,7 @@ export async function resolveDispatch(ctx) {
     // Delegate to registry when available
     try {
         const registry = getRegistry();
-        return await registry.evaluateDispatch(ctx);
+        return annotateBackgroundable(await registry.evaluateDispatch(ctx));
     }
     catch (err) {
         // Registry not initialized — fall back to inline loop
@@ -1163,7 +1164,7 @@ export async function resolveDispatch(ctx) {
         if (result) {
             if (result.action !== "skip")
                 result.matchedRule = rule.name;
-            return result;
+            return annotateBackgroundable(result);
         }
     }
     // No rule matched — unhandled phase.

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

@@ -24,6 +24,7 @@ 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 { normalizeWorktreePathForCompare } from "./worktree-root.js";
 import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
 import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
@@ -51,6 +52,11 @@ import { detectAbandonMilestone } from "./abandon-detect.js";
 import { isDeterministicPolicyError } from "./auto-tool-tracking.js";
 import { clearProjectResearchInflightMarker, finalizeProjectResearchTimeout, } from "./project-research-policy.js";
 import { validateArtifact } from "./schemas/validate.js";
+// ─── Path Comparison Helper ───────────────────────────────────────────────
+/** Compare two paths for physical identity, tolerating trailing slashes and symlinks. */
+function isSamePathLocal(a, b) {
+    return normalizeWorktreePathForCompare(a) === normalizeWorktreePathForCompare(b);
+}
 /** Maximum verification retry attempts before escalating to blocker placeholder (#2653). */
 const MAX_VERIFICATION_RETRIES = 3;
 /** Keep failure toasts short while still showing concrete examples. */
@@ -510,7 +516,7 @@ export async function postUnitPreVerification(pctx, opts) {
             await rebuildState(s.basePath);
         });
         // Sync worktree state back to project root (skipped for lightweight sidecars)
-        if (!opts?.skipWorktreeSync && s.originalBasePath && s.originalBasePath !== s.basePath) {
+        if (!opts?.skipWorktreeSync && s.originalBasePath && !isSamePathLocal(s.originalBasePath, s.basePath)) {
             await runSafely("postUnit", "worktree-sync", () => {
                 syncStateToProjectRoot(s.basePath, s.originalBasePath, s.currentMilestoneId);
             });

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

@@ -23,6 +23,7 @@ import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchForceReset, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, nativeMergeAbort, } from "./native-git-bridge.js";
 import { gsdHome } from "./gsd-home.js";
+import { createWorkspace } from "./workspace.js";
 const PROJECT_PREFERENCES_FILE = "PREFERENCES.md";
 const LEGACY_PROJECT_PREFERENCES_FILE = "preferences.md";
 const LEGACY_DEEP_SETUP_RUNTIME_UNIT_FILES = new Set([
@@ -195,8 +196,14 @@ function forceOverwriteAssessmentsWithVerdict(srcMilestoneDir, dstMilestoneDir)
     }
 }
 // ─── Module State ──────────────────────────────────────────────────────────
-/** Original project root before chdir into auto-worktree. */
-let originalBase = null;
+/** Active workspace registry — replaces the legacy `originalBase` singleton. */
+let activeWorkspace = null;
+function setActiveWorkspace(ws) {
+    activeWorkspace = ws;
+}
+function getActiveWorkspace() {
+    return activeWorkspace;
+}
 function clearProjectRootStateFiles(basePath, milestoneId) {
     const gsdDir = gsdRoot(basePath);
     const transientFiles = [
@@ -275,6 +282,33 @@ export const isSafeToAutoResolve = (filePath) => filePath.startsWith(".gsd/") ||
  * gsd.db in the worktree so it rebuilds from fresh disk state (#853).
  * Non-fatal — sync failure should never block dispatch.
  */
+/**
+ * Scope-typed variant of syncProjectRootToWorktree.
+ *
+ * Takes an explicit (rootScope, worktreeScope) pair where rootScope is the
+ * project root and worktreeScope is the auto-worktree. Direction is encoded
+ * in argument order. Asserts both scopes belong to the same workspace identity
+ * to prevent silent mismatch bugs.
+ */
+export function syncProjectRootToWorktreeByScope(rootScope, worktreeScope) {
+    if (rootScope.workspace.identityKey !== worktreeScope.workspace.identityKey) {
+        throw new Error(`syncProjectRootToWorktreeByScope: scope identity mismatch — ` +
+            `rootScope.identityKey="${rootScope.workspace.identityKey}" ` +
+            `worktreeScope.identityKey="${worktreeScope.workspace.identityKey}"`);
+    }
+    if (rootScope.milestoneId !== worktreeScope.milestoneId) {
+        throw new Error(`syncProjectRootToWorktreeByScope: milestoneId mismatch — ` +
+            `rootScope.milestoneId="${rootScope.milestoneId}" worktreeScope.milestoneId="${worktreeScope.milestoneId}"`);
+    }
+    const projectRoot = rootScope.workspace.projectRoot;
+    const worktreePath_ = worktreeScope.workspace.worktreeRoot ?? worktreeScope.workspace.projectRoot;
+    const milestoneId = rootScope.milestoneId;
+    syncProjectRootToWorktree(projectRoot, worktreePath_, milestoneId);
+}
+/**
+ * @deprecated Use syncProjectRootToWorktreeByScope instead.
+ * TODO(C-future): remove once all callers migrated.
+ */
 export function syncProjectRootToWorktree(projectRoot, worktreePath_, milestoneId) {
     if (!worktreePath_ || !projectRoot || worktreePath_ === projectRoot)
         return;
@@ -343,12 +377,36 @@ export function syncProjectRootToWorktree(projectRoot, worktreePath_, milestoneI
         logWarning("worktree", `worktree DB cleanup failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
+/**
+ * Scope-typed variant of syncStateToProjectRoot.
+ *
+ * Takes an explicit (worktreeScope, rootScope) pair. Direction is encoded in
+ * argument order (worktree → root). Asserts both scopes belong to the same
+ * workspace identity to prevent silent mismatch bugs.
+ */
+export function syncStateToProjectRootByScope(worktreeScope, rootScope) {
+    if (worktreeScope.workspace.identityKey !== rootScope.workspace.identityKey) {
+        throw new Error(`syncStateToProjectRootByScope: scope identity mismatch — ` +
+            `worktreeScope.identityKey="${worktreeScope.workspace.identityKey}" ` +
+            `rootScope.identityKey="${rootScope.workspace.identityKey}"`);
+    }
+    if (worktreeScope.milestoneId !== rootScope.milestoneId) {
+        throw new Error(`syncStateToProjectRootByScope: milestoneId mismatch — ` +
+            `worktreeScope.milestoneId="${worktreeScope.milestoneId}" rootScope.milestoneId="${rootScope.milestoneId}"`);
+    }
+    const worktreePath_ = worktreeScope.workspace.worktreeRoot ?? worktreeScope.workspace.projectRoot;
+    const projectRoot = rootScope.workspace.projectRoot;
+    const milestoneId = worktreeScope.milestoneId;
+    syncStateToProjectRoot(worktreePath_, projectRoot, milestoneId);
+}
 /**
  * Sync worktree diagnostics from worktree to project root.
  * Only runs when inside an auto-worktree (worktreePath differs from projectRoot).
  * DB/project-root state remains authoritative; markdown projections are not
  * copied from the worktree back to the project root.
  * Non-fatal — sync failure should never block dispatch.
+ * @deprecated Use syncStateToProjectRootByScope instead.
+ * TODO(C-future): remove once all callers migrated.
  */
 export function syncStateToProjectRoot(worktreePath_, projectRoot, milestoneId) {
     if (!worktreePath_ || !projectRoot || worktreePath_ === projectRoot)
@@ -520,6 +578,24 @@ export function cleanStaleRuntimeUnits(gsdRootPath, hasMilestoneSummary) {
     return cleaned;
 }
 // ─── Worktree ↔ Main Repo Sync (#1311) ──────────────────────────────────────
+/**
+ * Scope-typed variant of syncGsdStateToWorktree.
+ *
+ * Takes an explicit (rootScope, worktreeScope) pair. Note: milestoneId is not
+ * used by syncGsdStateToWorktree — this variant only requires workspace
+ * identity. Asserts both scopes belong to the same workspace identity to
+ * prevent silent mismatch bugs.
+ */
+export function syncGsdStateToWorktreeByScope(rootScope, worktreeScope) {
+    if (rootScope.workspace.identityKey !== worktreeScope.workspace.identityKey) {
+        throw new Error(`syncGsdStateToWorktreeByScope: scope identity mismatch — ` +
+            `rootScope.identityKey="${rootScope.workspace.identityKey}" ` +
+            `worktreeScope.identityKey="${worktreeScope.workspace.identityKey}"`);
+    }
+    const mainBasePath = rootScope.workspace.projectRoot;
+    const worktreePath_ = worktreeScope.workspace.worktreeRoot ?? worktreeScope.workspace.projectRoot;
+    return syncGsdStateToWorktree(mainBasePath, worktreePath_);
+}
 /**
  * Sync .gsd/ state from the main repo into the worktree.
  *
@@ -534,6 +610,8 @@ export function cleanStaleRuntimeUnits(gsdRootPath, hasMilestoneSummary) {
  * Only adds missing content — never overwrites existing files in the worktree.
  * Worktree files are compatibility projections; DB/project root remains
  * authoritative for runtime state.
+ * @deprecated Use syncGsdStateToWorktreeByScope instead.
+ * TODO(C-future): remove once all callers migrated.
  */
 export function syncGsdStateToWorktree(mainBasePath, worktreePath_) {
     const contract = resolveGsdPathContract(worktreePath_, mainBasePath);
@@ -906,6 +984,32 @@ export function enterBranchModeForMilestone(basePath, milestoneId) {
  * remains authoritative; this never downgrades checked boxes in a local
  * worktree projection.
  */
+/**
+ * Scope-typed variant of reconcilePlanCheckboxes.
+ *
+ * Takes an explicit (rootScope, worktreeScope) pair. milestoneId is taken
+ * from rootScope. Asserts both scopes belong to the same workspace identity
+ * to prevent silent mismatch bugs.
+ */
+export function reconcilePlanCheckboxesByScope(rootScope, worktreeScope) {
+    if (rootScope.workspace.identityKey !== worktreeScope.workspace.identityKey) {
+        throw new Error(`reconcilePlanCheckboxesByScope: scope identity mismatch — ` +
+            `rootScope.identityKey="${rootScope.workspace.identityKey}" ` +
+            `worktreeScope.identityKey="${worktreeScope.workspace.identityKey}"`);
+    }
+    if (rootScope.milestoneId !== worktreeScope.milestoneId) {
+        throw new Error(`reconcilePlanCheckboxesByScope: milestoneId mismatch — ` +
+            `rootScope.milestoneId="${rootScope.milestoneId}" worktreeScope.milestoneId="${worktreeScope.milestoneId}"`);
+    }
+    const projectRoot = rootScope.workspace.projectRoot;
+    const wtPath = worktreeScope.workspace.worktreeRoot ?? worktreeScope.workspace.projectRoot;
+    const milestoneId = rootScope.milestoneId;
+    reconcilePlanCheckboxes(projectRoot, wtPath, milestoneId);
+}
+/**
+ * @deprecated Use reconcilePlanCheckboxesByScope instead.
+ * TODO(C-future): remove once all callers migrated.
+ */
 function reconcilePlanCheckboxes(projectRoot, wtPath, milestoneId) {
     const srcMilestone = join(projectRoot, ".gsd", "milestones", milestoneId);
     const dstMilestone = join(wtPath, ".gsd", "milestones", milestoneId);
@@ -1059,11 +1163,11 @@ export function createAutoWorktree(basePath, milestoneId) {
     const previousCwd = process.cwd();
     try {
         process.chdir(info.path);
-        originalBase = basePath;
+        setActiveWorkspace(createWorkspace(basePath));
     }
     catch (err) {
         // If chdir fails, the worktree was created but we couldn't enter it.
-        // Don't store originalBase -- caller can retry or clean up.
+        // Don't set activeWorkspace -- caller can retry or clean up.
         throw new GSDError(GSD_IO_ERROR, `Auto-worktree created at ${info.path} but chdir failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     nudgeGitBranchCache(previousCwd);
@@ -1123,41 +1227,79 @@ export function teardownAutoWorktree(originalBasePath, milestoneId, opts = {}) {
     const branch = autoWorktreeBranch(milestoneId);
     const { preserveBranch = false } = opts;
     const previousCwd = process.cwd();
+    // Wrap the entire teardown body in a single try/finally so activeWorkspace
+    // is ALWAYS cleared — even if process.chdir throws (e.g. originalBasePath
+    // was deleted before teardown ran). Previously the finally only covered
+    // removeWorktree, leaving the registry stale on a chdir failure (H3 fix).
     try {
-        process.chdir(originalBasePath);
-        originalBase = null;
-    }
-    catch (err) {
-        throw new GSDError(GSD_IO_ERROR, `Failed to chdir back to ${originalBasePath} during teardown: ${err instanceof Error ? err.message : String(err)}`);
-    }
-    nudgeGitBranchCache(previousCwd);
-    removeWorktree(originalBasePath, milestoneId, {
-        branch,
-        deleteBranch: !preserveBranch,
-    });
-    // Verify cleanup succeeded — warn if the worktree directory is still on disk.
-    // On Windows, bash-based cleanup can silently fail when paths contain
-    // backslashes (#1436), leaving ~1 GB+ orphaned directories.
-    const wtDir = worktreePath(originalBasePath, milestoneId);
-    if (existsSync(wtDir)) {
-        logWarning("reconcile", `Worktree directory still exists after teardown: ${wtDir}. ` +
-            `This is likely an orphaned directory consuming disk space. ` +
-            `Remove it manually with: rm -rf "${wtDir.replaceAll("\\", "/")}"`, { worktree: milestoneId });
-        // Attempt a direct filesystem removal as a fallback — but ONLY if the
-        // path is safely inside .gsd/worktrees/ to prevent #2365 data loss.
-        if (isInsideWorktreesDir(originalBasePath, wtDir)) {
+        try {
+            process.chdir(originalBasePath);
+        }
+        catch (err) {
+            throw new GSDError(GSD_IO_ERROR, `Failed to chdir back to ${originalBasePath} during teardown: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        // Mirror cleanup steps from mergeMilestoneToMain abort path:
+        // 1. Remove transient state files (STATE.md, auto.lock, {MID}-META.json).
+        //    Non-fatal — must not block teardown.
+        try {
+            clearProjectRootStateFiles(originalBasePath, milestoneId);
+        }
+        catch (err) {
+            logWarning("worktree", `clearProjectRootStateFiles failed during teardown: ${err instanceof Error ? err.message : String(err)}`);
+        }
+        // 2. Reconcile worktree-local gsd.db into project root DB if both exist.
+        //    Non-fatal — handles legacy worktrees that have a local copy.
+        if (isDbAvailable()) {
             try {
-                rmSync(wtDir, { recursive: true, force: true });
+                const contract = resolveGsdPathContract(previousCwd, originalBasePath);
+                const worktreeDbPath = join(contract.worktreeGsd ?? join(previousCwd, ".gsd"), "gsd.db");
+                const mainDbPath = contract.projectDb;
+                if (existsSync(worktreeDbPath) && !isSamePath(worktreeDbPath, mainDbPath)) {
+                    reconcileWorktreeDb(mainDbPath, worktreeDbPath);
+                }
             }
             catch (err) {
-                // Non-fatal — the warning above tells the user how to clean up
-                logWarning("worktree", `worktree directory removal failed: ${err instanceof Error ? err.message : String(err)}`);
+                /* non-fatal */
+                logError("worktree", `DB reconciliation failed during teardown: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
-        else {
-            console.error(`[GSD] REFUSING fallback rmSync — path is outside .gsd/worktrees/: ${wtDir}`);
+        nudgeGitBranchCache(previousCwd);
+        // 3. Remove the worktree. Errors propagate naturally — the outer finally
+        //    ensures activeWorkspace is cleared regardless.
+        removeWorktree(originalBasePath, milestoneId, {
+            branch,
+            deleteBranch: !preserveBranch,
+        });
+        // Verify cleanup succeeded — warn if the worktree directory is still on disk.
+        // On Windows, bash-based cleanup can silently fail when paths contain
+        // backslashes (#1436), leaving ~1 GB+ orphaned directories.
+        const wtDir = worktreePath(originalBasePath, milestoneId);
+        if (existsSync(wtDir)) {
+            logWarning("reconcile", `Worktree directory still exists after teardown: ${wtDir}. ` +
+                `This is likely an orphaned directory consuming disk space. ` +
+                `Remove it manually with: rm -rf "${wtDir.replaceAll("\\", "/")}"`, { worktree: milestoneId });
+            // Attempt a direct filesystem removal as a fallback — but ONLY if the
+            // path is safely inside .gsd/worktrees/ to prevent #2365 data loss.
+            if (isInsideWorktreesDir(originalBasePath, wtDir)) {
+                try {
+                    rmSync(wtDir, { recursive: true, force: true });
+                }
+                catch (err) {
+                    // Non-fatal — the warning above tells the user how to clean up
+                    logWarning("worktree", `worktree directory removal failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
+            }
+            else {
+                console.error(`[GSD] REFUSING fallback rmSync — path is outside .gsd/worktrees/: ${wtDir}`);
+            }
         }
     }
+    finally {
+        // Clear module state unconditionally — regardless of which step above
+        // failed. A stale activeWorkspace causes getActiveAutoWorktreeContext()
+        // to return wrong data for subsequent operations.
+        setActiveWorkspace(null);
+    }
 }
 /**
  * Detect if the process is currently inside an auto-worktree.
@@ -1168,8 +1310,9 @@ export function isInAutoWorktree(basePath) {
     const targetPath = isGsdWorktreePath(basePath) ? basePath : process.cwd();
     if (!isGsdWorktreePath(targetPath))
         return false;
-    const projectRoot = resolveWorktreeProjectRoot(basePath, originalBase);
-    const targetProjectRoot = resolveWorktreeProjectRoot(targetPath, originalBase);
+    const storedBase = getAutoWorktreeOriginalBase();
+    const projectRoot = resolveWorktreeProjectRoot(basePath, storedBase);
+    const targetProjectRoot = resolveWorktreeProjectRoot(targetPath, storedBase);
     if (normalizeWorktreePathForCompare(projectRoot) !==
         normalizeWorktreePathForCompare(targetProjectRoot)) {
         return false;
@@ -1242,7 +1385,7 @@ export function enterAutoWorktree(basePath, milestoneId) {
     const previousCwd = process.cwd();
     try {
         process.chdir(p);
-        originalBase = basePath;
+        setActiveWorkspace(createWorkspace(basePath));
     }
     catch (err) {
         throw new GSDError(GSD_IO_ERROR, `Failed to enter auto-worktree at ${p}: ${err instanceof Error ? err.message : String(err)}`);
@@ -1255,14 +1398,16 @@ export function enterAutoWorktree(basePath, milestoneId) {
  * Returns null if not currently in an auto-worktree.
  */
 export function getAutoWorktreeOriginalBase() {
-    return originalBase;
+    return getActiveWorkspace()?.projectRoot ?? null;
 }
 export function _resetAutoWorktreeOriginalBaseForTests() {
-    originalBase = null;
+    setActiveWorkspace(null);
 }
 export function getActiveAutoWorktreeContext() {
-    if (!originalBase)
+    const ws = getActiveWorkspace();
+    if (!ws)
         return null;
+    const originalBase = ws.projectRoot;
     const cwd = process.cwd();
     if (!isGsdWorktreePath(cwd))
         return null;
@@ -1332,11 +1477,11 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     //    integration branch captures dirty files from OTHER milestones under a
     //    misleading commit message, contaminating the main branch (#2929).
     //
-    //    When originalBase is null (branch mode, no worktree), autoCommitDirtyState
+    //    When activeWorkspace is null (branch mode, no worktree), autoCommitDirtyState
     //    runs unconditionally — the caller is responsible for cwd placement.
     {
         let shouldAutoCommit = true;
-        if (originalBase !== null) {
+        if (getActiveWorkspace() !== null) {
             try {
                 const currentBranch = nativeGetCurrentBranch(worktreeCwd);
                 shouldAutoCommit = currentBranch === milestoneBranch;
@@ -2020,7 +2165,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
         logWarning("worktree", `git branch-delete failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     // 14. Clear module state
-    originalBase = null;
+    setActiveWorkspace(null);
     nudgeGitBranchCache(previousCwd);
     // 15. Anchor cwd at the project root on success-return. Step 12 removed
     // the worktree dir; if cwd was inside it, every subsequent process.cwd()

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

@@ -86,6 +86,7 @@ import { reorderForCaching } from "./prompt-ordering.js";
 export { STUB_RECOVERY_THRESHOLD, NEW_SESSION_TIMEOUT_MS, } from "./auto/session.js";
 import { autoSession as s } from "./auto-runtime-state.js";
 import { gsdHome } from "./gsd-home.js";
+import { createWorkspace, scopeMilestone } from "./workspace.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.
@@ -147,6 +148,32 @@ function restoreMilestoneLockEnv() {
     s.hadMilestoneLockEnv = false;
     s.milestoneLockEnvCaptured = false;
 }
+/**
+ * Rebuild s.scope from the current s.basePath / s.originalBasePath / s.currentMilestoneId.
+ *
+ * Pass the worktree path as rawPath when entering a worktree so createWorkspace
+ * can detect the worktree layout and set mode="worktree". When no worktree is
+ * active, rawPath should equal the project root.
+ *
+ * Clears s.scope when milestoneId is absent — scope is only meaningful when a
+ * milestone is active.
+ *
+ * TODO(C8): remove basePath/originalBasePath once all readers use s.scope.
+ */
+function rebuildScope(rawPath, milestoneId) {
+    if (!milestoneId) {
+        s.scope = null;
+        return;
+    }
+    try {
+        const workspace = createWorkspace(rawPath);
+        s.scope = scopeMilestone(workspace, milestoneId);
+    }
+    catch {
+        // Non-fatal — scope is additive. Existing readers still use basePath.
+        s.scope = null;
+    }
+}
 function normalizeSessionFilePath(raw) {
     if (typeof raw !== "string")
         return null;
@@ -284,6 +311,18 @@ export function isAutoActive() {
 export function _setAutoActiveForTest(active) {
     s.active = active;
 }
+/**
+ * Test-only seam: emit the missing-worktree warning exactly as the resume path
+ * does.  Allows unit tests to verify the warning is produced without
+ * bootstrapping the full auto-mode entry point.  Do not use in production code.
+ */
+export function _warnIfWorktreeMissingForTest(worktreePath, milestoneId) {
+    if (worktreePath && !existsSync(worktreePath)) {
+        logWarning("session", `Worktree was expected at ${worktreePath} but is missing. Continuing in project-root mode. To restart with a fresh worktree, run /gsd-debug or recreate the milestone.`, { file: "auto.ts", milestoneId });
+        return true;
+    }
+    return false;
+}
 export function isAutoPaused() {
     return s.paused;
 }
@@ -1204,6 +1243,18 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         s.autoStartTime = meta.autoStartTime || Date.now();
                         s.sessionMilestoneLock = meta.milestoneLock ?? null;
                         s.paused = true;
+                        // Build scope from persisted state. Use worktreePath when present and
+                        // still on disk so mode is detected correctly; fall back to project root.
+                        {
+                            const persistedWorktreePath = meta.worktreePath ?? null;
+                            if (persistedWorktreePath && !existsSync(persistedWorktreePath)) {
+                                logWarning("session", `Worktree was expected at ${persistedWorktreePath} but is missing. Continuing in project-root mode. To restart with a fresh worktree, run /gsd-debug or recreate the milestone.`, { file: "auto.ts", milestoneId: meta.milestoneId ?? "" });
+                            }
+                            const rawForScope = (persistedWorktreePath && existsSync(persistedWorktreePath))
+                                ? persistedWorktreePath
+                                : (s.originalBasePath || base);
+                            rebuildScope(rawForScope, s.currentMilestoneId);
+                        }
                         try {
                             unlinkSync(pausedPath);
                         }
@@ -1285,10 +1336,15 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         // session (e.g. isolation mode changed, detectWorktreeName differs across
         // process restarts).  We guard with existsSync so a stale or deleted
         // worktree directory safely falls back to the project root.
-        const resumeWorktreePath = freshStartAssessment.pausedSession?.worktreePath;
+        const resumeWorktreePath = freshStartAssessment.pausedSession?.worktreePath ?? null;
+        if (resumeWorktreePath && !existsSync(resumeWorktreePath)) {
+            logWarning("session", `Worktree was expected at ${resumeWorktreePath} but is missing. Continuing in project-root mode. To restart with a fresh worktree, run /gsd-debug or recreate the milestone.`, { file: "auto.ts", milestoneId: s.currentMilestoneId ?? "" });
+        }
         if (resumeWorktreePath && existsSync(resumeWorktreePath)) {
             s.basePath = resumeWorktreePath;
         }
+        // Rebuild scope now that s.basePath reflects the actual worktree (or project root).
+        rebuildScope(s.basePath, s.currentMilestoneId);
         // Ensure the workflow-logger audit log is pinned to the project root
         // even when auto-mode is entered via a path that bypasses the
         // bootstrap/dynamic-tools ensureDbOpen() → setLogBasePath() chain
@@ -1315,6 +1371,8 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             buildResolver().enterMilestone(s.currentMilestoneId, {
                 notify: ctx.ui.notify.bind(ctx.ui),
             });
+            // s.basePath may have been updated to a worktree path by enterMilestone.
+            rebuildScope(s.basePath, s.currentMilestoneId);
         }
         registerSigtermHandler(lockBase());
         ctx.ui.setStatus("gsd-auto", s.stepMode ? "next" : "auto");
@@ -1393,6 +1451,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     const ready = await bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, bootstrapDeps, freshStartAssessment);
     if (!ready)
         return;
+    // Build scope after bootstrap has populated s.basePath / s.originalBasePath /
+    // s.currentMilestoneId (including worktree setup inside bootstrapAutoSession).
+    rebuildScope(s.basePath, s.currentMilestoneId);
     captureProjectRootEnv(s.originalBasePath || s.basePath);
     try {
         pi.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "sync", preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, state: await deriveState(s.basePath) });

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

@@ -86,7 +86,7 @@ export async function handleAgentEnd(pi, event, ctx) {
         logWarning("bootstrap", `checkDeepProjectSetupAfterTurn failed: ${message}`);
     }
     if (checkAutoStartAfterDiscuss()) {
-        clearDiscussionFlowState();
+        clearDiscussionFlowState(resolveAgentEndBasePath() ?? process.cwd());
         return;
     }
     // #4573 — When the LLM emits "Milestone X ready." but the required files