gsd-pi 2.78.1-dev.84a383f51 → 2.78.1-dev.84c045fd2

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);
@@ -625,8 +638,9 @@ export function diffWorktreeGSD(basePath, name) {
  * on main when the merge is applied. If both branches have identical
  * content, this correctly returns an empty diff.
  */
-export function diffWorktreeAll(basePath, name) {
-    const branch = worktreeBranchName(name);
+export function diffWorktreeAll(basePath, name, branchOverride) {
+    basePath = normalizeBasePathForWorktreeOps(basePath);
+    const branch = branchOverride ?? worktreeBranchName(name);
     const mainBranch = nativeDetectMainBranch(basePath);
     const entries = nativeDiffNameStatus(basePath, mainBranch, branch);
     return parseDiffNameStatus(entries);
@@ -635,8 +649,9 @@ export function diffWorktreeAll(basePath, name) {
  * Get per-file line addition/deletion stats for what will change on main.
  * Uses direct diff (not merge-base) so the preview matches the actual merge outcome.
  */
-export function diffWorktreeNumstat(basePath, name) {
-    const branch = worktreeBranchName(name);
+export function diffWorktreeNumstat(basePath, name, branchOverride) {
+    basePath = normalizeBasePathForWorktreeOps(basePath);
+    const branch = branchOverride ?? worktreeBranchName(name);
     const mainBranch = nativeDetectMainBranch(basePath);
     const rawStats = nativeDiffNumstat(basePath, mainBranch, branch);
     const stats = [];
@@ -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);
@@ -679,8 +697,9 @@ export function getWorktreeLog(basePath, name) {
  * Must be called from the main working tree (not the worktree itself).
  * Returns the merge commit message.
  */
-export function mergeWorktreeToMain(basePath, name, commitMessage) {
-    const branch = worktreeBranchName(name);
+export function mergeWorktreeToMain(basePath, name, commitMessage, branchOverride) {
+    basePath = normalizeBasePathForWorktreeOps(basePath);
+    const branch = branchOverride ?? worktreeBranchName(name);
     const mainBranch = nativeDetectMainBranch(basePath);
     const current = nativeGetCurrentBranch(basePath);
     if (current !== mainBranch) {

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 {
@@ -107,7 +98,11 @@ export class WorktreeResolver {
             });
             return;
         }
-        const mode = this.deps.getIsolationMode();
+        // Resolve the project root for worktree operations via shared helper.
+        // Handles the case where originalBasePath is falsy and basePath is itself
+        // a worktree path — prevents double-nested worktree paths (#3729).
+        const basePath = resolveProjectRoot(this.s.originalBasePath, this.s.basePath);
+        const mode = this.deps.getIsolationMode(basePath);
         if (mode === "none") {
             debugLog("WorktreeResolver", {
                 action: "enterMilestone",
@@ -124,10 +119,6 @@ export class WorktreeResolver {
             });
             return;
         }
-        // Resolve the project root for worktree operations via shared helper.
-        // Handles the case where originalBasePath is falsy and basePath is itself
-        // a worktree path — prevents double-nested worktree paths (#3729).
-        const basePath = resolveProjectRoot(this.s.originalBasePath, this.s.basePath);
         debugLog("WorktreeResolver", {
             action: "enterMilestone",
             milestoneId,
@@ -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();
@@ -320,7 +335,7 @@ export class WorktreeResolver {
             ctx.notify(`Skipping worktree merge for ${milestoneId} — isolation was degraded (worktree creation failed earlier). Work is on the current branch.`, "info");
             return;
         }
-        const mode = this.deps.getIsolationMode();
+        const mode = this.deps.getIsolationMode(this.s.originalBasePath || this.s.basePath);
         debugLog("WorktreeResolver", {
             action: "mergeAndExit",
             milestoneId,

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

@@ -0,0 +1,163 @@
+import { existsSync, readFileSync, realpathSync, statSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { gsdHome } from "./gsd-home.js";
+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 explicitOriginal = originalBasePath?.trim();
+    if (explicitOriginal)
+        return resolveProjectRootFromPath(explicitOriginal);
+    const envProjectRoot = process.env.GSD_PROJECT_ROOT?.trim();
+    if (envProjectRoot && isGsdWorktreePath(basePath)) {
+        return resolveProjectRootFromPath(envProjectRoot);
+    }
+    return resolveProjectRootFromPath(basePath || envProjectRoot || process.cwd());
+}
+function resolveProjectRootFromPath(path) {
+    const normalizedPath = path.replaceAll("\\", "/");
+    const segment = findWorktreeSegment(normalizedPath);
+    if (!segment) {
+        return resolveNearestBootstrappedGsdRoot(path) ?? 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 gsdHomeNorm = normalizeWorktreePathForCompare(gsdHome());
+    const candidateGsdPath = normalizeWorktreePathForCompare(join(candidate, ".gsd"));
+    if (candidateGsdPath === gsdHomeNorm || candidateGsdPath.startsWith(`${gsdHomeNorm}/`)) {
+        const realRoot = resolveProjectRootFromGitFile(path);
+        return realRoot ?? path;
+    }
+    return candidate;
+}
+function resolveNearestBootstrappedGsdRoot(path) {
+    try {
+        let dir = existsSync(path) && !statSync(path).isDirectory()
+            ? resolve(path, "..")
+            : path;
+        const externalStateParent = normalizeWorktreePathForCompare(resolve(gsdHome(), ".."));
+        for (let i = 0; i < 30; i++) {
+            if (normalizeWorktreePathForCompare(dir) === externalStateParent)
+                return null;
+            if (hasGsdBootstrapArtifacts(join(dir, ".gsd")))
+                return dir;
+            const gitPath = join(dir, ".git");
+            if (existsSync(gitPath))
+                return null;
+            const parent = resolve(dir, "..");
+            if (parent === dir)
+                break;
+            dir = parent;
+        }
+    }
+    catch {
+        // Non-fatal: callers fall back to git root resolution.
+    }
+    return null;
+}
+function hasGsdBootstrapArtifacts(gsdPath) {
+    return existsSync(gsdPath) &&
+        (existsSync(join(gsdPath, "PREFERENCES.md")) ||
+            existsSync(join(gsdPath, "preferences.md")) ||
+            existsSync(join(gsdPath, "milestones")));
+}
+function resolveGitWorkingTreeRoot(path) {
+    try {
+        let dir = existsSync(path) && !statSync(path).isDirectory()
+            ? resolve(path, "..")
+            : path;
+        const externalStateParent = normalizeWorktreePathForCompare(resolve(gsdHome(), ".."));
+        for (let i = 0; i < 30; i++) {
+            if (normalizeWorktreePathForCompare(dir) === externalStateParent)
+                return null;
+            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.js

@@ -11,11 +11,12 @@
  * Pure utility functions (detectWorktreeName, getSliceBranchName, parseSliceBranch,
  * SLICE_BRANCH_RE) remain for backwards compatibility with legacy branches.
  */
-import { existsSync, readFileSync, realpathSync, utimesSync } from "node:fs";
+import { existsSync, readFileSync, utimesSync } from "node:fs";
 import { join, resolve } from "node:path";
-import { homedir } from "node:os";
 import { GitServiceImpl, writeIntegrationBranch } from "./git-service.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
+import { findWorktreeSegment, resolveWorktreeProjectRoot, } from "./worktree-root.js";
+export { resolveWorktreeProjectRoot } from "./worktree-root.js";
 export { MergeConflictError } from "./git-service.js";
 // ─── Lazy GitServiceImpl Cache ─────────────────────────────────────────────
 let cachedService = null;
@@ -67,28 +68,6 @@ export function captureIntegrationBranch(basePath, milestoneId) {
     writeIntegrationBranch(basePath, milestoneId, current);
 }
 // ─── Pure Utility Functions (unchanged) ────────────────────────────────────
-/**
- * Find the worktrees segment in a path, supporting both direct
- * (`/.gsd/worktrees/`) and symlink-resolved (`/.gsd/projects/<hash>/worktrees/`)
- * layouts.  When `.gsd` is a symlink to `~/.gsd/projects/<hash>`, resolved
- * paths contain the intermediate `projects/<hash>/` segment that the old
- * single-marker check missed.
- */
-function findWorktreeSegment(normalizedPath) {
-    // Direct layout: /.gsd/worktrees/<name>
-    const directMarker = "/.gsd/worktrees/";
-    const idx = normalizedPath.indexOf(directMarker);
-    if (idx !== -1) {
-        return { gsdIdx: idx, afterWorktrees: idx + directMarker.length };
-    }
-    // Symlink-resolved layout: /.gsd/projects/<hash>/worktrees/<name>
-    const symlinkRe = /\/\.gsd\/projects\/[a-f0-9]+\/worktrees\//;
-    const match = normalizedPath.match(symlinkRe);
-    if (match && match.index !== undefined) {
-        return { gsdIdx: match.index, afterWorktrees: match.index + match[0].length };
-    }
-    return null;
-}
 /**
  * Detect the active worktree name from the current working directory.
  * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
@@ -121,97 +100,7 @@ export function detectWorktreeName(basePath) {
  * operate against the real project root, not a worktree subdirectory.
  */
 export function resolveProjectRoot(basePath) {
-    // Layer 1: If the coordinator passed the real project root, use it.
-    if (process.env.GSD_PROJECT_ROOT) {
-        return process.env.GSD_PROJECT_ROOT;
-    }
-    const normalizedPath = basePath.replaceAll("\\", "/");
-    const seg = findWorktreeSegment(normalizedPath);
-    if (!seg)
-        return basePath;
-    // Candidate root via the string-slice heuristic
-    const sepChar = basePath.includes("\\") ? "\\" : "/";
-    const gsdMarker = `${sepChar}.gsd${sepChar}`;
-    const gsdIdx = basePath.indexOf(gsdMarker);
-    const candidate = gsdIdx !== -1
-        ? basePath.slice(0, gsdIdx)
-        : basePath.slice(0, seg.gsdIdx);
-    // Layer 2: Guard against resolving to the user's home directory.
-    // When .gsd is a symlink into ~/.gsd/projects/<hash>, the resolved path
-    // contains /.gsd/ at the user-level boundary. Slicing there yields ~ — wrong.
-    const gsdHome = normalizePathForCompare(process.env.GSD_HOME || join(homedir(), ".gsd"));
-    const candidateGsdPath = normalizePathForCompare(join(candidate, ".gsd"));
-    if (candidateGsdPath === gsdHome || candidateGsdPath.startsWith(gsdHome + "/")) {
-        // The candidate is the home directory (or within it in a way that .gsd
-        // maps to the user-level GSD dir). Try to recover the real project root
-        // from the worktree's .git file.
-        const realRoot = resolveProjectRootFromGitFile(basePath);
-        if (realRoot)
-            return realRoot;
-        // If git file resolution failed, return basePath unchanged rather than ~
-        return basePath;
-    }
-    return candidate;
-}
-/**
- * Recover the real project root from a worktree's .git file.
- *
- * Each git worktree has a `.git` file (not directory) containing:
- *   gitdir: /real/project/.git/worktrees/<name>
- *
- * Walking up from that gitdir gives us `/real/project/.git`, and its
- * parent is the real project root.
- */
-function resolveProjectRootFromGitFile(worktreePath) {
-    try {
-        // Walk up from the worktree path to find the .git file
-        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: ")) {
-                    // gitdir points to: <real-project>/.git/worktrees/<name>
-                    const gitDir = resolve(dir, content.slice(8));
-                    // Walk up: .git/worktrees/<name> → .git/worktrees → .git → project root
-                    const dotGitDir = resolve(gitDir, "..", "..");
-                    // Verify this looks like a .git directory
-                    if (dotGitDir.endsWith(".git") || dotGitDir.endsWith(".git/") || dotGitDir.endsWith(".git\\")) {
-                        return resolve(dotGitDir, "..");
-                    }
-                    // Alternative: the commondir file inside the worktree gitdir
-                    // points to the main .git directory
-                    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 — caller will use fallback
-    }
-    return null;
-}
-function normalizePathForCompare(path) {
-    let normalized;
-    try {
-        normalized = realpathSync(path);
-    }
-    catch {
-        normalized = resolve(path);
-    }
-    const slashed = normalized.replaceAll("\\", "/");
-    const trimmed = slashed.replace(/\/+$/, "");
-    return trimmed || "/";
+    return resolveWorktreeProjectRoot(basePath);
 }
 /**
  * Get the slice branch name, namespaced by worktree when inside one.

package/dist/resources/extensions/gsd/write-intercept.js

@@ -85,9 +85,9 @@ function matchesBlockedPattern(path) {
  * Directs the agent to use engine tool calls instead.
  */
 export const BLOCKED_WRITE_ERROR = `Direct writes to .gsd/STATE.md and .gsd/gsd.db are blocked. Use engine tool calls instead:
-- To complete a task: call gsd_complete_task(milestone_id, slice_id, task_id, summary)
-- To complete a slice: call gsd_complete_slice(milestone_id, slice_id, summary, uat_result)
-- To save a decision: call gsd_save_decision(scope, decision, choice, rationale)
+- To complete a task: call gsd_task_complete(milestone_id, slice_id, task_id, summary)
+- To complete a slice: call gsd_slice_complete(milestone_id, slice_id, summary, uat_result)
+- To save a decision: call gsd_decision_save(scope, decision, choice, rationale)
 - To start a task: call gsd_start_task(milestone_id, slice_id, task_id)
 - To record verification: call gsd_record_verification(milestone_id, slice_id, task_id, evidence)
 - To report a blocker: call gsd_report_blocker(milestone_id, slice_id, task_id, description)`;

package/dist/resources/extensions/mcp-client/index.js

@@ -18,9 +18,9 @@ import { Client } from "@modelcontextprotocol/sdk/client";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { readFileSync, existsSync } from "node:fs";
-import { homedir } from "node:os";
 import { join } from "node:path";
 import { buildHttpTransportOpts } from "./auth.js";
+import { gsdHome } from "../gsd/gsd-home.js";
 // ─── Connection Manager ───────────────────────────────────────────────────────
 const connections = new Map();
 const pendingConnections = new Map();
@@ -63,7 +63,7 @@ function readConfigs() {
     const configPaths = [
         join(process.cwd(), ".mcp.json"),
         join(process.cwd(), ".gsd", "mcp.json"),
-        join(process.env.GSD_HOME || join(homedir(), ".gsd"), "mcp.json"),
+        join(gsdHome(), "mcp.json"),
     ];
     for (const configPath of configPaths) {
         try {
@@ -503,12 +503,6 @@ export default function (pi) {
         },
     });
     // ── Lifecycle ─────────────────────────────────────────────────────────────
-    pi.on("session_start", async (_event, ctx) => {
-        const servers = readConfigs();
-        if (servers.length > 0) {
-            ctx.ui.notify(`MCP client ready — ${servers.length} server(s) configured`, "info");
-        }
-    });
     pi.on("session_shutdown", async () => {
         await closeAll();
     });

package/dist/resources/extensions/ollama/index.js

@@ -103,19 +103,32 @@ export default function ollama(pi) {
         // In headless/auto mode, await the probe so the fallback resolver can
         // see Ollama before the first LLM call (#3531 race condition).
         // In interactive mode, keep it async for fast startup.
+        // Surface probe failures under GSD_DEBUG so users can diagnose silent
+        // "Ollama is missing from /model" reports without patching dist/. The
+        // probe still soft-fails (registration is best-effort) — we just stop
+        // dropping the error on the floor. See #4982.
+        const debugOllama = (where, error) => {
+            if (process.env.GSD_DEBUG) {
+                const msg = error instanceof Error ? error.message : String(error);
+                process.stderr.write(`[ollama] ${where} probe failed: ${msg}\n`);
+            }
+        };
         if (!ctx.hasUI) {
             try {
                 await probeAndRegister(pi);
             }
-            catch { /* non-fatal */ }
+            catch (error) {
+                debugOllama("headless", error);
+            }
         }
         else {
             probeAndRegister(pi)
                 .then((found) => {
                 ctx.ui.setStatus("ollama", found ? "Ollama" : undefined);
             })
-                .catch(() => {
+                .catch((error) => {
                 ctx.ui.setStatus("ollama", undefined);
+                debugOllama("interactive", error);
             });
         }
     });

package/dist/resources/extensions/ollama/model-capabilities.js

@@ -32,9 +32,40 @@ const KNOWN_MODELS = [
     ["llama3", { contextWindow: 8192, maxTokens: 8192, ollamaOptions: { num_ctx: 8192 } }],
     ["llama2", { contextWindow: 4096, maxTokens: 4096, ollamaOptions: { num_ctx: 4096 } }],
     // ─── Qwen family ────────────────────────────────────────────────────
+    // Long-variant entries MUST appear before the bare `qwen3` base —
+    // `baseName.startsWith(pattern)` returns true for `qwen3.5`/`qwen3-coder`/
+    // `qwen3-next` against `qwen3`, and the first match wins (#4991).
+    // ref: qwen3-next 1M ctx — https://qwen.ai/blog?id=qwen3-next
+    ["qwen3-next", { contextWindow: 1048576, maxTokens: 32768, ollamaOptions: { num_ctx: 1048576 } }],
+    // ref: qwen3-coder 256K ctx — https://qwenlm.github.io/blog/qwen3-coder/
+    ["qwen3-coder", { contextWindow: 262144, maxTokens: 32768, ollamaOptions: { num_ctx: 262144 } }],
+    // ref: qwen3.5 / qwen3.6 1M ctx — Ollama Cloud release notes
+    ["qwen3.6", { contextWindow: 1048576, maxTokens: 32768, ollamaOptions: { num_ctx: 1048576 } }],
+    ["qwen3.5", { contextWindow: 1048576, maxTokens: 32768, ollamaOptions: { num_ctx: 1048576 } }],
     ["qwen3", { contextWindow: 131072, maxTokens: 32768, ollamaOptions: { num_ctx: 131072 } }],
     ["qwen2.5", { contextWindow: 131072, maxTokens: 32768, ollamaOptions: { num_ctx: 131072 } }],
     ["qwen2", { contextWindow: 131072, maxTokens: 32768, ollamaOptions: { num_ctx: 131072 } }],
+    // ─── GLM family (Z.ai, Ollama Cloud) ────────────────────────────────
+    // ref: glm 4.6 / 5.x 200K ctx — https://docs.z.ai/devpack/using5.1
+    // Long-variant entries before bare `glm-5` / `glm-4` would-be bases to
+    // avoid prefix shadowing (#4991).
+    ["glm-5.1", { contextWindow: 204800, maxTokens: 16384, ollamaOptions: { num_ctx: 204800 } }],
+    ["glm-5", { contextWindow: 204800, maxTokens: 16384, ollamaOptions: { num_ctx: 204800 } }],
+    ["glm-4.6", { contextWindow: 204800, maxTokens: 16384, ollamaOptions: { num_ctx: 204800 } }],
+    ["glm-4", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
+    // ─── Kimi K2 (Moonshot, Ollama Cloud) ──────────────────────────────
+    // ref: kimi-k2 256K ctx — https://platform.moonshot.ai/docs
+    // Same shadowing concern: kimi-k2-thinking and kimi-k2.{5,6} must
+    // match before any future bare `kimi-k2` entry (#4991).
+    ["kimi-k2-thinking", { contextWindow: 262144, maxTokens: 16384, ollamaOptions: { num_ctx: 262144 } }],
+    ["kimi-k2.6", { contextWindow: 262144, maxTokens: 16384, ollamaOptions: { num_ctx: 262144 } }],
+    ["kimi-k2.5", { contextWindow: 262144, maxTokens: 16384, ollamaOptions: { num_ctx: 262144 } }],
+    ["kimi-k2", { contextWindow: 262144, maxTokens: 16384, ollamaOptions: { num_ctx: 262144 } }],
+    // ─── MiniMax M2 (Ollama Cloud) ─────────────────────────────────────
+    // ref: minimax-m2 1M ctx — https://www.minimax.io/news/minimax-m2
+    ["minimax-m2.7", { contextWindow: 1048576, maxTokens: 16384, ollamaOptions: { num_ctx: 1048576 } }],
+    ["minimax-m2.5", { contextWindow: 1048576, maxTokens: 16384, ollamaOptions: { num_ctx: 1048576 } }],
+    ["minimax-m2", { contextWindow: 1048576, maxTokens: 16384, ollamaOptions: { num_ctx: 1048576 } }],
     // ─── Gemma family ───────────────────────────────────────────────────
     ["gemma3", { contextWindow: 131072, maxTokens: 16384, ollamaOptions: { num_ctx: 131072 } }],
     ["gemma2", { contextWindow: 8192, maxTokens: 8192, ollamaOptions: { num_ctx: 8192 } }],