gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

package/src/resources/extensions/browser-tools/index.ts

@@ -1,71 +1,160 @@
 /** browser-tools — pi extension: full browser interaction via Playwright. */
-import type { ExtensionAPI } from "@gsd/pi-coding-agent";
-import type { ToolDeps } from "./state.js";
-import { ensureBrowser, closeBrowser, getActivePage, getActiveTarget, getActivePageOrNull, attachPageListeners } from "./lifecycle.js";
-import { captureCompactPageState, postActionSummary, constrainScreenshot, captureErrorScreenshot } from "./capture.js";
-import { settleAfterActionAdaptive, ensureMutationCounter } from "./settle.js";
-import { buildRefSnapshot, resolveRefTarget } from "./refs.js";
-import * as u from "./utils.js";
-import { registerNavigationTools } from "./tools/navigation.js";
-import { registerScreenshotTools } from "./tools/screenshot.js";
-import { registerInteractionTools } from "./tools/interaction.js";
-import { registerInspectionTools } from "./tools/inspection.js";
-import { registerSessionTools } from "./tools/session.js";
-import { registerAssertionTools } from "./tools/assertions.js";
-import { registerRefTools } from "./tools/refs.js";
-import { registerWaitTools } from "./tools/wait.js";
-import { registerPageTools } from "./tools/pages.js";
-import { registerFormTools } from "./tools/forms.js";
-import { registerIntentTools } from "./tools/intent.js";
-import { registerPdfTools } from "./tools/pdf.js";
-import { registerStatePersistenceTools } from "./tools/state-persistence.js";
-import { registerNetworkMockTools } from "./tools/network-mock.js";
-import { registerDeviceTools } from "./tools/device.js";
-import { registerExtractTools } from "./tools/extract.js";
-import { registerVisualDiffTools } from "./tools/visual-diff.js";
-import { registerZoomTools } from "./tools/zoom.js";
-import { registerCodegenTools } from "./tools/codegen.js";
-import { registerActionCacheTools } from "./tools/action-cache.js";
-import { registerInjectionDetectionTools } from "./tools/injection-detect.js";
+import { importExtensionModule, type ExtensionAPI } from "@gsd/pi-coding-agent";
+
+let registrationPromise: Promise<void> | null = null;
+
+async function registerBrowserTools(pi: ExtensionAPI): Promise<void> {
+  if (!registrationPromise) {
+    registrationPromise = (async () => {
+      const [
+        lifecycle,
+        capture,
+        settle,
+        refs,
+        utils,
+        navigation,
+        screenshot,
+        interaction,
+        inspection,
+        session,
+        assertions,
+        refTools,
+        wait,
+        pages,
+        forms,
+        intent,
+        pdf,
+        statePersistence,
+        networkMock,
+        device,
+        extract,
+        visualDiff,
+        zoom,
+        codegen,
+        actionCache,
+        injectionDetection,
+      ] = await Promise.all([
+        importExtensionModule<typeof import("./lifecycle.js")>(import.meta.url, "./lifecycle.js"),
+        importExtensionModule<typeof import("./capture.js")>(import.meta.url, "./capture.js"),
+        importExtensionModule<typeof import("./settle.js")>(import.meta.url, "./settle.js"),
+        importExtensionModule<typeof import("./refs.js")>(import.meta.url, "./refs.js"),
+        importExtensionModule<typeof import("./utils.js")>(import.meta.url, "./utils.js"),
+        importExtensionModule<typeof import("./tools/navigation.js")>(import.meta.url, "./tools/navigation.js"),
+        importExtensionModule<typeof import("./tools/screenshot.js")>(import.meta.url, "./tools/screenshot.js"),
+        importExtensionModule<typeof import("./tools/interaction.js")>(import.meta.url, "./tools/interaction.js"),
+        importExtensionModule<typeof import("./tools/inspection.js")>(import.meta.url, "./tools/inspection.js"),
+        importExtensionModule<typeof import("./tools/session.js")>(import.meta.url, "./tools/session.js"),
+        importExtensionModule<typeof import("./tools/assertions.js")>(import.meta.url, "./tools/assertions.js"),
+        importExtensionModule<typeof import("./tools/refs.js")>(import.meta.url, "./tools/refs.js"),
+        importExtensionModule<typeof import("./tools/wait.js")>(import.meta.url, "./tools/wait.js"),
+        importExtensionModule<typeof import("./tools/pages.js")>(import.meta.url, "./tools/pages.js"),
+        importExtensionModule<typeof import("./tools/forms.js")>(import.meta.url, "./tools/forms.js"),
+        importExtensionModule<typeof import("./tools/intent.js")>(import.meta.url, "./tools/intent.js"),
+        importExtensionModule<typeof import("./tools/pdf.js")>(import.meta.url, "./tools/pdf.js"),
+        importExtensionModule<typeof import("./tools/state-persistence.js")>(import.meta.url, "./tools/state-persistence.js"),
+        importExtensionModule<typeof import("./tools/network-mock.js")>(import.meta.url, "./tools/network-mock.js"),
+        importExtensionModule<typeof import("./tools/device.js")>(import.meta.url, "./tools/device.js"),
+        importExtensionModule<typeof import("./tools/extract.js")>(import.meta.url, "./tools/extract.js"),
+        importExtensionModule<typeof import("./tools/visual-diff.js")>(import.meta.url, "./tools/visual-diff.js"),
+        importExtensionModule<typeof import("./tools/zoom.js")>(import.meta.url, "./tools/zoom.js"),
+        importExtensionModule<typeof import("./tools/codegen.js")>(import.meta.url, "./tools/codegen.js"),
+        importExtensionModule<typeof import("./tools/action-cache.js")>(import.meta.url, "./tools/action-cache.js"),
+        importExtensionModule<typeof import("./tools/injection-detect.js")>(import.meta.url, "./tools/injection-detect.js"),
+      ]);
+
+      const deps = {
+        ensureBrowser: lifecycle.ensureBrowser,
+        closeBrowser: lifecycle.closeBrowser,
+        getActivePage: lifecycle.getActivePage,
+        getActiveTarget: lifecycle.getActiveTarget,
+        getActivePageOrNull: lifecycle.getActivePageOrNull,
+        attachPageListeners: lifecycle.attachPageListeners,
+        captureCompactPageState: capture.captureCompactPageState,
+        postActionSummary: capture.postActionSummary,
+        constrainScreenshot: capture.constrainScreenshot,
+        captureErrorScreenshot: capture.captureErrorScreenshot,
+        formatCompactStateSummary: utils.formatCompactStateSummary,
+        getRecentErrors: utils.getRecentErrors,
+        settleAfterActionAdaptive: settle.settleAfterActionAdaptive,
+        ensureMutationCounter: settle.ensureMutationCounter,
+        buildRefSnapshot: refs.buildRefSnapshot,
+        resolveRefTarget: refs.resolveRefTarget,
+        parseRef: utils.parseRef,
+        formatVersionedRef: utils.formatVersionedRef,
+        staleRefGuidance: utils.staleRefGuidance,
+        beginTrackedAction: utils.beginTrackedAction,
+        finishTrackedAction: utils.finishTrackedAction,
+        truncateText: utils.truncateText,
+        verificationFromChecks: utils.verificationFromChecks,
+        verificationLine: utils.verificationLine,
+        collectAssertionState: (page: any, checks: any, target?: any) =>
+          utils.collectAssertionState(page, checks, capture.captureCompactPageState, target),
+        formatAssertionText: utils.formatAssertionText,
+        formatDiffText: utils.formatDiffText,
+        getUrlHash: utils.getUrlHash,
+        captureClickTargetState: utils.captureClickTargetState,
+        readInputLikeValue: utils.readInputLikeValue,
+        firstErrorLine: utils.firstErrorLine,
+        captureAccessibilityMarkdown: (selector?: string) =>
+          utils.captureAccessibilityMarkdown(lifecycle.getActiveTarget(), selector),
+        resolveAccessibilityScope: utils.resolveAccessibilityScope,
+        getLivePagesSnapshot: utils.createGetLivePagesSnapshot(lifecycle.ensureBrowser),
+        getSinceTimestamp: utils.getSinceTimestamp,
+        getConsoleEntriesSince: utils.getConsoleEntriesSince,
+        getNetworkEntriesSince: utils.getNetworkEntriesSince,
+        writeArtifactFile: utils.writeArtifactFile,
+        copyArtifactFile: utils.copyArtifactFile,
+        ensureSessionArtifactDir: utils.ensureSessionArtifactDir,
+        buildSessionArtifactPath: utils.buildSessionArtifactPath,
+        getSessionArtifactMetadata: utils.getSessionArtifactMetadata,
+        sanitizeArtifactName: utils.sanitizeArtifactName,
+        formatArtifactTimestamp: utils.formatArtifactTimestamp,
+      };
+
+      navigation.registerNavigationTools(pi, deps);
+      screenshot.registerScreenshotTools(pi, deps);
+      interaction.registerInteractionTools(pi, deps);
+      inspection.registerInspectionTools(pi, deps);
+      session.registerSessionTools(pi, deps);
+      assertions.registerAssertionTools(pi, deps);
+      refTools.registerRefTools(pi, deps);
+      wait.registerWaitTools(pi, deps);
+      pages.registerPageTools(pi, deps);
+      forms.registerFormTools(pi, deps);
+      intent.registerIntentTools(pi, deps);
+      pdf.registerPdfTools(pi, deps);
+      statePersistence.registerStatePersistenceTools(pi, deps);
+      networkMock.registerNetworkMockTools(pi, deps);
+      device.registerDeviceTools(pi, deps);
+      extract.registerExtractTools(pi, deps);
+      visualDiff.registerVisualDiffTools(pi, deps);
+      zoom.registerZoomTools(pi, deps);
+      codegen.registerCodegenTools(pi, deps);
+      actionCache.registerActionCacheTools(pi, deps);
+      injectionDetection.registerInjectionDetectionTools(pi, deps);
+    })().catch((error) => {
+      registrationPromise = null;
+      throw error;
+    });
+  }
+
+  return registrationPromise;
+}
 
 export default function (pi: ExtensionAPI) {
-	pi.on("session_shutdown", async () => { await closeBrowser(); });
-	const deps: ToolDeps = {
-		ensureBrowser, closeBrowser, getActivePage, getActiveTarget, getActivePageOrNull, attachPageListeners,
-		captureCompactPageState, postActionSummary, constrainScreenshot, captureErrorScreenshot,
-		formatCompactStateSummary: u.formatCompactStateSummary, getRecentErrors: u.getRecentErrors,
-		settleAfterActionAdaptive, ensureMutationCounter, buildRefSnapshot, resolveRefTarget,
-		parseRef: u.parseRef, formatVersionedRef: u.formatVersionedRef, staleRefGuidance: u.staleRefGuidance,
-		beginTrackedAction: u.beginTrackedAction, finishTrackedAction: u.finishTrackedAction,
-		truncateText: u.truncateText, verificationFromChecks: u.verificationFromChecks,
-		verificationLine: u.verificationLine, collectAssertionState: (p, checks, target?) => u.collectAssertionState(p, checks, captureCompactPageState, target),
-		formatAssertionText: u.formatAssertionText, formatDiffText: u.formatDiffText,
-		getUrlHash: u.getUrlHash,
-		captureClickTargetState: u.captureClickTargetState, readInputLikeValue: u.readInputLikeValue,
-		firstErrorLine: u.firstErrorLine, captureAccessibilityMarkdown: (selector?) => u.captureAccessibilityMarkdown(getActiveTarget(), selector),
-		resolveAccessibilityScope: u.resolveAccessibilityScope,
-		getLivePagesSnapshot: u.createGetLivePagesSnapshot(ensureBrowser),
-		getSinceTimestamp: u.getSinceTimestamp, getConsoleEntriesSince: u.getConsoleEntriesSince,
-		getNetworkEntriesSince: u.getNetworkEntriesSince, writeArtifactFile: u.writeArtifactFile,
-		copyArtifactFile: u.copyArtifactFile, ensureSessionArtifactDir: u.ensureSessionArtifactDir,
-		buildSessionArtifactPath: u.buildSessionArtifactPath, getSessionArtifactMetadata: u.getSessionArtifactMetadata,
-		sanitizeArtifactName: u.sanitizeArtifactName, formatArtifactTimestamp: u.formatArtifactTimestamp,
-	};
-	registerNavigationTools(pi, deps);  registerScreenshotTools(pi, deps);
-	registerInteractionTools(pi, deps); registerInspectionTools(pi, deps);
-	registerSessionTools(pi, deps);     registerAssertionTools(pi, deps);
-	registerRefTools(pi, deps);         registerWaitTools(pi, deps);
-	registerPageTools(pi, deps);
-	registerFormTools(pi, deps);
-	registerIntentTools(pi, deps);
-	registerPdfTools(pi, deps);
-	registerStatePersistenceTools(pi, deps);
-	registerNetworkMockTools(pi, deps);
-	registerDeviceTools(pi, deps);
-	registerExtractTools(pi, deps);
-	registerVisualDiffTools(pi, deps);
-	registerZoomTools(pi, deps);
-	registerCodegenTools(pi, deps);
-	registerActionCacheTools(pi, deps);
-	registerInjectionDetectionTools(pi, deps);
+  pi.on("session_start", async (_event, ctx) => {
+    if (ctx.hasUI) {
+      void registerBrowserTools(pi).catch((error) => {
+        ctx.ui.notify(`browser-tools failed to load: ${error instanceof Error ? error.message : String(error)}`, "warning");
+      });
+      return;
+    }
+
+    await registerBrowserTools(pi);
+  });
+
+  pi.on("session_shutdown", async () => {
+    const { closeBrowser } = await importExtensionModule<typeof import("./lifecycle.js")>(import.meta.url, "./lifecycle.js");
+    await closeBrowser();
+  });
 }

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

