gsd-pi 2.78.0 → 2.78.1-dev.82bcf6b71

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

@@ -18,28 +18,13 @@ import { createWorktree, listWorktrees, removeWorktree, mergeWorktreeToMain, dif
 import { inferCommitType } from "./git-service.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 = null;
-/** Get the original project root if currently in a worktree, or null. */
-export function getWorktreeOriginalCwd() {
-    return originalCwd;
-}
-/** Get the name of the active worktree, or null if not in one. */
-export function getActiveWorktreeName() {
-    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) ────────
 function worktreeCompletions(prefix) {
     const parts = prefix.trim().split(/\s+/);
@@ -111,7 +96,7 @@ async function worktreeHandler(args, ctx, pi, alias) {
             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);
@@ -123,7 +108,7 @@ async function worktreeHandler(args, ctx, pi, alias) {
     }
     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) {
             // Bare "/worktree merge" — only valid when inside a worktree
@@ -154,7 +139,7 @@ async function worktreeHandler(args, ctx, pi, alias) {
     }
     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);
             return;
@@ -171,7 +156,7 @@ async function worktreeHandler(args, ctx, pi, alias) {
         ctx.ui.notify(`Usage: /${alias} ${trimmed}${trimmed === "list" || trimmed === "return" ? "" : " <name>"}`, "warning");
         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");
@@ -192,14 +177,7 @@ export function registerWorktreeCommand(pi) {
     // 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",
         getArgumentCompletions: worktreeCompletions,
@@ -260,7 +238,7 @@ async function handleCreate(basePath, name, ctx) {
         // before createWorktree so the new worktree forks from committed HEAD)
         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
         const hookError = runWorktreePostCreateHook(mainBase, info.path);
@@ -268,8 +246,8 @@ async function handleCreate(basePath, name, ctx) {
             ctx.ui.notify(hookError, "warning");
         }
         // Track original cwd before switching
-        if (!originalCwd)
-            originalCwd = basePath;
+        if (!getWorktreeOriginalCwd())
+            setWorktreeOriginalCwd(basePath);
         const prevCwd = process.cwd();
         process.chdir(info.path);
         nudgeGitBranchCache(prevCwd);
@@ -319,7 +297,7 @@ async function handleCreate(basePath, name, ctx) {
 }
 async function handleSwitch(basePath, name, ctx) {
     try {
-        const mainBase = originalCwd ?? basePath;
+        const mainBase = getWorktreeOriginalCwd() ?? basePath;
         const wtPath = worktreePath(mainBase, name);
         if (!existsSync(wtPath)) {
             ctx.ui.notify(`Worktree "${name}" not found. Run /worktree list to see available worktrees.`, "warning");
@@ -328,8 +306,8 @@ async function handleSwitch(basePath, name, ctx) {
         // Auto-commit dirty files before leaving current workspace
         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);
         nudgeGitBranchCache(prevCwd);
@@ -352,6 +330,7 @@ async function handleSwitch(basePath, name, ctx) {
     }
 }
 async function handleReturn(ctx) {
+    const originalCwd = getWorktreeOriginalCwd();
     if (!originalCwd) {
         ctx.ui.notify("Already in the main project tree.", "info");
         return;
@@ -359,7 +338,7 @@ async function handleReturn(ctx) {
     // Auto-commit dirty files before leaving worktree
     const commitMsg = autoCommitCurrentBranch(process.cwd(), "worktree-return", "worktree");
     const returnTo = originalCwd;
-    originalCwd = null;
+    clearWorktreeOriginalCwd();
     const prevCwd = process.cwd();
     process.chdir(returnTo);
     nudgeGitBranchCache(prevCwd);
@@ -409,7 +388,7 @@ const CLR = {
 };
 async function handleList(basePath, ctx) {
     try {
-        const mainBase = originalCwd ?? basePath;
+        const mainBase = getWorktreeOriginalCwd() ?? basePath;
         const worktrees = listWorktrees(mainBase);
         if (worktrees.length === 0) {
             ctx.ui.notify("No GSD worktrees found. Create one with /worktree <name>.", "info");
@@ -452,6 +431,7 @@ async function handleList(basePath, ctx) {
             }
             lines.push("");
         }
+        const originalCwd = getWorktreeOriginalCwd();
         if (originalCwd) {
             lines.push(`  ${CLR.label("main tree")}  ${CLR.path(originalCwd)}`);
         }
@@ -539,11 +519,11 @@ async function handleMerge(basePath, name, ctx, pi, targetBranch) {
         }
         // 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) ---
         // Try a direct squash-merge first. Only fall back to LLM on conflict.
@@ -620,7 +600,7 @@ async function handleMerge(basePath, name, ctx, pi, targetBranch) {
 }
 async function handleRemove(basePath, name, ctx) {
     try {
-        const mainBase = originalCwd ?? basePath;
+        const mainBase = getWorktreeOriginalCwd() ?? basePath;
         // Validate the worktree exists before attempting removal
         const worktrees = listWorktrees(mainBase);
         const wt = worktrees.find(w => w.name === name);
@@ -641,9 +621,9 @@ async function handleRemove(basePath, name, ctx) {
         const prevCwd = process.cwd();
         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");
     }
@@ -654,7 +634,7 @@ async function handleRemove(basePath, name, ctx) {
 }
 async function handleRemoveAll(basePath, ctx) {
     try {
-        const mainBase = originalCwd ?? basePath;
+        const mainBase = getWorktreeOriginalCwd() ?? basePath;
         const worktrees = listWorktrees(mainBase);
         if (worktrees.length === 0) {
             ctx.ui.notify("No worktrees to remove.", "info");
@@ -684,9 +664,9 @@ async function handleRemoveAll(basePath, ctx) {
             }
         }
         // 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 = [];
         if (removed.length > 0)

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

@@ -21,6 +21,7 @@ import { GSDError, GSD_PARSE_ERROR, GSD_STALE_STATE, GSD_LOCK_HELD, GSD_GIT_ERRO
 import { logWarning } from "./workflow-logger.js";
 import { nativeBranchDelete, nativeBranchExists, nativeBranchForceReset, nativeCommit, nativeDetectMainBranch, nativeDiffContent, nativeDiffNameStatus, nativeDiffNumstat, nativeGetCurrentBranch, nativeIsAncestor, nativeLogOneline, nativeMergeSquash, nativeWorktreeAdd, nativeWorktreeList, nativeWorktreePrune, nativeWorktreeRemove, } from "./native-git-bridge.js";
 import { emitCanonicalRootRedirect } from "./worktree-telemetry.js";
+import { isGsdWorktreePath, normalizeWorktreePathForCompare, resolveWorktreeProjectRoot, } from "./worktree-root.js";
 // ─── Path Helpers ──────────────────────────────────────────────────────────
 function normalizePathForComparison(path) {
     const normalized = path
@@ -29,6 +30,14 @@ function normalizePathForComparison(path) {
         .replace(/\/+$/, "");
     return process.platform === "win32" ? normalized.toLowerCase() : normalized;
 }
+function normalizeBasePathForWorktreeOps(basePath) {
+    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 ─────────────────────────────────────────────────────────
 /**
  * Resolve the actual git directory for a given repository path.
@@ -61,7 +70,7 @@ export function resolveGitDir(basePath) {
     return gitPath;
 }
 export function worktreesDir(basePath) {
-    return join(basePath, ".gsd", "worktrees");
+    return join(resolveWorktreeProjectRoot(basePath), ".gsd", "worktrees");
 }
 export function worktreePath(basePath, name) {
     return join(worktreesDir(basePath), name);
@@ -143,6 +152,7 @@ export function resolveCanonicalMilestoneRoot(basePath, milestoneId) {
  * @param opts.branch — override the default `worktree/<name>` branch name
  */
 export function createWorktree(basePath, name, opts = {}) {
+    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.`);
@@ -227,6 +237,7 @@ export function createWorktree(basePath, name, opts = {}) {
  * Uses native worktree list and filters to those under .gsd/worktrees/.
  */
 export function listWorktrees(basePath) {
+    basePath = normalizeBasePathForWorktreeOps(basePath);
     const baseVariants = [resolve(basePath)];
     if (existsSync(basePath)) {
         baseVariants.push(realpathSync(basePath));
@@ -366,6 +377,7 @@ export function findNestedGitDirs(rootPath) {
  * If the process is currently inside the worktree, chdir out first.
  */
 export function removeWorktree(basePath, name, opts = {}) {
+    basePath = normalizeBasePathForWorktreeOps(basePath);
     let wtPath = worktreePath(basePath, name);
     const branch = opts.branch ?? worktreeBranchName(name);
     const { deleteBranch = true, force = true } = opts;
@@ -614,6 +626,7 @@ function parseDiffNameStatus(entries) {
  * Returns a summary of added, modified, and removed GSD artifacts.
  */
 export function diffWorktreeGSD(basePath, name) {
+    basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = worktreeBranchName(name);
     const mainBranch = nativeDetectMainBranch(basePath);
     const entries = nativeDiffNameStatus(basePath, mainBranch, branch, ".gsd/", true);
@@ -626,6 +639,7 @@ export function diffWorktreeGSD(basePath, name) {
  * content, this correctly returns an empty diff.
  */
 export function diffWorktreeAll(basePath, name) {
+    basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = worktreeBranchName(name);
     const mainBranch = nativeDetectMainBranch(basePath);
     const entries = nativeDiffNameStatus(basePath, mainBranch, branch);
@@ -636,6 +650,7 @@ export function diffWorktreeAll(basePath, name) {
  * Uses direct diff (not merge-base) so the preview matches the actual merge outcome.
  */
 export function diffWorktreeNumstat(basePath, name) {
+    basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = worktreeBranchName(name);
     const mainBranch = nativeDetectMainBranch(basePath);
     const rawStats = nativeDiffNumstat(basePath, mainBranch, branch);
@@ -652,6 +667,7 @@ export function diffWorktreeNumstat(basePath, name) {
  * Returns the raw unified diff for LLM consumption.
  */
 export function getWorktreeGSDDiff(basePath, name) {
+    basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = worktreeBranchName(name);
     const mainBranch = nativeDetectMainBranch(basePath);
     return nativeDiffContent(basePath, mainBranch, branch, ".gsd/", undefined, true);
@@ -661,6 +677,7 @@ export function getWorktreeGSDDiff(basePath, name) {
  * Returns the raw unified diff for LLM consumption.
  */
 export function getWorktreeCodeDiff(basePath, name) {
+    basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = worktreeBranchName(name);
     const mainBranch = nativeDetectMainBranch(basePath);
     return nativeDiffContent(basePath, mainBranch, branch, undefined, ".gsd/", true);
@@ -669,6 +686,7 @@ export function getWorktreeCodeDiff(basePath, name) {
  * Get commit log for the worktree branch since it diverged from main.
  */
 export function getWorktreeLog(basePath, name) {
+    basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = worktreeBranchName(name);
     const mainBranch = nativeDetectMainBranch(basePath);
     const entries = nativeLogOneline(basePath, mainBranch, branch);
@@ -680,6 +698,7 @@ export function getWorktreeLog(basePath, name) {
  * Returns the merge commit message.
  */
 export function mergeWorktreeToMain(basePath, name, commitMessage) {
+    basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = worktreeBranchName(name);
     const mainBranch = nativeDetectMainBranch(basePath);
     const current = nativeGetCurrentBranch(basePath);

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

@@ -20,28 +20,19 @@ 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";
 // ─── 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, basePath) {
-    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 ──────────────────────────────────────────────────────
 export class WorktreeResolver {
@@ -306,6 +297,30 @@ export class WorktreeResolver {
      */
     mergeAndExit(milestoneId, ctx) {
         this.validateMilestoneId(milestoneId);
+        // Anchor cwd at the project root before any merge work. Some merge code
+        // paths (mergeMilestoneToMain, slice-cadence) chdir explicitly; others
+        // (branch-mode, isolation-degraded skip, missing-original-base skip)
+        // do not. If the worktree dir is later torn down while cwd still points
+        // into it, every subsequent process.cwd() throws ENOENT — and after
+        // de73fb43d that surfaces as a session-failed cancel and (in headless
+        // mode) terminates the whole gsd process. Best-effort: silent on
+        // failure so existing test fixtures that use synthetic paths still pass.
+        if (this.s.originalBasePath) {
+            try {
+                // process.cwd() can throw ENOENT when cwd was removed, so attempt
+                // recovery directly.
+                process.chdir(this.s.originalBasePath);
+            }
+            catch (err) {
+                debugLog("WorktreeResolver", {
+                    action: "mergeAndExit",
+                    phase: "pre-merge-chdir-failed",
+                    milestoneId,
+                    originalBasePath: this.s.originalBasePath,
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+        }
         // #4764 — telemetry: record start timestamp so we can emit merge duration.
         const mergeStartedAt = new Date().toISOString();
         const mergeStartMs = Date.now();

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

@@ -0,0 +1,124 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+export function normalizeWorktreePathForCompare(path) {
+    let normalized;
+    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) {
+    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) {
+    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, originalBasePath) {
+    const preferred = originalBasePath?.trim() ||
+        process.env.GSD_PROJECT_ROOT?.trim() ||
+        basePath;
+    return resolveProjectRootFromPath(preferred);
+}
+function resolveProjectRootFromPath(path) {
+    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) {
+    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) {
+    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/dist/resources/extensions/gsd/worktree-session-state.js

@@ -0,0 +1,33 @@
+// GSD worktree session state
+let originalCwd = null;
+export function getWorktreeOriginalCwd() {
+    return originalCwd;
+}
+export function setWorktreeOriginalCwd(cwd) {
+    originalCwd = cwd;
+}
+export function clearWorktreeOriginalCwd() {
+    originalCwd = null;
+}
+export function ensureWorktreeOriginalCwdFromPath(cwd = process.cwd()) {
+    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() {
+    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;
+}