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

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

@@ -56,11 +56,13 @@ import { getErrorMessage } from "./error-utils.js";
 import { recoverFailedMigration } from "./migrate-external.js";
 import { initRegistry, convertDispatchRules } from "./rule-registry.js";
 import { emitJournalEvent as _emitJournalEvent } from "./journal.js";
+import { isClosedStatus } from "./status-guards.js";
 import { updateProgressWidget as _updateProgressWidget, updateSliceProgressCache, clearSliceProgressCache, } from "./auto-dashboard.js";
 import { registerSigtermHandler as _registerSigtermHandler, deregisterSigtermHandler as _deregisterSigtermHandler, } from "./auto-supervisor.js";
 import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { countPendingCaptures } from "./captures.js";
 import { CMUX_CHANNELS } from "../shared/cmux-events.js";
+import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 function makeCmuxEmitters(pi) {
     return {
         syncCmuxSidebar: (preferences, state) => pi.events.emit(CMUX_CHANNELS.SIDEBAR, { action: "sync", preferences, state }),
@@ -84,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.
@@ -145,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;
@@ -282,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;
 }
@@ -1154,15 +1195,31 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         || !!freshStartAssessment.lock);
                 if (shouldResumePausedSession) {
                     // Validate the milestone still exists and isn't already complete (#1664).
+                    // DB status is authoritative when available; SUMMARY.md is a legacy
+                    // fallback only for unmigrated/offline projects.
                     const mDir = resolveMilestonePath(base, meta.milestoneId);
-                    const summaryFile = resolveMilestoneFile(base, meta.milestoneId, "SUMMARY");
                     let summaryIsTerminal = false;
-                    if (summaryFile) {
-                        try {
-                            summaryIsTerminal = classifyMilestoneSummaryContent(readFileSync(summaryFile, "utf-8")) !== "failure";
+                    let dbAvailable = isDbAvailable();
+                    let milestoneRow = dbAvailable ? getMilestone(meta.milestoneId) : null;
+                    if (!milestoneRow) {
+                        const opened = await ensureDbOpen(base);
+                        dbAvailable = opened || isDbAvailable();
+                        if (dbAvailable) {
+                            milestoneRow = getMilestone(meta.milestoneId);
                         }
-                        catch {
-                            summaryIsTerminal = false;
+                    }
+                    if (dbAvailable) {
+                        summaryIsTerminal = !!milestoneRow && isClosedStatus(milestoneRow.status);
+                    }
+                    else {
+                        const summaryFile = resolveMilestoneFile(base, meta.milestoneId, "SUMMARY");
+                        if (summaryFile) {
+                            try {
+                                summaryIsTerminal = classifyMilestoneSummaryContent(readFileSync(summaryFile, "utf-8")) !== "failure";
+                            }
+                            catch {
+                                summaryIsTerminal = false;
+                            }
                         }
                     }
                     if (!mDir || summaryIsTerminal) {
@@ -1186,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);
                         }
@@ -1267,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
@@ -1297,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");
@@ -1375,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

package/dist/resources/extensions/gsd/bootstrap/dynamic-tools.js

@@ -1,8 +1,9 @@
 import { existsSync } from "node:fs";
-import { join, sep } from "node:path";
+import { dirname } from "node:path";
 import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@gsd/pi-coding-agent";
 import { DEFAULT_BASH_TIMEOUT_SECS } from "../constants.js";
 import { setLogBasePath, logWarning } from "../workflow-logger.js";
+import { resolveGsdPathContract } from "../paths.js";
 /**
  * Resolve the correct DB path for the current working directory.
  * If `basePath` is inside a `.gsd/worktrees/<MID>/` directory, returns
@@ -10,67 +11,15 @@ import { setLogBasePath, logWarning } from "../workflow-logger.js";
  * returns `<basePath>/.gsd/gsd.db`.
  */
 export function resolveProjectRootDbPath(basePath) {
-    // Detect worktree: look for `.gsd/worktrees/` in the path segments.
-    // A worktree path looks like: /project/root/.gsd/worktrees/M001/...
-    // We need to resolve back to /project/root/.gsd/gsd.db
-    const marker = `${sep}.gsd${sep}worktrees${sep}`;
-    const idx = basePath.indexOf(marker);
-    if (idx !== -1) {
-        const projectRoot = basePath.slice(0, idx);
-        return join(projectRoot, ".gsd", "gsd.db");
-    }
-    // Also handle forward-slash paths on all platforms
-    const fwdMarker = "/.gsd/worktrees/";
-    const fwdIdx = basePath.indexOf(fwdMarker);
-    if (fwdIdx !== -1) {
-        const projectRoot = basePath.slice(0, fwdIdx);
-        return join(projectRoot, ".gsd", "gsd.db");
-    }
-    // External-state layout: ~/.gsd/projects/<hash>/worktrees/<MID>/...
-    // Resolve to ~/.gsd/projects/<hash>/gsd.db (the canonical project DB) (#2952).
-    // Must be checked before the generic symlink-resolved handler: both match
-    // /.gsd/projects/<hash>/worktrees/ but require different resolution targets.
-    const extRe = /[/\\]\.gsd[/\\]projects[/\\][a-f0-9]+[/\\]worktrees(?:[/\\]|$)/;
-    const extMatch = extRe.exec(basePath);
-    if (extMatch) {
-        const matchStr = extMatch[0];
-        // Find the "/worktrees" portion within the match and slice up to it
-        const wtIdx = matchStr.search(/[/\\]worktrees(?:[/\\]|$)/);
-        const projectStateRoot = basePath.slice(0, extMatch.index + wtIdx);
-        return join(projectStateRoot, "gsd.db");
-    }
-    // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/M001/...
-    // The project root is everything before /.gsd/projects/ (#2517)
-    const symlinkMarker = `${sep}.gsd${sep}projects${sep}`;
-    const symlinkIdx = basePath.indexOf(symlinkMarker);
-    if (symlinkIdx !== -1) {
-        const afterProjects = basePath.slice(symlinkIdx + symlinkMarker.length);
-        // Expect: <hash>/worktrees/...
-        const worktreeSeg = `${sep}worktrees${sep}`;
-        if (afterProjects.includes(worktreeSeg)) {
-            const projectRoot = basePath.slice(0, symlinkIdx);
-            return join(projectRoot, ".gsd", "gsd.db");
-        }
-    }
-    // Forward-slash variant for symlink-resolved layout
-    const fwdSymlinkMarker = "/.gsd/projects/";
-    const fwdSymlinkIdx = basePath.indexOf(fwdSymlinkMarker);
-    if (fwdSymlinkIdx !== -1) {
-        const afterProjects = basePath.slice(fwdSymlinkIdx + fwdSymlinkMarker.length);
-        if (afterProjects.includes("/worktrees/")) {
-            const projectRoot = basePath.slice(0, fwdSymlinkIdx);
-            return join(projectRoot, ".gsd", "gsd.db");
-        }
-    }
-    return join(basePath, ".gsd", "gsd.db");
+    return resolveGsdPathContract(basePath).projectDb;
 }
 export async function ensureDbOpen(basePath = process.cwd()) {
     try {
         const db = await import("../gsd-db.js");
-        const dbPath = resolveProjectRootDbPath(basePath);
-        const gsdDir = join(basePath, ".gsd");
-        // Derive the project root from the DB path (strip .gsd/gsd.db)
-        const projectRoot = join(dbPath, "..", "..");
+        const contract = resolveGsdPathContract(basePath);
+        const dbPath = contract.projectDb;
+        const gsdDir = contract.projectGsd;
+        const projectRoot = dirname(dirname(dbPath));
         // Open existing DB file (may be at project root for worktrees)
         if (existsSync(dbPath)) {
             const opened = db.openDatabase(dbPath);
@@ -78,26 +27,9 @@ export async function ensureDbOpen(basePath = process.cwd()) {
                 setLogBasePath(projectRoot);
             return opened;
         }
-        // No DB file — create + migrate from Markdown if .gsd/ has content
+        // No DB file — create an empty authoritative DB. Markdown migration is
+        // explicit-only; runtime startup must not import projections into state.
         if (existsSync(gsdDir)) {
-            const hasDecisions = existsSync(join(gsdDir, "DECISIONS.md"));
-            const hasRequirements = existsSync(join(gsdDir, "REQUIREMENTS.md"));
-            const hasMilestones = existsSync(join(gsdDir, "milestones"));
-            if (hasDecisions || hasRequirements || hasMilestones) {
-                const opened = db.openDatabase(dbPath);
-                if (opened) {
-                    setLogBasePath(projectRoot);
-                    try {
-                        const { migrateFromMarkdown } = await import("../md-importer.js");
-                        migrateFromMarkdown(basePath);
-                    }
-                    catch (err) {
-                        logWarning("bootstrap", `ensureDbOpen auto-migration failed: ${err.message}`);
-                    }
-                }
-                return opened;
-            }
-            // .gsd/ exists but has no Markdown content (fresh project) — create empty DB
             const opened = db.openDatabase(dbPath);
             if (opened)
                 setLogBasePath(projectRoot);

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -60,7 +60,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             const { initHealthWidget } = await import("../health-widget.js");
             initHealthWidget(ctx);
         }
-        resetWriteGateState();
+        resetWriteGateState(process.cwd());
         resetToolCallLoopGuard();
         approvalQuestionAbortInFlight = false;
         await resetAskUserQuestionsTurnCache();
@@ -109,10 +109,10 @@ export function registerHooks(pi, ecosystemHandlers) {
     pi.on("session_switch", async (_event, ctx) => {
         initNotificationStore(process.cwd());
         installNotifyInterceptor(ctx);
-        resetWriteGateState();
+        resetWriteGateState(process.cwd());
         resetToolCallLoopGuard();
         await resetAskUserQuestionsTurnCache();
-        clearDiscussionFlowState();
+        clearDiscussionFlowState(process.cwd());
         await syncServiceTierStatus(ctx);
         await applyDisabledModelProviderPolicy(ctx);
         // Skip MCP auto-prep when running inside an auto-worktree. The worktree
@@ -137,13 +137,14 @@ export function registerHooks(pi, ecosystemHandlers) {
         // Wait for ecosystem loader to finish (no-op after first turn).
         const { getEcosystemReadyPromise } = await import("../ecosystem/loader.js");
         await getEcosystemReadyPromise();
+        const beforeAgentBasePath = process.cwd();
         const pendingApprovalGate = getPendingGate();
         if (pendingApprovalGate && isExplicitApprovalResponse(event.prompt, pendingApprovalGate)) {
-            markApprovalGateVerified(pendingApprovalGate);
+            markApprovalGateVerified(pendingApprovalGate, beforeAgentBasePath);
             const milestoneId = extractDepthVerificationMilestoneId(pendingApprovalGate);
             if (milestoneId)
-                markDepthVerified(milestoneId);
-            clearPendingGate();
+                markDepthVerified(milestoneId, beforeAgentBasePath);
+            clearPendingGate(beforeAgentBasePath);
         }
         // GSD's own context injection (existing behavior — unchanged).
         const { buildBeforeAgentStartResult } = await import("./system-context.js");
@@ -318,7 +319,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             return;
         const gateId = approvalGateIdForUnit(unitType, unitId);
         if (gateId)
-            setPendingGate(gateId);
+            setPendingGate(gateId, process.cwd());
         approvalQuestionAbortInFlight = true;
         ctx.ui.notify(`${unitType}${unitId ? ` ${unitId}` : ""} is waiting for your approval - pausing before more tool calls run.`, "info");
         // The pending gate set above blocks subsequent non-read-only tool calls
@@ -360,7 +361,7 @@ export function registerHooks(pi, ecosystemHandlers) {
             const questions = event.input?.questions ?? [];
             const questionId = questions.find((question) => typeof question?.id === "string" && isGateQuestionId(question.id))?.id;
             if (typeof questionId === "string") {
-                setPendingGate(questionId);
+                setPendingGate(questionId, discussionBasePath);
             }
         }
         // ── Discussion gate enforcement: block tool calls while gate is pending ──
@@ -501,7 +502,8 @@ export function registerHooks(pi, ecosystemHandlers) {
         const toolName = canonicalToolName(event.toolName);
         if (toolName !== "ask_user_questions")
             return;
-        const milestoneId = await getDiscussionMilestoneIdFor(process.cwd());
+        const basePath = process.cwd();
+        const milestoneId = await getDiscussionMilestoneIdFor(basePath);
         const queueActive = isQueuePhaseActive();
         const details = event.details;
         // ── Discussion gate enforcement: handle gate question responses ──
@@ -533,11 +535,11 @@ export function registerHooks(pi, ecosystemHandlers) {
                 if (pendingQuestion) {
                     const answer = details.response?.answers?.[currentPendingGate];
                     if (isDepthConfirmationAnswer(answer?.selected, pendingQuestion.options)) {
-                        markApprovalGateVerified(currentPendingGate);
+                        markApprovalGateVerified(currentPendingGate, basePath);
                         const milestoneIdFromGate = extractDepthVerificationMilestoneId(currentPendingGate);
                         if (milestoneIdFromGate)
-                            markDepthVerified(milestoneIdFromGate);
-                        clearPendingGate();
+                            markDepthVerified(milestoneIdFromGate, basePath);
+                        clearPendingGate(basePath);
                     }
                 }
             }
@@ -553,9 +555,9 @@ export function registerHooks(pi, ecosystemHandlers) {
                 if (isDepthConfirmationAnswer(answer?.selected, question.options)) {
                     if (currentPendingGate && question.id !== currentPendingGate)
                         break;
-                    markApprovalGateVerified(question.id);
-                    markDepthVerified(inferredMilestoneId);
-                    clearPendingGate();
+                    markApprovalGateVerified(question.id, basePath);
+                    markDepthVerified(inferredMilestoneId, basePath);
+                    clearPendingGate(basePath);
                 }
                 break;
             }
@@ -564,7 +566,6 @@ export function registerHooks(pi, ecosystemHandlers) {
             return;
         if (!milestoneId)
             return;
-        const basePath = process.cwd();
         const milestoneDir = resolveMilestonePath(basePath, milestoneId);
         if (!milestoneDir)
             return;

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -55,19 +55,31 @@ const QUEUE_SAFE_TOOLS = new Set([
  *   true / false        — shell no-ops / test exit codes
  */
 const BASH_READ_ONLY_RE = /^\s*(cat|head|tail|less|more|wc|file|stat|du|df|which|type|echo|printf|ls|find|grep|rg|awk|sed\b(?!.*-i)|sort|uniq|diff|comm|tr|cut|tee\s+-a\s+\/dev\/null|git\s+(log|show|diff|status|branch|tag|remote|rev-parse|ls-files|blame|shortlog|describe|stash\s+list|config\s+--get|cat-file)|gh\s+(issue|pr|api|repo|release)\s+(view|list|diff|status|checks)|mkdir\s+-p\s+\.gsd|rtk\s|npm\s+run\s+(test|test:\w+|lint|lint:\w+|typecheck|type-check|type-check:\w+|check|verify|audit|outdated|format:check|ci|validate)\b|npm\s+(ls|list|info|view|show|outdated|audit|explain|doctor|ping|--version|-v)\b|npx\s|tsx\s|node\s+(--print|--version|-v\b)|python[23]?\s+(-c\s+'[^']*'|--version|-V\b|-m\s+(pip\s+show|pip\s+list|site))|pip[23]?\s+(show|list|freeze|check|index\s+versions)\b|jq\s|yq\s|curl\s+(-s\b|--silent\b)(?!\s+[^|>]*\s-[oO]\b)(?!\s+[^|>]*\s--output\b)[^|>]*$|openssl\s+(version|x509|s_client)|env\b|printenv\b|true\b|false\b)/;
-const verifiedDepthMilestones = new Set();
-const verifiedApprovalGates = new Set();
-let activeQueuePhase = false;
+function createEmptyWriteGateState() {
+    return {
+        verifiedDepthMilestones: new Set(),
+        verifiedApprovalGates: new Set(),
+        activeQueuePhase: false,
+        pendingGateId: null,
+    };
+}
+const writeGateStatesByBasePath = new Map();
+function writeGateStateKey(basePath) {
+    return resolve(basePath);
+}
+function getWriteGateState(basePath = process.cwd()) {
+    const key = writeGateStateKey(basePath);
+    let state = writeGateStatesByBasePath.get(key);
+    if (!state) {
+        state = createEmptyWriteGateState();
+        writeGateStatesByBasePath.set(key, state);
+    }
+    return state;
+}
 /**
- * Discussion gate enforcement state.
- *
- * When ask_user_questions is called with a recognized gate question ID,
- * we track the pending gate. Until the gate is confirmed (user selects the
- * first/recommended option), all non-read-only tool calls are blocked.
- * This mechanically prevents the model from rationalizing past failed or
- * cancelled gate questions.
+ * Discussion gate enforcement state is scoped per basePath so multiple
+ * workspaces can coexist in the same process without sharing gate state.
  */
-let pendingGateId = null;
 /**
  * Recognized gate question ID patterns.
  * These appear in discuss.md (depth/requirements/roadmap).
@@ -99,24 +111,25 @@ function shouldPersistWriteGateSnapshot(env = process.env) {
     const v = env.GSD_PERSIST_WRITE_GATE_STATE;
     return v !== "0" && v !== "false";
 }
-function writeGateSnapshotPath(basePath = process.cwd()) {
+function writeGateSnapshotPath(basePath) {
     return join(basePath, ".gsd", "runtime", "write-gate-state.json");
 }
-function currentWriteGateSnapshot() {
+function currentWriteGateSnapshot(basePath = process.cwd()) {
+    const state = getWriteGateState(basePath);
     return {
-        verifiedDepthMilestones: [...verifiedDepthMilestones].sort(),
-        verifiedApprovalGates: [...verifiedApprovalGates].sort(),
-        activeQueuePhase,
-        pendingGateId,
+        verifiedDepthMilestones: [...state.verifiedDepthMilestones].sort(),
+        verifiedApprovalGates: [...state.verifiedApprovalGates].sort(),
+        activeQueuePhase: state.activeQueuePhase,
+        pendingGateId: state.pendingGateId,
     };
 }
-function persistWriteGateSnapshot(basePath = process.cwd()) {
+function persistWriteGateSnapshot(basePath) {
     if (!shouldPersistWriteGateSnapshot())
         return;
     const path = writeGateSnapshotPath(basePath);
     mkdirSync(join(basePath, ".gsd", "runtime"), { recursive: true });
     const tempPath = `${path}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2)}.tmp`;
-    writeFileSync(tempPath, JSON.stringify(currentWriteGateSnapshot(), null, 2), "utf-8");
+    writeFileSync(tempPath, JSON.stringify(currentWriteGateSnapshot(basePath), null, 2), "utf-8");
     try {
         renameSync(tempPath, path);
     }
@@ -132,7 +145,7 @@ function persistWriteGateSnapshot(basePath = process.cwd()) {
         }
     }
 }
-function clearPersistedWriteGateSnapshot(basePath = process.cwd()) {
+function clearPersistedWriteGateSnapshot(basePath) {
     if (!shouldPersistWriteGateSnapshot())
         return;
     const path = writeGateSnapshotPath(basePath);
@@ -164,7 +177,7 @@ const EMPTY_SNAPSHOT = {
     activeQueuePhase: false,
     pendingGateId: null,
 };
-export function loadWriteGateSnapshot(basePath = process.cwd()) {
+export function loadWriteGateSnapshot(basePath) {
     const path = writeGateSnapshotPath(basePath);
     if (!existsSync(path)) {
         // When persist mode is active and the file has been deleted, treat it as a
@@ -172,61 +185,59 @@ export function loadWriteGateSnapshot(basePath = process.cwd()) {
         // In non-persist mode the file is never written, so fall back to in-memory.
         if (shouldPersistWriteGateSnapshot())
             return EMPTY_SNAPSHOT;
-        return currentWriteGateSnapshot();
+        return currentWriteGateSnapshot(basePath);
     }
     try {
         return normalizeWriteGateSnapshot(JSON.parse(readFileSync(path, "utf-8")));
     }
     catch {
-        return currentWriteGateSnapshot();
+        return currentWriteGateSnapshot(basePath);
     }
 }
-export function isDepthVerified() {
-    return verifiedDepthMilestones.size > 0;
+export function isDepthVerified(basePath = process.cwd()) {
+    return getWriteGateState(basePath).verifiedDepthMilestones.size > 0;
 }
 /**
  * Check whether a specific milestone has passed depth verification.
  */
-export function isMilestoneDepthVerified(milestoneId) {
+export function isMilestoneDepthVerified(milestoneId, basePath = process.cwd()) {
     if (!milestoneId)
         return false;
-    return verifiedDepthMilestones.has(milestoneId);
+    return getWriteGateState(basePath).verifiedDepthMilestones.has(milestoneId);
 }
 export function isMilestoneDepthVerifiedInSnapshot(snapshot, milestoneId) {
     if (!milestoneId)
         return false;
     return snapshot.verifiedDepthMilestones.includes(milestoneId);
 }
-export function isQueuePhaseActive() {
-    return activeQueuePhase;
+export function isQueuePhaseActive(basePath = process.cwd()) {
+    return getWriteGateState(basePath).activeQueuePhase;
 }
-export function setQueuePhaseActive(active) {
-    activeQueuePhase = active;
-    persistWriteGateSnapshot();
+export function setQueuePhaseActive(active, basePath) {
+    getWriteGateState(basePath).activeQueuePhase = active;
+    persistWriteGateSnapshot(basePath);
 }
-export function resetWriteGateState() {
-    verifiedDepthMilestones.clear();
-    verifiedApprovalGates.clear();
-    pendingGateId = null;
-    persistWriteGateSnapshot();
+export function resetWriteGateState(basePath) {
+    const state = getWriteGateState(basePath);
+    state.verifiedDepthMilestones.clear();
+    state.verifiedApprovalGates.clear();
+    state.pendingGateId = null;
+    persistWriteGateSnapshot(basePath);
 }
-export function clearDiscussionFlowState() {
-    verifiedDepthMilestones.clear();
-    verifiedApprovalGates.clear();
-    activeQueuePhase = false;
-    pendingGateId = null;
-    clearPersistedWriteGateSnapshot();
+export function clearDiscussionFlowState(basePath) {
+    writeGateStatesByBasePath.delete(writeGateStateKey(basePath));
+    clearPersistedWriteGateSnapshot(basePath);
 }
 export function markDepthVerified(milestoneId, basePath = process.cwd()) {
     if (!milestoneId)
         return;
-    verifiedDepthMilestones.add(milestoneId);
+    getWriteGateState(basePath).verifiedDepthMilestones.add(milestoneId);
     persistWriteGateSnapshot(basePath);
 }
 export function markApprovalGateVerified(gateId, basePath = process.cwd()) {
     if (!gateId)
         return;
-    verifiedApprovalGates.add(gateId);
+    getWriteGateState(basePath).verifiedApprovalGates.add(gateId);
     persistWriteGateSnapshot(basePath);
 }
 export function isApprovalGateVerifiedInSnapshot(snapshot, gateId) {
@@ -258,26 +269,27 @@ function extractContextMilestoneId(inputPath) {
 /**
  * Mark a gate as pending (called when ask_user_questions is invoked with a gate ID).
  */
-export function setPendingGate(gateId) {
-    pendingGateId = gateId;
-    verifiedApprovalGates.delete(gateId);
+export function setPendingGate(gateId, basePath) {
+    const state = getWriteGateState(basePath);
+    state.pendingGateId = gateId;
+    state.verifiedApprovalGates.delete(gateId);
     const milestoneId = extractDepthVerificationMilestoneId(gateId);
     if (milestoneId)
-        verifiedDepthMilestones.delete(milestoneId);
-    persistWriteGateSnapshot();
+        state.verifiedDepthMilestones.delete(milestoneId);
+    persistWriteGateSnapshot(basePath);
 }
 /**
  * Clear the pending gate (called when the user confirms).
  */
-export function clearPendingGate() {
-    pendingGateId = null;
-    persistWriteGateSnapshot();
+export function clearPendingGate(basePath) {
+    getWriteGateState(basePath).pendingGateId = null;
+    persistWriteGateSnapshot(basePath);
 }
 /**
  * Get the currently pending gate, if any.
  */
-export function getPendingGate() {
-    return pendingGateId;
+export function getPendingGate(basePath = process.cwd()) {
+    return getWriteGateState(basePath).pendingGateId;
 }
 /**
  * Check whether a tool call should be blocked because a discussion gate

package/dist/resources/extensions/gsd/commands-codebase.js

@@ -6,7 +6,7 @@
  */
 import { generateCodebaseMap, updateCodebaseMap, writeCodebaseMap, getCodebaseMapStats, readCodebaseMap, } from "./codebase-generator.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { projectRoot } from "./commands/context.js";
+import { currentDirectoryRoot } from "./commands/context.js";
 const USAGE = "Usage: /gsd codebase [generate|update|stats]\n\n" +
     "  generate [--max-files N] [--collapse-threshold N]  — Generate or regenerate CODEBASE.md\n" +
     "  update [--max-files N] [--collapse-threshold N]    — Refresh the CODEBASE.md cache immediately\n" +
@@ -20,7 +20,7 @@ const USAGE = "Usage: /gsd codebase [generate|update|stats]\n\n" +
     "    max_files: 1000\n" +
     "    collapse_threshold: 15";
 export async function handleCodebase(args, ctx, _pi) {
-    const basePath = projectRoot();
+    const basePath = currentDirectoryRoot();
     const parts = args.trim().split(/\s+/);
     const sub = parts[0] ?? "";
     switch (sub) {