@@ -1,5 +1,5 @@
 /**
- * Auto-mode Supervisor — SIGTERM handling and working-tree activity detection.
+ * Auto-mode Supervisor — signal handling and working-tree activity detection.
  *
  * Pure functions — no module-level globals or AutoContext dependency.
  */
@@ -8,10 +8,10 @@ import { clearLock } from "./crash-recovery.js";
 import { releaseSessionLock } from "./session-lock.js";
 import { nativeHasChanges } from "./native-git-bridge.js";
 
-// ─── SIGTERM Handling ─────────────────────────────────────────────────────────
+// ─── Signal Handling ──────────────────────────────────────────────────────────
 
 /**
- * Register a SIGTERM handler that clears the lock file and exits cleanly.
+ * Register SIGTERM and SIGINT handlers that clear lock files and exit cleanly.
  * Captures the active base path at registration time so the handler
  * always references the correct path even if the module variable changes.
  * Removes any previously registered handler before installing the new one.
@@ -22,20 +22,25 @@ export function registerSigtermHandler(
   currentBasePath: string,
   previousHandler: (() => void) | null,
 ): () => void {
-  if (previousHandler) process.off("SIGTERM", previousHandler);
+  if (previousHandler) {
+    process.off("SIGTERM", previousHandler);
+    process.off("SIGINT", previousHandler);
+  }
   const handler = () => {
     releaseSessionLock(currentBasePath);
     clearLock(currentBasePath);
     process.exit(0);
   };
   process.on("SIGTERM", handler);
+  process.on("SIGINT", handler);
   return handler;
 }
 
-/** Deregister the SIGTERM handler (called on stop/pause). */
+/** Deregister signal handlers (called on stop/pause). */
 export function deregisterSigtermHandler(handler: (() => void) | null): void {
   if (handler) {
     process.off("SIGTERM", handler);
+    process.off("SIGINT", handler);
   }
 }
 

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

