gsd-pi 2.78.0 → 2.78.1-dev.8a893322c

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

@@ -33,29 +33,21 @@ import { inferCommitType } from "./git-service.js";
 import type { FileLineStat } from "./worktree-manager.js";
 import { existsSync, realpathSync, readdirSync, rmSync, unlinkSync } from "node:fs";
 import { nativeMergeAbort } from "./native-git-bridge.js";
-import { join, sep } from "node:path";
+import { join } from "node:path";
+import {
+  clearWorktreeOriginalCwd,
+  ensureWorktreeOriginalCwdFromPath,
+  getActiveWorktreeName,
+  getWorktreeOriginalCwd,
+  setWorktreeOriginalCwd,
+} from "./worktree-session-state.js";
+
+export { getActiveWorktreeName, getWorktreeOriginalCwd } from "./worktree-session-state.js";
 
 /**
  * Tracks the original project root so we can switch back.
  * Set when we first chdir into a worktree, cleared on return.
  */
-let originalCwd: string | null = null;
-
-/** Get the original project root if currently in a worktree, or null. */
-export function getWorktreeOriginalCwd(): string | null {
-  return originalCwd;
-}
-
-/** Get the name of the active worktree, or null if not in one. */
-export function getActiveWorktreeName(): string | null {
-  if (!originalCwd) return null;
-  const cwd = process.cwd();
-  const wtDir = join(originalCwd, ".gsd", "worktrees");
-  if (!cwd.startsWith(wtDir)) return null;
-  const rel = cwd.slice(wtDir.length + 1);
-  const name = rel.split("/")[0] ?? rel.split("\\")[0];
-  return name || null;
-}
 
 // ─── Shared completions and handler (used by both /worktree and /wt) ────────
 
