gsd-pi 2.78.1-dev.9d08d820b → 2.78.1-dev.a7b6e59b7

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

@@ -0,0 +1,309 @@
+// GSD-2 — In-TUI handler for /gsd worktree commands (list, merge, clean, remove).
+//
+// Mirrors the CLI subcommands in src/worktree-cli.ts but emits results via
+// ctx.ui.notify() instead of writing colored output to stderr. Reuses the
+// same extension modules (worktree-manager, native-git-bridge, etc.) so the
+// behavior is identical to the CLI surface.
+import { existsSync } from "node:fs";
+import { projectRoot } from "./commands/context.js";
+import { listWorktrees, removeWorktree, mergeWorktreeToMain, diffWorktreeAll, diffWorktreeNumstat, worktreeBranchName, } from "./worktree-manager.js";
+import { nativeHasChanges, nativeDetectMainBranch, nativeCommitCountBetween, } from "./native-git-bridge.js";
+import { inferCommitType } from "./git-service.js";
+import { autoCommitCurrentBranch } from "./worktree.js";
+import { GSDError, GSD_GIT_ERROR } from "./errors.js";
+// ─── Status helper ─────────────────────────────────────────────────────────
+function getStatus(basePath, name, wtPath) {
+    const diff = diffWorktreeAll(basePath, name);
+    const numstat = diffWorktreeNumstat(basePath, name);
+    const filesChanged = diff.added.length + diff.modified.length + diff.removed.length;
+    let linesAdded = 0;
+    let linesRemoved = 0;
+    for (const s of numstat) {
+        linesAdded += s.added;
+        linesRemoved += s.removed;
+    }
+    let uncommitted = false;
+    try {
+        uncommitted = existsSync(wtPath) && nativeHasChanges(wtPath);
+    }
+    catch {
+        // native check failure → treat as clean for display purposes
+    }
+    let commits = 0;
+    try {
+        const main = nativeDetectMainBranch(basePath);
+        commits = nativeCommitCountBetween(basePath, main, worktreeBranchName(name));
+    }
+    catch {
+        // commit count unavailable → leave at 0
+    }
+    return {
+        name,
+        path: wtPath,
+        branch: worktreeBranchName(name),
+        exists: existsSync(wtPath),
+        filesChanged,
+        linesAdded,
+        linesRemoved,
+        uncommitted,
+        commits,
+    };
+}
+// ─── Formatters (exported for tests) ────────────────────────────────────────
+export function formatWorktreeList(statuses) {
+    if (statuses.length === 0) {
+        return "No worktrees.\n\nCreate one from the CLI: gsd -w <name>";
+    }
+    const lines = [`Worktrees — ${statuses.length}`, ""];
+    for (const s of statuses) {
+        const badge = s.uncommitted
+            ? "(uncommitted)"
+            : s.filesChanged > 0
+                ? "(unmerged)"
+                : "(clean)";
+        lines.push(`  ${s.name} ${badge}`);
+        lines.push(`    branch  ${s.branch}`);
+        lines.push(`    path    ${s.path}`);
+        if (s.filesChanged > 0) {
+            lines.push(`    diff    ${s.filesChanged} file${s.filesChanged === 1 ? "" : "s"}, +${s.linesAdded} -${s.linesRemoved}, ${s.commits} commit${s.commits === 1 ? "" : "s"}`);
+        }
+        lines.push("");
+    }
+    lines.push("Commands:");
+    lines.push("  /gsd worktree merge <name>   Merge into main and clean up");
+    lines.push("  /gsd worktree remove <name>  Remove a worktree (--force to skip safety checks)");
+    lines.push("  /gsd worktree clean          Remove all merged/empty worktrees");
+    return lines.join("\n");
+}
+export function formatCleanKeepReason(status) {
+    if (!status.exists) {
+        return "directory missing — run 'git worktree prune' to unregister";
+    }
+    if (status.filesChanged > 0) {
+        return `${status.filesChanged} changed file${status.filesChanged === 1 ? "" : "s"}${status.uncommitted ? ", uncommitted" : ""}`;
+    }
+    return "uncommitted changes";
+}
+// ─── Subcommand: list ───────────────────────────────────────────────────────
+async function handleList(ctx) {
+    const basePath = projectRoot();
+    const worktrees = listWorktrees(basePath);
+    const statuses = worktrees.map((wt) => getStatus(basePath, wt.name, wt.path));
+    ctx.ui.notify(formatWorktreeList(statuses), "info");
+}
+// ─── Subcommand: merge ──────────────────────────────────────────────────────
+async function handleMerge(args, ctx) {
+    const basePath = projectRoot();
+    const worktrees = listWorktrees(basePath);
+    const trimmed = args.trim();
+    let target = trimmed;
+    if (!target) {
+        if (worktrees.length === 1) {
+            target = worktrees[0].name;
+        }
+        else if (worktrees.length === 0) {
+            ctx.ui.notify("No worktrees to merge.", "info");
+            return;
+        }
+        else {
+            const names = worktrees.map((w) => w.name).join(", ");
+            ctx.ui.notify(`Usage: /gsd worktree merge <name>\n\nWorktrees: ${names}`, "warning");
+            return;
+        }
+    }
+    const wt = worktrees.find((w) => w.name === target);
+    if (!wt) {
+        const available = worktrees.map((w) => w.name).join(", ") || "(none)";
+        ctx.ui.notify(`Worktree "${target}" not found.\n\nAvailable: ${available}`, "error");
+        return;
+    }
+    const status = getStatus(basePath, target, wt.path);
+    if (status.filesChanged === 0 && !status.uncommitted) {
+        try {
+            removeWorktree(basePath, target, { deleteBranch: true });
+            ctx.ui.notify(`Removed empty worktree ${target}.`, "info");
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.ui.notify(`Worktree partially removed: ${msg}\n\nRun 'git worktree prune' to clean up any dangling registrations.`, "error");
+        }
+        return;
+    }
+    if (status.uncommitted) {
+        try {
+            autoCommitCurrentBranch(wt.path, "worktree-merge", target);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.ui.notify([
+                `Auto-commit before merge failed: ${msg}`,
+                "",
+                `Commit or stash changes in ${wt.path}, then re-run /gsd worktree merge ${target}.`,
+            ].join("\n"), "error");
+            return;
+        }
+    }
+    const commitType = inferCommitType(target);
+    const mainBranch = nativeDetectMainBranch(basePath);
+    const commitMessage = `${commitType}: merge worktree ${target}\n\nGSD-Worktree: ${target}`;
+    try {
+        mergeWorktreeToMain(basePath, target, commitMessage);
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        if (err instanceof GSDError && err.code === GSD_GIT_ERROR) {
+            ctx.ui.notify(`Merge requires the main branch to be checked out: ${msg}\n\nSwitch to ${mainBranch} (e.g. 'git checkout ${mainBranch}'), then re-run /gsd worktree merge ${target}.`, "error");
+        }
+        else {
+            ctx.ui.notify(`Merge failed: ${msg}\n\nResolve conflicts manually, then run /gsd worktree merge ${target} again.`, "error");
+        }
+        return;
+    }
+    const successLines = [
+        `Merged ${target} → ${mainBranch}`,
+        `  ${status.filesChanged} file${status.filesChanged === 1 ? "" : "s"}, +${status.linesAdded} -${status.linesRemoved}`,
+        `  commit: ${commitMessage.split("\n")[0]}`,
+    ];
+    try {
+        removeWorktree(basePath, target, { deleteBranch: true });
+        ctx.ui.notify(successLines.join("\n"), "info");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        const cleanupLines = [
+            ...successLines,
+            "",
+            `Cleanup failed after the merge succeeded: ${msg}`,
+            err instanceof GSDError && err.code === GSD_GIT_ERROR
+                ? `Switch to ${mainBranch} (e.g. 'git checkout ${mainBranch}'), then remove the worktree manually with /gsd worktree remove ${target} --force.`
+                : `Remove the worktree manually with /gsd worktree remove ${target} --force, or run 'git worktree prune' to clean up dangling registrations.`,
+        ];
+        ctx.ui.notify(cleanupLines.join("\n"), "warning");
+    }
+}
+// ─── Subcommand: clean ──────────────────────────────────────────────────────
+async function handleClean(ctx) {
+    const basePath = projectRoot();
+    const worktrees = listWorktrees(basePath);
+    if (worktrees.length === 0) {
+        ctx.ui.notify("No worktrees to clean.", "info");
+        return;
+    }
+    const removed = [];
+    const kept = [];
+    for (const wt of worktrees) {
+        const status = getStatus(basePath, wt.name, wt.path);
+        if (status.filesChanged === 0 && !status.uncommitted) {
+            try {
+                removeWorktree(basePath, wt.name, { deleteBranch: true });
+                removed.push(wt.name);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                kept.push(`${wt.name} (failed: ${msg})`);
+            }
+        }
+        else {
+            const reason = formatCleanKeepReason(status);
+            kept.push(`${wt.name} (${reason})`);
+        }
+    }
+    const lines = [`Cleaned ${removed.length} worktree${removed.length === 1 ? "" : "s"}.`];
+    if (removed.length > 0) {
+        lines.push("", "Removed:");
+        for (const n of removed)
+            lines.push(`  ✓ ${n}`);
+    }
+    if (kept.length > 0) {
+        lines.push("", "Kept:");
+        for (const n of kept)
+            lines.push(`  ─ ${n}`);
+    }
+    ctx.ui.notify(lines.join("\n"), "info");
+}
+// ─── Subcommand: remove ─────────────────────────────────────────────────────
+async function handleRemove(args, ctx) {
+    const basePath = projectRoot();
+    const tokens = args.trim().split(/\s+/).filter(Boolean);
+    const force = tokens.includes("--force");
+    const name = tokens.find((t) => t !== "--force");
+    if (!name) {
+        ctx.ui.notify("Usage: /gsd worktree remove <name> [--force]", "warning");
+        return;
+    }
+    const worktrees = listWorktrees(basePath);
+    const wt = worktrees.find((w) => w.name === name);
+    if (!wt) {
+        const available = worktrees.map((w) => w.name).join(", ") || "(none)";
+        ctx.ui.notify(`Worktree "${name}" not found.\n\nAvailable: ${available}`, "error");
+        return;
+    }
+    const status = getStatus(basePath, name, wt.path);
+    if ((status.filesChanged > 0 || status.uncommitted) && !force) {
+        ctx.ui.notify([
+            `Worktree "${name}" has pending changes (${formatCleanKeepReason(status)}).`,
+            "",
+            `  Merge first:     /gsd worktree merge ${name}`,
+            `  Or force-remove: /gsd worktree remove ${name} --force`,
+        ].join("\n"), "warning");
+        return;
+    }
+    try {
+        removeWorktree(basePath, name, { deleteBranch: true });
+        ctx.ui.notify(`Removed worktree ${name}.`, "info");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Worktree partially removed: ${msg}\n\nRun 'git worktree prune' to clean up any dangling registrations.`, "error");
+    }
+}
+// ─── Help text ──────────────────────────────────────────────────────────────
+const HELP_TEXT = [
+    "Usage: /gsd worktree <command> [args]",
+    "",
+    "Commands:",
+    "  list                       Show all worktrees with status",
+    "  merge [name]               Merge a worktree into main, then remove it",
+    "  remove <name> [--force]    Remove a worktree (refuses unmerged changes without --force)",
+    "  clean                      Remove all merged/empty worktrees",
+    "",
+    "The -w flag (CLI only) creates/resumes worktrees on session start:",
+    "  gsd -w               Auto-name a new worktree, or resume the only active one",
+    "  gsd -w my-feature    Create or resume a named worktree",
+].join("\n");
+// ─── Dispatcher ─────────────────────────────────────────────────────────────
+export async function handleWorktree(args, ctx) {
+    const trimmed = args.trim();
+    const lowered = trimmed.toLowerCase();
+    if (!lowered || lowered === "help" || lowered === "--help" || lowered === "-h") {
+        ctx.ui.notify(HELP_TEXT, "info");
+        return;
+    }
+    try {
+        if (lowered === "list" || lowered === "ls") {
+            await handleList(ctx);
+            return;
+        }
+        if (lowered === "merge" || lowered.startsWith("merge ")) {
+            await handleMerge(trimmed.replace(/^merge\s*/i, ""), ctx);
+            return;
+        }
+        if (lowered === "clean") {
+            await handleClean(ctx);
+            return;
+        }
+        if (lowered === "remove" ||
+            lowered.startsWith("remove ") ||
+            lowered === "rm" ||
+            lowered.startsWith("rm ")) {
+            const stripped = trimmed.replace(/^(remove|rm)\s*/i, "");
+            await handleRemove(stripped, ctx);
+            return;
+        }
+        ctx.ui.notify(`Unknown worktree command: ${trimmed}\n\n${HELP_TEXT}`, "warning");
+    }
+    catch (err) {
+        const msg = err instanceof Error ? err.message : String(err);
+        ctx.ui.notify(`Worktree command failed: ${msg}`, "error");
+    }
+}

package/dist/resources/extensions/gsd/prompts/guided-discuss-milestone.md

@@ -1,3 +1,5 @@
+**Working directory:** `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` to any other directory.
+
 Discuss milestone {{milestoneId}} ("{{milestoneTitle}}"). Identify gray areas, ask the user about them, and write `{{milestoneId}}-CONTEXT.md` in the milestone directory with the decisions. Use the **Context** output template below. If a `GSD Skill Preferences` block is present in system context, use it to decide which skills to load and follow; do not override required artifact rules.
 
 **Structured questions available: {{structuredQuestionsAvailable}}**

package/dist/resources/extensions/gsd/prompts/parallel-research-slices.md

@@ -1,5 +1,7 @@
 # Parallel Slice Research
 
+**Working directory:** `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` to any other directory.
+
 You are dispatching parallel research agents for **{{sliceCount}} slices** in milestone **{{mid}} — {{midTitle}}**.
 
 ## Slices to Research

package/dist/resources/extensions/gsd/prompts/rewrite-docs.md

@@ -1,5 +1,7 @@
 You are executing GSD auto-mode.
 
+**Working directory:** `{{workingDirectory}}`. All file reads, writes, and shell commands MUST operate relative to this directory. Do NOT `cd` to any other directory.
+
 ## UNIT: Rewrite Documents — Apply Override(s) for Milestone {{milestoneId}} ("{{milestoneTitle}}")
 
 An override was issued by the user that changes a fundamental decision or approach. Your job is to propagate this change across all active planning documents so they are internally consistent and future tasks execute correctly.

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

@@ -297,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/mcp-client/index.js

@@ -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/skills/lint/SKILL.md

@@ -7,6 +7,10 @@ description: Lint and format code. Auto-detects ESLint, Biome, Prettier, or lang
 Lint and format code in the current project. Auto-detect the project's linter and formatter toolchain, run them against the target files, and report results grouped by severity with actionable fix suggestions.
 </objective>
 
+<working_directory_awareness>
+**Before running any `git` or build command:** check whether your dispatch context specifies a working directory (look for "Working directory:" in your initial prompt). If it does and `pwd` does not match it, prefix every git invocation with `-C <that path>` (e.g. `git -C /path/to/worktree diff --name-only`) and run linters/formatters with the explicit path argument. Linting the wrong directory is a silent failure mode.
+</working_directory_awareness>
+
 <arguments>
 This skill accepts optional arguments after `/lint`:
 

package/dist/resources/skills/review/SKILL.md

@@ -23,6 +23,10 @@ The reviewer reads both the diff and the surrounding source files to understand
 The purpose is to review and report findings. Making changes during review conflates the reviewer and author roles. Present findings and let the user decide what to act on.
 </analysis_only_rule>
 
+<working_directory_awareness>
+**Before running any `git` command:** check whether your dispatch context specifies a working directory (look for "Working directory:" in your initial prompt). If it does and `pwd` does not match it, prefix every git invocation with `-C <that path>` (e.g. `git -C /path/to/worktree diff --cached`). Reviewing the wrong directory's diff is a silent failure mode — the review will look correct but cover the wrong code.
+</working_directory_awareness>
+
 <quick_start>
 
 <determine_review_scope>

package/dist/resources/skills/test/SKILL.md

@@ -151,6 +151,9 @@ Failures:
 **Suggest what to test when no arguments are given.**
 
 **A. Check recent changes:**
+
+> **Working directory check:** if your dispatch context specifies a working directory and `pwd` does not match it, prefix the git commands below with `-C <that path>` (e.g. `git -C /path/to/worktree diff --name-only HEAD~5`).
+
 - Run `git diff --name-only HEAD~5` to find recently changed files
 - Run `git diff --name-only --cached` for staged files
 - Filter to source files (exclude configs, docs, lockfiles)