@@ -175,7 +175,23 @@ export async function runPostUnitVerification(
       s.verificationRetryCount.delete(s.currentUnit.id);
       s.pendingVerificationRetry = null;
       return "continue";
-    } else if (result.discoverySource === "package-json") {
+    }
+
+    // Check if all failures are infra errors (ETIMEDOUT, ENOENT, etc.).
+    // Infra errors are transient OS-level problems the agent cannot fix —
+    // retrying the entire task is wasteful and creates phantom failures.
+    const failedChecks = result.checks.filter(c => c.exitCode !== 0);
+    const allInfraErrors = failedChecks.length > 0 && failedChecks.every(c => c.infraError === true);
+    if (allInfraErrors) {
+      const infraNames = failedChecks.map(f => f.command).join(", ");
+      ctx.ui.notify(`Verification gate: infra error (${infraNames}) — skipping retry, not a code issue`, "warning");
+      process.stderr.write(`verification-gate: all ${failedChecks.length} failure(s) are infra errors — treating as transient, no retry\n`);
+      s.verificationRetryCount.delete(s.currentUnit.id);
+      s.pendingVerificationRetry = null;
+      return "continue";
+    }
+
+    if (result.discoverySource === "package-json") {
       // Auto-discovered checks from package.json may fail on pre-existing errors
       // that the current task didn't introduce. Don't trigger the retry loop —
       // log a warning and let the task proceed (#1186).
@@ -189,7 +205,9 @@ export async function runPostUnitVerification(
       s.verificationRetryCount.delete(s.currentUnit.id);
       s.pendingVerificationRetry = null;
       return "continue";
-    } else if (autoFixEnabled && attempt + 1 <= maxRetries) {
+    }
+
+    if (autoFixEnabled && attempt + 1 <= maxRetries) {
       const nextAttempt = attempt + 1;
       s.verificationRetryCount.set(s.currentUnit.id, nextAttempt);
       s.pendingVerificationRetry = {

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

@@ -6,7 +6,7 @@
  * manages create, enter, detect, and teardown for auto-mode worktrees.
  */
 
-import { existsSync, readFileSync, realpathSync, unlinkSync, statSync, rmSync } from "node:fs";
+import { existsSync, readFileSync, realpathSync, unlinkSync, statSync, rmSync, readdirSync, cpSync, mkdirSync, lstatSync as lstatSyncFn } from "node:fs";
 import { isAbsolute, join, sep } from "node:path";
 import { GSDError, GSD_IO_ERROR, GSD_GIT_ERROR } from "./errors.js";
 import { execSync, execFileSync } from "node:child_process";
@@ -45,6 +45,123 @@ import { getErrorMessage } from "./error-utils.js";
 /** Original project root before chdir into auto-worktree. */
 let originalBase: string | null = null;
 
+// ─── Worktree ↔ Main Repo Sync (#1311) ──────────────────────────────────────
+
+/**
+ * Sync .gsd/ state from the main repo into the worktree.
+ *
+ * When .gsd/ is a symlink to the external state directory, both the main
+ * repo and worktree share the same directory — no sync needed.
+ *
+ * When .gsd/ is a real directory (e.g., git-tracked or manage_gitignore:false),
+ * the worktree has its own copy that may be stale. This function copies
+ * missing milestones, CONTEXT, ROADMAP, DECISIONS, REQUIREMENTS, and
+ * PROJECT files from the main repo's .gsd/ into the worktree's .gsd/.
+ *
+ * Only adds missing content — never overwrites existing files in the worktree
+ * (the worktree's execution state is authoritative for in-progress work).
+ */
+export function syncGsdStateToWorktree(mainBasePath: string, worktreePath_: string): { synced: string[] } {
+  const mainGsd = gsdRoot(mainBasePath);
+  const wtGsd = gsdRoot(worktreePath_);
+  const synced: string[] = [];
+
+  // If both resolve to the same directory (symlink), no sync needed
+  try {
+    const mainResolved = realpathSync(mainGsd);
+    const wtResolved = realpathSync(wtGsd);
+    if (mainResolved === wtResolved) return { synced };
+  } catch {
+    // Can't resolve — proceed with sync as a safety measure
+  }
+
+  if (!existsSync(mainGsd) || !existsSync(wtGsd)) return { synced };
+
+  // Sync root-level .gsd/ files (DECISIONS, REQUIREMENTS, PROJECT, KNOWLEDGE)
+  const rootFiles = ["DECISIONS.md", "REQUIREMENTS.md", "PROJECT.md", "KNOWLEDGE.md", "OVERRIDES.md"];
+  for (const f of rootFiles) {
+    const src = join(mainGsd, f);
+    const dst = join(wtGsd, f);
+    if (existsSync(src) && !existsSync(dst)) {
+      try {
+        cpSync(src, dst);
+        synced.push(f);
+      } catch { /* non-fatal */ }
+    }
+  }
+
+  // Sync milestones: copy entire milestone directories that are missing
+  const mainMilestonesDir = join(mainGsd, "milestones");
+  const wtMilestonesDir = join(wtGsd, "milestones");
+  if (existsSync(mainMilestonesDir)) {
+    try {
+      mkdirSync(wtMilestonesDir, { recursive: true });
+      const mainMilestones = readdirSync(mainMilestonesDir, { withFileTypes: true })
+        .filter(d => d.isDirectory() && /^M\d{3}/.test(d.name))
+        .map(d => d.name);
+
+      for (const mid of mainMilestones) {
+        const srcDir = join(mainMilestonesDir, mid);
+        const dstDir = join(wtMilestonesDir, mid);
+
+        if (!existsSync(dstDir)) {
+          // Entire milestone missing from worktree — copy it
+          try {
+            cpSync(srcDir, dstDir, { recursive: true });
+            synced.push(`milestones/${mid}/`);
+          } catch { /* non-fatal */ }
+        } else {
+          // Milestone directory exists but may be missing files (stale snapshot).
+          // Sync individual top-level milestone files (CONTEXT, ROADMAP, RESEARCH, etc.)
+          try {
+            const srcFiles = readdirSync(srcDir).filter(f => f.endsWith(".md") || f.endsWith(".json"));
+            for (const f of srcFiles) {
+              const srcFile = join(srcDir, f);
+              const dstFile = join(dstDir, f);
+              if (!existsSync(dstFile)) {
+                try {
+                  const srcStat = lstatSyncFn(srcFile);
+                  if (srcStat.isFile()) {
+                    cpSync(srcFile, dstFile);
+                    synced.push(`milestones/${mid}/${f}`);
+                  }
+                } catch { /* non-fatal */ }
+              }
+            }
+
+            // Sync slices directory if it exists in main but not in worktree
+            const srcSlicesDir = join(srcDir, "slices");
+            const dstSlicesDir = join(dstDir, "slices");
+            if (existsSync(srcSlicesDir) && !existsSync(dstSlicesDir)) {
+              try {
+                cpSync(srcSlicesDir, dstSlicesDir, { recursive: true });
+                synced.push(`milestones/${mid}/slices/`);
+              } catch { /* non-fatal */ }
+            } else if (existsSync(srcSlicesDir) && existsSync(dstSlicesDir)) {
+              // Both exist — sync missing slice directories
+              const srcSlices = readdirSync(srcSlicesDir, { withFileTypes: true })
+                .filter(d => d.isDirectory())
+                .map(d => d.name);
+              for (const sid of srcSlices) {
+                const srcSlice = join(srcSlicesDir, sid);
+                const dstSlice = join(dstSlicesDir, sid);
+                if (!existsSync(dstSlice)) {
+                  try {
+                    cpSync(srcSlice, dstSlice, { recursive: true });
+                    synced.push(`milestones/${mid}/slices/${sid}/`);
+                  } catch { /* non-fatal */ }
+                }
+              }
+            }
+          } catch { /* non-fatal */ }
+        }
+      }
+    } catch { /* non-fatal */ }
+  }
+
+  return { synced };
+}
+
 // ─── Worktree Post-Create Hook (#597) ────────────────────────────────────────
 
 /**
@@ -125,6 +242,12 @@ export function createAutoWorktree(basePath: string, milestoneId: string): strin
   // Ensure worktree shares external state via symlink
   ensureGsdSymlink(info.path);
 
+  // Sync .gsd/ state from main repo into the worktree (#1311).
+  // Even with the symlink, the worktree may have stale git-tracked files
+  // if .gsd/ is not gitignored. And on fresh create, the milestone files
+  // created on main since the branch point won't be in the worktree.
+  syncGsdStateToWorktree(basePath, info.path);
+
   // Run user-configured post-create hook (#597) — e.g. copy .env, symlink assets
   const hookError = runWorktreePostCreateHook(basePath, info.path);
   if (hookError) {
@@ -267,6 +390,18 @@ export function enterAutoWorktree(basePath: string, milestoneId: string): string
     throw new GSDError(GSD_IO_ERROR, `Auto-worktree path ${p} exists but .git is unreadable`);
   }
 
+  // Ensure worktree shares external state via symlink (#1311).
+  // On resume (enterAutoWorktree), the symlink may be missing if it was
+  // created before ensureGsdSymlink existed, or the .gsd/ directory may be
+  // a stale git-tracked copy instead of a symlink. Refreshing here ensures
+  // the worktree sees the same milestone state as the main repo.
+  ensureGsdSymlink(p);
+
+  // Sync .gsd/ state from main repo into worktree (#1311).
+  // Covers the case where .gsd/ is a real directory (not symlinked) and
+  // milestones were created on main after the worktree was last used.
+  syncGsdStateToWorktree(basePath, p);
+
   const previousCwd = process.cwd();
 
   try {