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

package/src/resources/extensions/gsd/auto.ts

@@ -175,6 +175,7 @@ import { getErrorMessage } from "./error-utils.js";
 import { recoverFailedMigration } from "./migrate-external.js";
 import { initRegistry, convertDispatchRules } from "./rule-registry.js";
 import { emitJournalEvent as _emitJournalEvent, type JournalEntry } from "./journal.js";
+import { isClosedStatus } from "./status-guards.js";
 import {
   type AutoDashboardData,
   updateProgressWidget as _updateProgressWidget,
@@ -194,6 +195,7 @@ import {
 import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { countPendingCaptures } from "./captures.js";
 import { CMUX_CHANNELS, type CmuxLogLevel } from "../shared/cmux-events.js";
+import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
 
 function makeCmuxEmitters(pi: ExtensionAPI) {
   return {
@@ -254,6 +256,7 @@ export type {
 } 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).
@@ -322,6 +325,32 @@ function restoreMilestoneLockEnv(): void {
   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: string, milestoneId: string | null): void {
+  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: unknown): string | null {
   if (typeof raw !== "string") return null;
   const trimmed = raw.trim();
@@ -507,6 +536,26 @@ export function _setAutoActiveForTest(active: boolean): void {
   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: string | null | undefined,
+  milestoneId: string,
+): boolean {
+  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(): boolean {
   return s.paused;
 }
@@ -1506,14 +1555,29 @@ export async function startAuto(
           );
         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";
-            } catch {
-              summaryIsTerminal = false;
+          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);
+            }
+          }
+          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) {
@@ -1536,6 +1600,22 @@ export async function startAuto(
             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); } catch (e) {
               if ((e as NodeJS.ErrnoException).code !== "ENOENT") {
                 logWarning("session", `pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" });
@@ -1620,10 +1700,19 @@ export async function startAuto(
     // 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
@@ -1652,6 +1741,8 @@ export async function startAuto(
       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());
@@ -1766,6 +1857,10 @@ export async function startAuto(
   );
   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" as const, preferences: loadEffectiveGSDPreferences(s.basePath || undefined)?.preferences, state: await deriveState(s.basePath) });

package/src/resources/extensions/gsd/bootstrap/agent-end-recovery.ts

@@ -115,7 +115,7 @@ export async function handleAgentEnd(
   }
 
   if (checkAutoStartAfterDiscuss()) {
-    clearDiscussionFlowState();
+    clearDiscussionFlowState(resolveAgentEndBasePath() ?? process.cwd());
     return;
   }
 

package/src/resources/extensions/gsd/bootstrap/dynamic-tools.ts

@@ -1,11 +1,12 @@
 import { existsSync } from "node:fs";
-import { join, sep } from "node:path";
+import { dirname } from "node:path";
 
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
 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.
@@ -14,75 +15,16 @@ import { setLogBasePath, logWarning } from "../workflow-logger.js";
  * returns `<basePath>/.gsd/gsd.db`.
  */
 export function resolveProjectRootDbPath(basePath: string): string {
-  // 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: string = process.cwd()): Promise<boolean> {
   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)) {
@@ -91,26 +33,9 @@ export async function ensureDbOpen(basePath: string = process.cwd()): Promise<bo
       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 as Error).message}`);
-          }
-        }
-        return opened;
-      }
-
-      // .gsd/ exists but has no Markdown content (fresh project) — create empty DB
       const opened = db.openDatabase(dbPath);
       if (opened) setLogBasePath(projectRoot);
       return opened;

package/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -76,7 +76,7 @@ export function registerHooks(
       const { initHealthWidget } = await import("../health-widget.js");
       initHealthWidget(ctx);
     }
-    resetWriteGateState();
+    resetWriteGateState(process.cwd());
     resetToolCallLoopGuard();
     approvalQuestionAbortInFlight = false;
     await resetAskUserQuestionsTurnCache();