@@ -145,7 +137,7 @@ async function worktreeHandler(
       return;
     }
     // create and switch both do the same thing: switch if exists, create if not
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
     const existing = listWorktrees(mainBase);
     if (existing.some(wt => wt.name === name)) {
       await handleSwitch(basePath, name, ctx);
@@ -157,7 +149,7 @@ async function worktreeHandler(
 
   if (trimmed === "merge" || trimmed.startsWith("merge ")) {
     const mergeArgs = trimmed.replace(/^merge\s*/, "").trim().split(/\s+/).filter(Boolean);
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
     const activeWt = getActiveWorktreeName();
 
     if (mergeArgs.length === 0) {
@@ -191,7 +183,7 @@ async function worktreeHandler(
 
   if (trimmed === "remove" || trimmed.startsWith("remove ")) {
     const name = trimmed.replace(/^remove\s*/, "").trim();
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
 
     if (name === "all") {
       await handleRemoveAll(mainBase, ctx);
@@ -213,7 +205,7 @@ async function worktreeHandler(
     return;
   }
 
-  const mainBase = originalCwd ?? basePath;
+  const mainBase = getWorktreeOriginalCwd() ?? basePath;
   const nameOnly = trimmed.split(/\s+/)[0]!;
   if (trimmed !== nameOnly) {
     ctx.ui.notify(`Unknown command. Did you mean /${alias} switch ${nameOnly}?`, "warning");
@@ -241,14 +233,7 @@ export function registerWorktreeCommand(pi: ExtensionAPI): void {
   // Restore worktree state after /reload.
   // The module-level originalCwd resets to null when extensions are re-loaded,
   // but process.cwd() is still inside the worktree. Detect this and recover.
-  if (!originalCwd) {
-    const cwd = process.cwd();
-    const marker = `${sep}.gsd${sep}worktrees${sep}`;
-    const markerIdx = cwd.indexOf(marker);
-    if (markerIdx !== -1) {
-      originalCwd = cwd.slice(0, markerIdx);
-    }
-  }
+  ensureWorktreeOriginalCwdFromPath();
 
   pi.registerCommand("worktree", {
     description: "Git worktrees (also /wt): /worktree <name> | list | merge | remove",
@@ -320,7 +305,7 @@ async function handleCreate(
     const commitMsg = autoCommitCurrentBranch(basePath, "worktree-switch", name);
 
     // Create from the main tree, not from inside another worktree
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
     const info = createWorktree(mainBase, name);
 
     // Run user-configured post-create hook (#597) — e.g. copy .env, symlink assets
@@ -330,7 +315,7 @@ async function handleCreate(
     }
 
     // Track original cwd before switching
-    if (!originalCwd) originalCwd = basePath;
+    if (!getWorktreeOriginalCwd()) setWorktreeOriginalCwd(basePath);
 
     const prevCwd = process.cwd();
     process.chdir(info.path);
@@ -390,7 +375,7 @@ async function handleSwitch(
   ctx: ExtensionCommandContext,
 ): Promise<void> {
   try {
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
     const wtPath = worktreePath(mainBase, name);
 
     if (!existsSync(wtPath)) {
@@ -405,7 +390,7 @@ async function handleSwitch(
     const commitMsg = autoCommitCurrentBranch(basePath, "worktree-switch", name);
 
     // Track original cwd before switching
-    if (!originalCwd) originalCwd = basePath;
+    if (!getWorktreeOriginalCwd()) setWorktreeOriginalCwd(basePath);
 
     const prevCwd = process.cwd();
     process.chdir(wtPath);
@@ -433,6 +418,7 @@ async function handleSwitch(
 }
 
 async function handleReturn(ctx: ExtensionCommandContext): Promise<void> {
+  const originalCwd = getWorktreeOriginalCwd();
   if (!originalCwd) {
     ctx.ui.notify("Already in the main project tree.", "info");
     return;
@@ -442,7 +428,7 @@ async function handleReturn(ctx: ExtensionCommandContext): Promise<void> {
   const commitMsg = autoCommitCurrentBranch(process.cwd(), "worktree-return", "worktree");
 
   const returnTo = originalCwd;
-  originalCwd = null;
+  clearWorktreeOriginalCwd();
 
   const prevCwd = process.cwd();
   process.chdir(returnTo);
@@ -504,7 +490,7 @@ async function handleList(
   ctx: ExtensionCommandContext,
 ): Promise<void> {
   try {
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
     const worktrees = listWorktrees(mainBase);
 
     if (worktrees.length === 0) {
@@ -552,6 +538,7 @@ async function handleList(
       lines.push("");
     }
 
+    const originalCwd = getWorktreeOriginalCwd();
     if (originalCwd) {
       lines.push(`  ${CLR.label("main tree")}  ${CLR.path(originalCwd)}`);
     }
@@ -651,11 +638,11 @@ async function handleMerge(
 
     // Switch to the main tree before merging.
     // Must be on the main branch to run git merge --squash.
-    if (originalCwd) {
+    if (getWorktreeOriginalCwd()) {
       const prevCwd = process.cwd();
       process.chdir(basePath);
       nudgeGitBranchCache(prevCwd);
-      originalCwd = null;
+      clearWorktreeOriginalCwd();
     }
 
     // --- Deterministic merge path (preferred) ---
@@ -754,7 +741,7 @@ async function handleRemove(
   ctx: ExtensionCommandContext,
 ): Promise<void> {
   try {
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
 
     // Validate the worktree exists before attempting removal
     const worktrees = listWorktrees(mainBase);
@@ -779,9 +766,9 @@ async function handleRemove(
     removeWorktree(mainBase, name, { deleteBranch: true });
 
     // If we were in that worktree, removeWorktree chdir'd us out — clear tracking
-    if (originalCwd && process.cwd() !== prevCwd) {
+    if (getWorktreeOriginalCwd() && process.cwd() !== prevCwd) {
       nudgeGitBranchCache(prevCwd);
-      originalCwd = null;
+      clearWorktreeOriginalCwd();
     }
 
     ctx.ui.notify(`${CLR.ok("✓")} Worktree ${CLR.name(name)} removed ${CLR.muted("(branch deleted)")}.`, "info");
@@ -796,7 +783,7 @@ async function handleRemoveAll(
   ctx: ExtensionCommandContext,
 ): Promise<void> {
   try {
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
     const worktrees = listWorktrees(mainBase);
 
     if (worktrees.length === 0) {
@@ -830,9 +817,9 @@ async function handleRemoveAll(
     }
 
     // If we were in a worktree that got removed, clear tracking
-    if (originalCwd && process.cwd() !== prevCwd) {
+    if (getWorktreeOriginalCwd() && process.cwd() !== prevCwd) {
       nudgeGitBranchCache(prevCwd);
-      originalCwd = null;
+      clearWorktreeOriginalCwd();
     }
 
     const lines: string[] = [];

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

@@ -39,6 +39,11 @@ import {
   nativeWorktreeRemove,
 } from "./native-git-bridge.js";
 import { emitCanonicalRootRedirect } from "./worktree-telemetry.js";
+import {
+  isGsdWorktreePath,
+  normalizeWorktreePathForCompare,
+  resolveWorktreeProjectRoot,
+} from "./worktree-root.js";
 
 // ─── Types ─────────────────────────────────────────────────────────────────
 
@@ -75,6 +80,20 @@ function normalizePathForComparison(path: string): string {
   return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
 
+function normalizeBasePathForWorktreeOps(basePath: string): string {
+  const resolved = resolveWorktreeProjectRoot(basePath);
+  if (
+    isGsdWorktreePath(basePath) &&
+    normalizeWorktreePathForCompare(resolved) === normalizeWorktreePathForCompare(basePath)
+  ) {
+    throw new GSDError(
+      GSD_GIT_ERROR,
+      `Cannot resolve project root from worktree path: ${basePath}. Run the command from the project root or set GSD_PROJECT_ROOT.`,
+    );
+  }
+  return resolved;
+}
+
 // ─── resolveGitDir ─────────────────────────────────────────────────────────
 
 /**
@@ -106,7 +125,7 @@ export function resolveGitDir(basePath: string): string {
 }
 
 export function worktreesDir(basePath: string): string {
-  return join(basePath, ".gsd", "worktrees");
+  return join(resolveWorktreeProjectRoot(basePath), ".gsd", "worktrees");
 }
 
 export function worktreePath(basePath: string, name: string): string {
@@ -195,6 +214,8 @@ export function resolveCanonicalMilestoneRoot(
  * @param opts.branch — override the default `worktree/<name>` branch name
  */
 export function createWorktree(basePath: string, name: string, opts: { branch?: string; startPoint?: string; reuseExistingBranch?: boolean } = {}): WorktreeInfo {
+  basePath = normalizeBasePathForWorktreeOps(basePath);
+
   // Validate name: alphanumeric, hyphens, underscores only
   if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
     throw new GSDError(GSD_PARSE_ERROR, `Invalid worktree name "${name}". Use only letters, numbers, hyphens, and underscores.`);
@@ -297,6 +318,8 @@ export function createWorktree(basePath: string, name: string, opts: { branch?:
  * Uses native worktree list and filters to those under .gsd/worktrees/.
  */
 export function listWorktrees(basePath: string): WorktreeInfo[] {
+  basePath = normalizeBasePathForWorktreeOps(basePath);
+
   const baseVariants = [resolve(basePath)];
   if (existsSync(basePath)) {
     baseVariants.push(realpathSync(basePath));
@@ -459,6 +482,8 @@ export function removeWorktree(
   name: string,
   opts: { deleteBranch?: boolean; force?: boolean; branch?: string } = {},
 ): void {
+  basePath = normalizeBasePathForWorktreeOps(basePath);
+
   let wtPath = worktreePath(basePath, name);
   const branch = opts.branch ?? worktreeBranchName(name);
   const { deleteBranch = true, force = true } = opts;
@@ -714,6 +739,8 @@ function parseDiffNameStatus(entries: { status: string; path: string }[]): Workt
  * Returns a summary of added, modified, and removed GSD artifacts.
  */
 export function diffWorktreeGSD(basePath: string, name: string): WorktreeDiffSummary {
+  basePath = normalizeBasePathForWorktreeOps(basePath);
+
   const branch = worktreeBranchName(name);
   const mainBranch = nativeDetectMainBranch(basePath);
 
@@ -729,6 +756,8 @@ export function diffWorktreeGSD(basePath: string, name: string): WorktreeDiffSum
  * content, this correctly returns an empty diff.
  */
 export function diffWorktreeAll(basePath: string, name: string): WorktreeDiffSummary {
+  basePath = normalizeBasePathForWorktreeOps(basePath);
+
   const branch = worktreeBranchName(name);
   const mainBranch = nativeDetectMainBranch(basePath);
 
@@ -742,6 +771,8 @@ export function diffWorktreeAll(basePath: string, name: string): WorktreeDiffSum
  * Uses direct diff (not merge-base) so the preview matches the actual merge outcome.
  */
 export function diffWorktreeNumstat(basePath: string, name: string): FileLineStat[] {
+  basePath = normalizeBasePathForWorktreeOps(basePath);
+
   const branch = worktreeBranchName(name);
   const mainBranch = nativeDetectMainBranch(basePath);
 
@@ -760,6 +791,8 @@ export function diffWorktreeNumstat(basePath: string, name: string): FileLineSta
  * Returns the raw unified diff for LLM consumption.
  */
 export function getWorktreeGSDDiff(basePath: string, name: string): string {
+  basePath = normalizeBasePathForWorktreeOps(basePath);
+
   const branch = worktreeBranchName(name);
   const mainBranch = nativeDetectMainBranch(basePath);
 
@@ -771,6 +804,8 @@ export function getWorktreeGSDDiff(basePath: string, name: string): string {
  * Returns the raw unified diff for LLM consumption.
  */
 export function getWorktreeCodeDiff(basePath: string, name: string): string {
+  basePath = normalizeBasePathForWorktreeOps(basePath);
+
   const branch = worktreeBranchName(name);
   const mainBranch = nativeDetectMainBranch(basePath);
 
@@ -781,6 +816,8 @@ export function getWorktreeCodeDiff(basePath: string, name: string): string {
  * Get commit log for the worktree branch since it diverged from main.
  */
 export function getWorktreeLog(basePath: string, name: string): string {
+  basePath = normalizeBasePathForWorktreeOps(basePath);
+
   const branch = worktreeBranchName(name);
   const mainBranch = nativeDetectMainBranch(basePath);
 
@@ -795,6 +832,8 @@ export function getWorktreeLog(basePath: string, name: string): string {
  * Returns the merge commit message.
  */
 export function mergeWorktreeToMain(basePath: string, name: string, commitMessage: string): string {
+  basePath = normalizeBasePathForWorktreeOps(basePath);
+
   const branch = worktreeBranchName(name);
   const mainBranch = nativeDetectMainBranch(basePath);
   const current = nativeGetCurrentBranch(basePath);

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

@@ -23,6 +23,7 @@ import { emitJournalEvent } from "./journal.js";
 import { emitWorktreeCreated, emitWorktreeMerged } from "./worktree-telemetry.js";
 import { getCollapseCadence, getMilestoneResquash, resquashMilestoneOnMain } from "./slice-cadence.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { resolveWorktreeProjectRoot } from "./worktree-root.js";
 
 // ─── Dependency Interface ──────────────────────────────────────────────────
 
@@ -84,31 +85,20 @@ export interface NotifyCtx {
 
 // ─── Path Helpers ──────────────────────────────────────────────────────────
 
-/**
- * Worktree marker segment — present in any path produced by worktreePath().
- * Used to strip the worktree suffix and recover the project root (#3729).
- */
-const WORKTREE_MARKER = "/.gsd/worktrees/";
-
 /**
  * Resolve the project root from session path state.
  *
  * Prefers `originalBasePath` (always the project root when set), but falls
  * back to `basePath` when `originalBasePath` is falsy (e.g. fresh AutoSession
  * with default empty string). If `basePath` itself is inside a worktree
- * directory (contains `/.gsd/worktrees/`), strip that suffix to recover the
- * actual project root — preventing double-nested worktree paths (#3729).
+ * directory (including symlink-resolved ~/.gsd/projects/<hash>/worktrees
+ * paths), recover the actual project root to prevent double nesting (#3729).
  */
 export function resolveProjectRoot(
   originalBasePath: string,
   basePath: string,
 ): string {
-  let resolved = originalBasePath || basePath;
-  const markerIdx = resolved.indexOf(WORKTREE_MARKER);
-  if (markerIdx !== -1) {
-    resolved = resolved.slice(0, markerIdx);
-  }
-  return resolved;
+  return resolveWorktreeProjectRoot(basePath, originalBasePath);
 }
 
 // ─── WorktreeResolver ──────────────────────────────────────────────────────

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

@@ -0,0 +1,144 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+export interface WorktreeSegment {
+  gsdIdx: number;
+  afterWorktrees: number;
+}
+
+export function normalizeWorktreePathForCompare(path: string): string {
+  let normalized: string;
+  try {
+    normalized = realpathSync(path);
+  } catch {
+    normalized = resolve(path);
+  }
+  const slashed = normalized.replaceAll("\\", "/");
+  const trimmed = slashed.replace(/\/+$/, "");
+  return process.platform === "win32" ? (trimmed || "/").toLowerCase() : (trimmed || "/");
+}
+
+/**
+ * Find the GSD worktree segment in both direct project layout and the
+ * symlink-resolved external-state layout used by ~/.gsd/projects/<hash>.
+ */
+export function findWorktreeSegment(normalizedPath: string): WorktreeSegment | null {
+  const directMarker = "/.gsd/worktrees/";
+  const directIdx = normalizedPath.indexOf(directMarker);
+  if (directIdx !== -1) {
+    return { gsdIdx: directIdx, afterWorktrees: directIdx + directMarker.length };
+  }
+
+  const externalRe = /\/\.gsd\/projects\/[^/]+\/worktrees\//;
+  const externalMatch = normalizedPath.match(externalRe);
+  if (externalMatch && externalMatch.index !== undefined) {
+    return {
+      gsdIdx: externalMatch.index,
+      afterWorktrees: externalMatch.index + externalMatch[0].length,
+    };
+  }
+
+  return null;
+}
+
+export function isGsdWorktreePath(path: string): boolean {
+  return findWorktreeSegment(path.replaceAll("\\", "/")) !== null;
+}
+
+/**
+ * Resolve the canonical project root for worktree operations.
+ *
+ * `originalBasePath` wins when available because session state already knows the
+ * root. `GSD_PROJECT_ROOT` is the next strongest signal for worker processes.
+ * Otherwise, derive the root from direct `.gsd/worktrees` paths, or recover it
+ * from the worktree `.git` file for symlink-resolved ~/.gsd/project paths.
+ */
+export function resolveWorktreeProjectRoot(
+  basePath: string,
+  originalBasePath?: string | null,
+): string {
+  const preferred =
+    originalBasePath?.trim() ||
+    process.env.GSD_PROJECT_ROOT?.trim() ||
+    basePath;
+
+  return resolveProjectRootFromPath(preferred);
+}
+
+function resolveProjectRootFromPath(path: string): string {
+  const normalizedPath = path.replaceAll("\\", "/");
+  const segment = findWorktreeSegment(normalizedPath);
+  if (!segment) return resolveGitWorkingTreeRoot(path) ?? path;
+
+  const sepChar = path.includes("\\") ? "\\" : "/";
+  const gsdMarker = `${sepChar}.gsd${sepChar}`;
+  const markerIdx = path.indexOf(gsdMarker);
+  const candidate = markerIdx !== -1
+    ? path.slice(0, markerIdx)
+    : path.slice(0, segment.gsdIdx);
+
+  const gsdHome = normalizeWorktreePathForCompare(process.env.GSD_HOME || join(homedir(), ".gsd"));
+  const candidateGsdPath = normalizeWorktreePathForCompare(join(candidate, ".gsd"));
+
+  if (candidateGsdPath === gsdHome || candidateGsdPath.startsWith(`${gsdHome}/`)) {
+    const realRoot = resolveProjectRootFromGitFile(path);
+    return realRoot ?? path;
+  }
+
+  return candidate;
+}
+
+function resolveGitWorkingTreeRoot(path: string): string | null {
+  try {
+    let dir = existsSync(path) && !statSync(path).isDirectory()
+      ? resolve(path, "..")
+      : path;
+
+    for (let i = 0; i < 30; i++) {
+      const gitPath = join(dir, ".git");
+      if (existsSync(gitPath)) return dir;
+
+      const parent = resolve(dir, "..");
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+    // Non-fatal: callers either keep the original path or fail closed.
+  }
+  return null;
+}
+
+function resolveProjectRootFromGitFile(worktreePath: string): string | null {
+  try {
+    let dir = worktreePath;
+    for (let i = 0; i < 30; i++) {
+      const gitPath = join(dir, ".git");
+      if (existsSync(gitPath)) {
+        const content = readFileSync(gitPath, "utf8").trim();
+        if (content.startsWith("gitdir: ")) {
+          const gitDir = resolve(dir, content.slice(8));
+          const dotGitDir = resolve(gitDir, "..", "..");
+          if (dotGitDir.endsWith(".git") || dotGitDir.endsWith(".git/") || dotGitDir.endsWith(".git\\")) {
+            return resolve(dotGitDir, "..");
+          }
+
+          const commonDirPath = join(gitDir, "commondir");
+          if (existsSync(commonDirPath)) {
+            const commonDir = readFileSync(commonDirPath, "utf8").trim();
+            const resolvedCommonDir = resolve(gitDir, commonDir);
+            return resolve(resolvedCommonDir, "..");
+          }
+        }
+        break;
+      }
+
+      const parent = resolve(dir, "..");
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+    // Non-fatal: callers either keep the original path or fail closed.
+  }
+  return null;
+}

package/src/resources/extensions/gsd/worktree-session-state.ts

@@ -0,0 +1,35 @@
+// GSD worktree session state
+let originalCwd: string | null = null;
+
+export function getWorktreeOriginalCwd(): string | null {
+  return originalCwd;
+}
+
+export function setWorktreeOriginalCwd(cwd: string): void {
+  originalCwd = cwd;
+}
+
+export function clearWorktreeOriginalCwd(): void {
+  originalCwd = null;
+}
+
+export function ensureWorktreeOriginalCwdFromPath(cwd: string = process.cwd()): string | null {
+  if (originalCwd) return originalCwd;
+  const marker = `${/\\/.test(cwd) ? "\\" : "/"}.gsd${/\\/.test(cwd) ? "\\" : "/"}worktrees${/\\/.test(cwd) ? "\\" : "/"}`;
+  const markerIdx = cwd.indexOf(marker);
+  if (markerIdx !== -1) {
+    originalCwd = cwd.slice(0, markerIdx);
+  }
+  return originalCwd;
+}
+
+export function getActiveWorktreeName(): string | null {
+  if (!originalCwd) return null;
+  const cwd = process.cwd();
+  const wtDir = `${originalCwd.replace(/[\\/]+$/, "")}/.gsd/worktrees`.replaceAll("\\", "/");
+  const normalizedCwd = cwd.replaceAll("\\", "/");
+  if (!normalizedCwd.startsWith(`${wtDir}/`)) return null;
+  const rel = normalizedCwd.slice(wtDir.length + 1);
+  const name = rel.split("/")[0];
+  return name || null;
+}