gsd-pi 2.33.1-dev.ee47f1b → 2.34.0-dev.bbb5216

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

@@ -0,0 +1,344 @@
+/**
+ * WorktreeResolver — encapsulates worktree path state and merge/exit lifecycle.
+ *
+ * Replaces scattered `s.basePath`/`s.originalBasePath` mutation and 3 duplicated
+ * merge-or-teardown blocks in auto-loop.ts with single method calls. All
+ * `s.basePath` mutations (except session.reset() and initial setup) happen
+ * through this class.
+ *
+ * Design: Option A — mutates AutoSession fields directly so existing `s.basePath`
+ * reads continue to work everywhere without wiring changes.
+ *
+ * Key invariant: `createAutoWorktree()` and `enterAutoWorktree()` call
+ * `process.chdir()` internally — this class MUST NOT double-chdir.
+ */
+import { debugLog } from "./debug-logger.js";
+// ─── WorktreeResolver ──────────────────────────────────────────────────────
+export class WorktreeResolver {
+    s;
+    deps;
+    constructor(session, deps) {
+        this.s = session;
+        this.deps = deps;
+    }
+    // ── Getters ────────────────────────────────────────────────────────────
+    /** Current working path — may be worktree or project root. */
+    get workPath() {
+        return this.s.basePath;
+    }
+    /** Original project root — always the non-worktree path. */
+    get projectRoot() {
+        return this.s.originalBasePath || this.s.basePath;
+    }
+    /** Path for auto.lock file — same as the old lockBase(). */
+    get lockPath() {
+        return this.s.originalBasePath || this.s.basePath;
+    }
+    // ── Private Helpers ────────────────────────────────────────────────────
+    rebuildGitService() {
+        const gitConfig = this.deps.loadEffectiveGSDPreferences()?.preferences?.git ?? {};
+        this.s.gitService = new this.deps.GitServiceImpl(this.s.basePath, gitConfig);
+    }
+    /** Restore basePath to originalBasePath and rebuild GitService. */
+    restoreToProjectRoot() {
+        if (!this.s.originalBasePath)
+            return;
+        this.s.basePath = this.s.originalBasePath;
+        this.rebuildGitService();
+        this.deps.invalidateAllCaches();
+    }
+    // ── Validation ──────────────────────────────────────────────────────────
+    /** Validate milestoneId to prevent path traversal. */
+    validateMilestoneId(milestoneId) {
+        if (/[\/\\]|\.\./.test(milestoneId)) {
+            throw new Error(`Invalid milestoneId: ${milestoneId} — contains path separators or traversal`);
+        }
+    }
+    // ── Enter Milestone ────────────────────────────────────────────────────
+    /**
+     * Enter or create a worktree for the given milestone.
+     *
+     * Only acts if `shouldUseWorktreeIsolation()` returns true.
+     * Delegates to `enterAutoWorktree` (existing) or `createAutoWorktree` (new).
+     * Those functions call `process.chdir()` internally — we do NOT double-chdir.
+     *
+     * Updates `s.basePath` and rebuilds GitService on success.
+     * On failure: notifies a warning and does NOT update `s.basePath`.
+     */
+    enterMilestone(milestoneId, ctx) {
+        this.validateMilestoneId(milestoneId);
+        if (!this.deps.shouldUseWorktreeIsolation()) {
+            debugLog("WorktreeResolver", {
+                action: "enterMilestone",
+                milestoneId,
+                skipped: true,
+                reason: "isolation-disabled",
+            });
+            return;
+        }
+        const basePath = this.s.originalBasePath || this.s.basePath;
+        debugLog("WorktreeResolver", {
+            action: "enterMilestone",
+            milestoneId,
+            basePath,
+        });
+        try {
+            const existingPath = this.deps.getAutoWorktreePath(basePath, milestoneId);
+            let wtPath;
+            if (existingPath) {
+                wtPath = this.deps.enterAutoWorktree(basePath, milestoneId);
+            }
+            else {
+                wtPath = this.deps.createAutoWorktree(basePath, milestoneId);
+            }
+            this.s.basePath = wtPath;
+            this.rebuildGitService();
+            debugLog("WorktreeResolver", {
+                action: "enterMilestone",
+                milestoneId,
+                result: "success",
+                wtPath,
+            });
+            ctx.notify(`Entered worktree for ${milestoneId} at ${wtPath}`, "info");
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            debugLog("WorktreeResolver", {
+                action: "enterMilestone",
+                milestoneId,
+                result: "error",
+                error: msg,
+            });
+            ctx.notify(`Auto-worktree creation for ${milestoneId} failed: ${msg}. Continuing in project root.`, "warning");
+            // Do NOT update s.basePath — stay in project root
+        }
+    }
+    // ── Exit Milestone ─────────────────────────────────────────────────────
+    /**
+     * Exit the current worktree: auto-commit, teardown, reset basePath.
+     *
+     * Only acts if currently in an auto-worktree (checked via `isInAutoWorktree`).
+     * Resets `s.basePath` to `s.originalBasePath` and rebuilds GitService.
+     */
+    exitMilestone(milestoneId, ctx, opts) {
+        this.validateMilestoneId(milestoneId);
+        if (!this.deps.isInAutoWorktree(this.s.basePath)) {
+            debugLog("WorktreeResolver", {
+                action: "exitMilestone",
+                milestoneId,
+                skipped: true,
+                reason: "not-in-worktree",
+            });
+            return;
+        }
+        debugLog("WorktreeResolver", {
+            action: "exitMilestone",
+            milestoneId,
+            basePath: this.s.basePath,
+        });
+        try {
+            this.deps.autoCommitCurrentBranch(this.s.basePath, "stop", milestoneId);
+        }
+        catch (err) {
+            debugLog("WorktreeResolver", {
+                action: "exitMilestone",
+                milestoneId,
+                phase: "auto-commit-failed",
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        try {
+            this.deps.teardownAutoWorktree(this.s.originalBasePath, milestoneId, {
+                preserveBranch: opts?.preserveBranch ?? false,
+            });
+        }
+        catch (err) {
+            debugLog("WorktreeResolver", {
+                action: "exitMilestone",
+                milestoneId,
+                phase: "teardown-failed",
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+        this.restoreToProjectRoot();
+        debugLog("WorktreeResolver", {
+            action: "exitMilestone",
+            milestoneId,
+            result: "done",
+            basePath: this.s.basePath,
+        });
+        ctx.notify(`Exited worktree for ${milestoneId}`, "info");
+    }
+    // ── Merge and Exit ─────────────────────────────────────────────────────
+    /**
+     * Merge the completed milestone branch back to main and exit the worktree.
+     *
+     * Handles all three isolation modes:
+     * - **worktree**: Read roadmap, merge, teardown worktree, reset paths.
+     *   Falls back to bare teardown if no roadmap exists.
+     * - **branch**: Check if on milestone branch, merge if so (no chdir/teardown).
+     * - **none**: No-op.
+     *
+     * Error recovery: on merge failure, always restore `s.basePath` to
+     * `s.originalBasePath` and `process.chdir(s.originalBasePath)`.
+     */
+    mergeAndExit(milestoneId, ctx) {
+        this.validateMilestoneId(milestoneId);
+        const mode = this.deps.getIsolationMode();
+        debugLog("WorktreeResolver", {
+            action: "mergeAndExit",
+            milestoneId,
+            mode,
+            basePath: this.s.basePath,
+        });
+        if (mode === "none") {
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                skipped: true,
+                reason: "mode-none",
+            });
+            return;
+        }
+        if (mode === "worktree" ||
+            (this.deps.isInAutoWorktree(this.s.basePath) && this.s.originalBasePath)) {
+            this._mergeWorktreeMode(milestoneId, ctx);
+        }
+        else if (mode === "branch") {
+            this._mergeBranchMode(milestoneId, ctx);
+        }
+    }
+    /** Worktree-mode merge: read roadmap, merge, teardown, reset paths. */
+    _mergeWorktreeMode(milestoneId, ctx) {
+        const originalBase = this.s.originalBasePath;
+        if (!originalBase) {
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                mode: "worktree",
+                skipped: true,
+                reason: "missing-original-base",
+            });
+            return;
+        }
+        try {
+            const { synced } = this.deps.syncWorktreeStateBack(originalBase, this.s.basePath, milestoneId);
+            if (synced.length > 0) {
+                debugLog("WorktreeResolver", {
+                    action: "mergeAndExit",
+                    milestoneId,
+                    phase: "reverse-sync",
+                    synced: synced.length,
+                });
+            }
+            const roadmapPath = this.deps.resolveMilestoneFile(originalBase, milestoneId, "ROADMAP");
+            if (roadmapPath) {
+                const roadmapContent = this.deps.readFileSync(roadmapPath, "utf-8");
+                const mergeResult = this.deps.mergeMilestoneToMain(originalBase, milestoneId, roadmapContent);
+                ctx.notify(`Milestone ${milestoneId} merged to main.${mergeResult.pushed ? " Pushed to remote." : ""}`, "info");
+            }
+            else {
+                // No roadmap — fall back to bare teardown
+                this.deps.teardownAutoWorktree(originalBase, milestoneId);
+                ctx.notify(`Exited worktree for ${milestoneId} (no roadmap for merge).`, "info");
+            }
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                result: "error",
+                error: msg,
+                fallback: "chdir-to-project-root",
+            });
+            ctx.notify(`Milestone merge failed: ${msg}`, "warning");
+            // Error recovery: always restore to project root
+            if (originalBase) {
+                try {
+                    process.chdir(originalBase);
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+        }
+        // Always restore basePath and rebuild — whether merge succeeded or failed
+        this.restoreToProjectRoot();
+        debugLog("WorktreeResolver", {
+            action: "mergeAndExit",
+            milestoneId,
+            result: "done",
+            basePath: this.s.basePath,
+        });
+    }
+    /** Branch-mode merge: check current branch, merge if on milestone branch. */
+    _mergeBranchMode(milestoneId, ctx) {
+        try {
+            const currentBranch = this.deps.getCurrentBranch(this.s.basePath);
+            const milestoneBranch = this.deps.autoWorktreeBranch(milestoneId);
+            if (currentBranch !== milestoneBranch) {
+                debugLog("WorktreeResolver", {
+                    action: "mergeAndExit",
+                    milestoneId,
+                    mode: "branch",
+                    skipped: true,
+                    reason: "not-on-milestone-branch",
+                    currentBranch,
+                    milestoneBranch,
+                });
+                return;
+            }
+            const roadmapPath = this.deps.resolveMilestoneFile(this.s.basePath, milestoneId, "ROADMAP");
+            if (!roadmapPath) {
+                debugLog("WorktreeResolver", {
+                    action: "mergeAndExit",
+                    milestoneId,
+                    mode: "branch",
+                    skipped: true,
+                    reason: "no-roadmap",
+                });
+                return;
+            }
+            const roadmapContent = this.deps.readFileSync(roadmapPath, "utf-8");
+            const mergeResult = this.deps.mergeMilestoneToMain(this.s.basePath, milestoneId, roadmapContent);
+            // Rebuild GitService after merge (branch HEAD changed)
+            this.rebuildGitService();
+            ctx.notify(`Milestone ${milestoneId} merged (branch mode).${mergeResult.pushed ? " Pushed to remote." : ""}`, "info");
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                mode: "branch",
+                result: "success",
+            });
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            debugLog("WorktreeResolver", {
+                action: "mergeAndExit",
+                milestoneId,
+                mode: "branch",
+                result: "error",
+                error: msg,
+            });
+            ctx.notify(`Milestone merge failed (branch mode): ${msg}`, "warning");
+        }
+    }
+    // ── Merge and Enter Next ───────────────────────────────────────────────
+    /**
+     * Milestone transition: merge the current milestone, then enter the next one.
+     *
+     * This is the pattern used when the loop detects that the active milestone
+     * has changed (e.g., current completed, next one is now active). The caller
+     * is responsible for re-deriving state between the merge and the enter.
+     */
+    mergeAndEnterNext(currentMilestoneId, nextMilestoneId, ctx) {
+        debugLog("WorktreeResolver", {
+            action: "mergeAndEnterNext",
+            currentMilestoneId,
+            nextMilestoneId,
+        });
+        this.mergeAndExit(currentMilestoneId, ctx);
+        this.enterMilestone(nextMilestoneId, ctx);
+    }
+}

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