@@ -126,10 +126,10 @@ export function registerHooks(
   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
@@ -155,12 +155,13 @@ export function registerHooks(
     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();
+      if (milestoneId) markDepthVerified(milestoneId, beforeAgentBasePath);
+      clearPendingGate(beforeAgentBasePath);
     }
 
     // GSD's own context injection (existing behavior — unchanged).
@@ -346,7 +347,7 @@ export function registerHooks(
     if (!shouldPauseForUserApprovalQuestion(unitType, [event.message])) return;
 
     const gateId = approvalGateIdForUnit(unitType, unitId);
-    if (gateId) setPendingGate(gateId);
+    if (gateId) setPendingGate(gateId, process.cwd());
 
     approvalQuestionAbortInFlight = true;
     ctx.ui.notify(
@@ -393,7 +394,7 @@ export function registerHooks(
       const questions: any[] = (event.input as any)?.questions ?? [];
       const questionId = questions.find((question) => typeof question?.id === "string" && isGateQuestionId(question.id))?.id;
       if (typeof questionId === "string") {
-        setPendingGate(questionId);
+        setPendingGate(questionId, discussionBasePath);
       }
     }
 
@@ -555,7 +556,8 @@ export function registerHooks(
     }
     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 as any;
@@ -588,10 +590,10 @@ export function registerHooks(
         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();
+            if (milestoneIdFromGate) markDepthVerified(milestoneIdFromGate, basePath);
+            clearPendingGate(basePath);
           }
         }
       }
@@ -607,9 +609,9 @@ export function registerHooks(
         const inferredMilestoneId = extractDepthVerificationMilestoneId(question.id) ?? milestoneId;
         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;
       }
@@ -617,8 +619,6 @@ export function registerHooks(
 
     if (!milestoneId && !queueActive) return;
     if (!milestoneId) return;
-
-    const basePath = process.cwd();
     const milestoneDir = resolveMilestonePath(basePath, milestoneId);
     if (!milestoneDir) return;
 

package/src/resources/extensions/gsd/bootstrap/tests/write-gate-basepath.test.ts

@@ -0,0 +1,103 @@
+// GSD-2 write-gate bootstrap — regression test for required basePath (commit A3)
+//
+// Verifies that persistWriteGateSnapshot / loadWriteGateSnapshot are pinned to
+// the basePath argument and do not silently fall back to process.cwd(). The
+// underlying bug: both functions defaulted `basePath = process.cwd()`, so a
+// persist in cwd-A followed by a chdir to cwd-B and a load (which also
+// defaulted to process.cwd(), now cwd-B) missed the persisted file entirely —
+// the depth-verification state became invisible across cwd boundaries.
+
+import { test, describe, before, after } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, existsSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import {
+  markDepthVerified,
+  loadWriteGateSnapshot,
+  clearDiscussionFlowState,
+} from "../write-gate.js";
+
+// ─── Helpers ────────────────────────────────────────────────────────────────
+
+function makeTempDir(): string {
+  return mkdtempSync(join(tmpdir(), "wg-basepath-test-"));
+}
+
+// Save and restore process.cwd() across tests to avoid cross-test pollution.
+let originalCwd: string;
+before(() => {
+  originalCwd = process.cwd();
+});
+after(() => {
+  if (process.cwd() !== originalCwd) {
+    process.chdir(originalCwd);
+  }
+});
+
+// ─── Scenario: persist with basePath=A, chdir, load with basePath=A ─────────
+//
+// This is the exact failure mode from the bug: persist used process.cwd() and
+// load used process.cwd(), and they resolved to different directories after a
+// chdir.  With the fix, both calls receive an explicit basePath so cwd changes
+// have no effect.
+
+describe("write-gate basePath regression", () => {
+  let baseDirA: string;
+  let baseDirB: string;
+
+  before(() => {
+    baseDirA = makeTempDir();
+    baseDirB = makeTempDir();
+  });
+
+  after(() => {
+    // Restore cwd before cleanup to avoid issues on Windows.
+    process.chdir(originalCwd);
+    rmSync(baseDirA, { recursive: true, force: true });
+    rmSync(baseDirB, { recursive: true, force: true });
+  });
+
+  test("snapshot persisted to basePath=A is readable after chdir to basePath=B", (t) => {
+    // Arrange: enable persistence (the default when env var is not set to "0"/"false").
+    const prev = process.env.GSD_PERSIST_WRITE_GATE_STATE;
+    t.after(() => {
+      if (prev === undefined) {
+        delete process.env.GSD_PERSIST_WRITE_GATE_STATE;
+      } else {
+        process.env.GSD_PERSIST_WRITE_GATE_STATE = prev;
+      }
+    });
+    process.env.GSD_PERSIST_WRITE_GATE_STATE = "1";
+
+    // Reset state and clear any stale snapshot files from both dirs.
+    clearDiscussionFlowState(baseDirA);
+    clearDiscussionFlowState(baseDirB);
+
+    // Act: persist a milestone as depth-verified into baseDirA.
+    markDepthVerified("M001", baseDirA);
+
+    // Confirm the snapshot file was written under baseDirA.
+    const snapshotPath = join(baseDirA, ".gsd", "runtime", "write-gate-state.json");
+    assert.ok(existsSync(snapshotPath), "snapshot file should exist under baseDirA");
+
+    // Simulate what happens when cwd changes to a different project root.
+    process.chdir(baseDirB);
+    assert.notEqual(process.cwd(), baseDirA, "cwd should differ from baseDirA after chdir");
+
+    // Load snapshot using the explicit baseDirA — must see the persisted state.
+    const snapshot = loadWriteGateSnapshot(baseDirA);
+    assert.ok(
+      snapshot.verifiedDepthMilestones.includes("M001"),
+      "loadWriteGateSnapshot(baseDirA) must return the persisted milestone despite cwd being baseDirB",
+    );
+
+    // Loading with baseDirB must NOT see the state from baseDirA.
+    const snapshotB = loadWriteGateSnapshot(baseDirB);
+    assert.ok(
+      !snapshotB.verifiedDepthMilestones.includes("M001"),
+      "loadWriteGateSnapshot(baseDirB) must not bleed state from baseDirA",
+    );
+  });
+});