@@ -11,7 +11,7 @@
  * Pure utility functions (detectWorktreeName, getSliceBranchName, parseSliceBranch,
  * SLICE_BRANCH_RE) remain for backwards compatibility with legacy branches.
  */
-import { existsSync, lstatSync, readFileSync, utimesSync } from "node:fs";
+import { existsSync, readFileSync, utimesSync } from "node:fs";
 import { join, resolve } from "node:path";
 import { GitServiceImpl, writeIntegrationBranch } from "./git-service.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
@@ -47,14 +47,14 @@ export function setActiveMilestoneId(basePath, milestoneId) {
  * record when the user starts from a different branch (#300). Always a no-op
  * if on a GSD slice branch.
  */
-export function captureIntegrationBranch(basePath, milestoneId) {
+export function captureIntegrationBranch(basePath, milestoneId, options) {
     // In a worktree, the base branch is implicit (worktree/<name>).
     // Writing it to META.json would leave stale metadata after merge back to main.
     if (detectWorktreeName(basePath))
         return;
     const svc = getService(basePath);
     const current = svc.getCurrentBranch();
-    writeIntegrationBranch(basePath, milestoneId, current);
+    writeIntegrationBranch(basePath, milestoneId, current, options);
 }
 // ─── Pure Utility Functions (unchanged) ────────────────────────────────────
 /**
@@ -62,25 +62,6 @@ export function captureIntegrationBranch(basePath, milestoneId) {
  * Returns null if not inside a GSD worktree (.gsd/worktrees/<name>/).
  */
 export function detectWorktreeName(basePath) {
-    // Primary: use git metadata — .git file with gitdir: pointer
-    const gitPath = join(basePath, ".git");
-    try {
-        const stat = lstatSync(gitPath);
-        if (stat.isFile()) {
-            const content = readFileSync(gitPath, "utf-8").trim();
-            if (content.startsWith("gitdir:")) {
-                const gitdir = content.slice(7).trim();
-                // Git worktree gitdir format: <repo>/.git/worktrees/<name>
-                const parts = gitdir.replace(/\\/g, "/").split("/");
-                const wtIdx = parts.lastIndexOf("worktrees");
-                if (wtIdx !== -1 && wtIdx < parts.length - 1) {
-                    return parts[wtIdx + 1] || null;
-                }
-            }
-        }
-    }
-    catch { /* fall through */ }
-    // Fallback: path-based detection for legacy setups
     const normalizedPath = basePath.replaceAll("\\", "/");
     const marker = "/.gsd/worktrees/";
     const idx = normalizedPath.indexOf(marker);
@@ -99,33 +80,15 @@ export function detectWorktreeName(basePath) {
  * operate against the real project root, not a worktree subdirectory.
  */
 export function resolveProjectRoot(basePath) {
-    // Primary: use git metadata to resolve the main worktree root
-    const gitPath = join(basePath, ".git");
-    try {
-        const stat = lstatSync(gitPath);
-        if (stat.isFile()) {
-            const content = readFileSync(gitPath, "utf-8").trim();
-            if (content.startsWith("gitdir:")) {
-                const gitdir = resolve(basePath, content.slice(7).trim());
-                // Git worktree gitdir: <repo>/.git/worktrees/<name>
-                // Walk up to <repo>
-                const parts = gitdir.replace(/\\/g, "/").split("/");
-                const wtIdx = parts.lastIndexOf("worktrees");
-                if (wtIdx >= 2 && parts[wtIdx - 1] === ".git") {
-                    return parts.slice(0, wtIdx - 1).join("/");
-                }
-            }
-        }
-    }
-    catch { /* fall through */ }
-    // Fallback: legacy path-based detection
     const normalizedPath = basePath.replaceAll("\\", "/");
     const marker = "/.gsd/worktrees/";
     const idx = normalizedPath.indexOf(marker);
     if (idx === -1)
         return basePath;
-    const osSep = basePath.includes("\\") ? "\\" : "/";
-    const markerOs = `${osSep}.gsd${osSep}worktrees${osSep}`;
+    // Return the original path up to the .gsd/ marker (un-normalized)
+    // Account for potential OS-specific separators
+    const sep = basePath.includes("\\") ? "\\" : "/";
+    const markerOs = `${sep}.gsd${sep}worktrees${sep}`;
     const idxOs = basePath.indexOf(markerOs);
     if (idxOs !== -1)
         return basePath.slice(0, idxOs);

package/dist/tool-bootstrap.js

@@ -1,4 +1,4 @@
-import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, rmSync, symlinkSync } from "node:fs";
+import { chmodSync, copyFileSync, existsSync, lstatSync, mkdirSync, rmSync, statSync, symlinkSync, unlinkSync } from "node:fs";
 import { delimiter, join } from "node:path";
 const TOOL_SPECS = {
     fd: {
@@ -32,6 +32,45 @@ function isRegularFile(path) {
         return false;
     }
 }
+function pathExistsIncludingBrokenSymlink(path) {
+    try {
+        lstatSync(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function isBrokenSymlink(path) {
+    try {
+        const stat = lstatSync(path);
+        if (!stat.isSymbolicLink())
+            return false;
+        try {
+            statSync(path);
+            return false;
+        }
+        catch {
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+}
+function removeTargetPath(path) {
+    try {
+        const stat = lstatSync(path);
+        if (stat.isSymbolicLink()) {
+            unlinkSync(path);
+            return;
+        }
+        rmSync(path, { force: true });
+    }
+    catch {
+        // Path already absent.
+    }
+}
 export function resolveToolFromPath(tool, pathValue = process.env.PATH) {
     const spec = TOOL_SPECS[tool];
     for (const dir of splitPath(pathValue)) {
@@ -48,23 +87,32 @@ export function resolveToolFromPath(tool, pathValue = process.env.PATH) {
 }
 function provisionTool(targetDir, tool, sourcePath) {
     const targetPath = join(targetDir, TOOL_SPECS[tool].targetName);
-    if (existsSync(targetPath))
-        return targetPath;
-    mkdirSync(targetDir, { recursive: true });
-    try {
-        symlinkSync(sourcePath, targetPath);
+    const brokenTarget = isBrokenSymlink(targetPath);
+    if (pathExistsIncludingBrokenSymlink(targetPath)) {
+        if (!brokenTarget)
+            return targetPath;
+        removeTargetPath(targetPath);
     }
-    catch {
-        rmSync(targetPath, { force: true });
-        copyFileSync(sourcePath, targetPath);
-        chmodSync(targetPath, 0o755);
+    mkdirSync(targetDir, { recursive: true });
+    if (!brokenTarget) {
+        try {
+            symlinkSync(sourcePath, targetPath);
+            return targetPath;
+        }
+        catch {
+            // Fall back to copying below.
+        }
     }
+    removeTargetPath(targetPath);
+    copyFileSync(sourcePath, targetPath);
+    chmodSync(targetPath, 0o755);
     return targetPath;
 }
 export function ensureManagedTools(targetDir, pathValue = process.env.PATH) {
     const provisioned = [];
     for (const tool of Object.keys(TOOL_SPECS)) {
-        if (existsSync(join(targetDir, TOOL_SPECS[tool].targetName)))
+        const targetPath = join(targetDir, TOOL_SPECS[tool].targetName);
+        if (pathExistsIncludingBrokenSymlink(targetPath) && !isBrokenSymlink(targetPath))
             continue;
         const sourcePath = resolveToolFromPath(tool, pathValue);
         if (!sourcePath)

package/dist/worktree-cli.js

@@ -20,22 +20,22 @@
 import chalk from 'chalk';
 import { createJiti } from '@mariozechner/jiti';
 import { fileURLToPath } from 'node:url';
-import { dirname, join } from 'node:path';
 import { generateWorktreeName } from './worktree-name-gen.js';
 import { existsSync } from 'node:fs';
-const __dirname = dirname(fileURLToPath(import.meta.url));
+import { resolveBundledSourceResource } from './bundled-resource-path.js';
 const jiti = createJiti(fileURLToPath(import.meta.url), { interopDefault: true, debug: false });
+const gsdExtensionPath = (...segments) => resolveBundledSourceResource(import.meta.url, 'extensions', 'gsd', ...segments);
 // Lazily-loaded extension modules (loaded once on first use via jiti)
 let _ext = null;
 async function loadExtensionModules() {
     if (_ext)
         return _ext;
     const [wtMgr, autoWt, gitBridge, gitSvc, wt] = await Promise.all([
-        jiti.import(join(__dirname, 'resources/extensions/gsd/worktree-manager.ts'), {}),
-        jiti.import(join(__dirname, 'resources/extensions/gsd/auto-worktree.ts'), {}),
-        jiti.import(join(__dirname, 'resources/extensions/gsd/native-git-bridge.ts'), {}),
-        jiti.import(join(__dirname, 'resources/extensions/gsd/git-service.ts'), {}),
-        jiti.import(join(__dirname, 'resources/extensions/gsd/worktree.ts'), {}),
+        jiti.import(gsdExtensionPath('worktree-manager.ts'), {}),
+        jiti.import(gsdExtensionPath('auto-worktree.ts'), {}),
+        jiti.import(gsdExtensionPath('native-git-bridge.ts'), {}),
+        jiti.import(gsdExtensionPath('git-service.ts'), {}),
+        jiti.import(gsdExtensionPath('worktree.ts'), {}),
     ]);
     _ext = {
         createWorktree: wtMgr.createWorktree,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gsd-pi",
-  "version": "2.33.1-dev.ee47f1b",
+  "version": "2.34.0-dev.bbb5216",
   "description": "GSD — Get Shit Done coding agent",
   "license": "MIT",
   "repository": {