@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

package/dist/resources/extensions/gsd/tui/render-kit.js

@@ -1,6 +1,6 @@
 // Project/App: gsd-pi
 // File Purpose: Shared terminal rendering helpers for GSD extension TUI surfaces.
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
+import { style, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
 export function safeLine(text, width, ellipsis = "…") {
     if (width <= 0)
         return "";
@@ -73,18 +73,43 @@ export function renderPanel(theme, title, inner, width, options = {}) {
         return [safeLine(title, width), ...inner.map((line) => safeLine(line, width))];
     }
     const ruleColor = options.ruleColor ?? "borderAccent";
-    const indent = Math.max(0, options.indent ?? 2);
-    const rule = (text) => theme.fg(ruleColor, text);
-    // Header rule: "── <title> ───────"
-    const lead = "── ";
-    const headerUsed = visibleWidth(lead) + visibleWidth(title) + 1;
-    const headerFill = Math.max(0, width - headerUsed);
-    const header = safeLine(rule(lead) + title + " " + rule("─".repeat(headerFill)), width, "");
-    // Body lines, indented so no chrome sits on copyable text.
-    const pad = " ".repeat(indent);
-    const contentWidth = Math.max(0, width - indent);
-    const body = inner.map((line) => safeLine(pad + safeLine(line, contentWidth), width, ""));
-    return [header, "", ...body, rule("─".repeat(width))];
+    const paddingX = Math.max(0, options.indent ?? 0);
+    const surface = style()
+        .border("open")
+        .title(title, (text) => theme.fg(ruleColor, text))
+        .borderColor((text) => theme.fg(ruleColor, text))
+        .paddingX(paddingX)
+        .bottomRule(true);
+    const body = inner.length > 0 ? inner : [""];
+    return surface.render(body, width);
+}
+/**
+ * Plain transcript outcome — matches the GSD chat/tool speaker line (no rule box).
+ * Header: `GSD · <status>` with optional right meta; body copy-clean; optional footer right.
+ */
+export function renderPlainOutcome(theme, width, statusLine, bodyLines, options) {
+    const headerLeft = theme.fg("accent", theme.bold("GSD")) + theme.fg("dim", " · ") + statusLine;
+    const header = options?.headerRight
+        ? rightAlign(headerLeft, options.headerRight, width)
+        : safeLine(headerLeft, width);
+    const out = [header];
+    if (options?.splitRows && options.splitRows.length > 0) {
+        for (const row of options.splitRows) {
+            out.push(row.right ? rightAlign(row.left, row.right, width) : safeLine(row.left, width));
+        }
+    }
+    else {
+        for (const line of bodyLines.filter(Boolean)) {
+            out.push(safeLine(line, width));
+        }
+    }
+    if (options?.footerRight) {
+        out.push(rightAlign("", options.footerRight, width));
+    }
+    if (out.length === 1 && !options?.footerRight) {
+        return [header, ""];
+    }
+    return [...out, ""];
 }
 export function renderFrame(theme, inner, width, options = {}) {
     if (width < 4)

package/dist/resources/extensions/gsd/unit-context-composer.js

@@ -125,7 +125,7 @@ export function composeContextModeInstructions(unitType, opts) {
 }
 const TOOL_SURFACE_GUIDANCE_BY_UNIT = {
     "run-uat": "Do not call `gsd_exec`, `Bash`, `Write`, or `Edit` — they are unavailable in this unit. Run every automated check through `gsd_uat_exec` with the appropriate `intent`. For browser UAT modes, use `browser_*` tools when presented; if browser automation fails, record the failure honestly and use `gsd_uat_exec` for the best objective substitute.",
-    "complete-slice": "Run slice-level verification through `gsd_exec` (or MCP-scoped `mcp__…__gsd_exec`), not direct `bash`. Do not call `gsd_uat_result_save` — run-uat owns persisted UAT assessment. On verification failure, do not edit user source files in this unit.",
+    "complete-slice": "Run slice-level verification through `gsd_exec` (or MCP-scoped `mcp__…__gsd_exec`), not direct `bash`. Capture learnings through `gsd_capture_thought` (or MCP-scoped `mcp__…__gsd_capture_thought`), not bare `capture_thought`, when workflow MCP tools are presented. Do not call `gsd_uat_result_save` — run-uat owns persisted UAT assessment. On verification failure, do not edit user source files in this unit.",
     "gate-evaluate": "Dispatch only **tester** subagents via `subagent`. Persist each gate with `gsd_save_gate_result`. Do not use `ToolSearch` — it is not available.",
     "reactive-execute": "Dispatch only **worker** subagents via `subagent`. Do not call `gsd_task_complete` from this parent batch — each worker owns its task completion. If a failed task left no summary, call `gsd_summary_save` with `blocker_discovered: true`.",
     "execute-task": "Complete only this task via `gsd_task_complete`. Do not call `gsd_slice_complete`, `gsd_validate_milestone`, or `gsd_complete_milestone` — the orchestrator owns phase transitions.",

package/dist/resources/extensions/gsd/unit-registry.js

@@ -173,15 +173,19 @@ export const UNIT_REGISTRY = {
         phaseChain: ["completion"],
         toolContract: {
             allowedGsdTools: [
+                "gsd_exec",
                 "gsd_slice_complete",
                 "gsd_task_reopen",
                 "gsd_replan_slice",
                 "gsd_decision_save",
+                "gsd_capture_thought",
                 "gsd_requirement_update",
                 "gsd_summary_save",
                 "subagent",
             ],
             requiredWorkflowTools: [
+                "gsd_exec",
+                "gsd_capture_thought",
                 "gsd_slice_complete",
                 "gsd_task_reopen",
                 "gsd_replan_slice",
@@ -207,8 +211,21 @@ export const UNIT_REGISTRY = {
         scopeClass: "execute-task",
         phaseChain: ["execution"],
         toolContract: {
-            allowedGsdTools: ["gsd_task_complete", "gsd_decision_save"],
-            requiredWorkflowTools: ["gsd_task_complete"],
+            allowedGsdTools: [
+                "gsd_task_complete",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+                "gsd_capture_thought",
+                "gsd_decision_save",
+            ],
+            requiredWorkflowTools: [
+                "gsd_task_complete",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+                "gsd_capture_thought",
+            ],
         },
     },
     "execute-task-simple": {
@@ -216,8 +233,21 @@ export const UNIT_REGISTRY = {
         scopeClass: "execute-task",
         phaseChain: ["execution_simple", "execution"],
         toolContract: {
-            allowedGsdTools: ["gsd_task_complete", "gsd_decision_save"],
-            requiredWorkflowTools: ["gsd_task_complete"],
+            allowedGsdTools: [
+                "gsd_task_complete",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+                "gsd_capture_thought",
+                "gsd_decision_save",
+            ],
+            requiredWorkflowTools: [
+                "gsd_task_complete",
+                "gsd_exec",
+                "gsd_exec_search",
+                "gsd_resume",
+                "gsd_capture_thought",
+            ],
         },
     },
     "reactive-execute": {

package/dist/resources/extensions/gsd/workflow-logger.js

@@ -42,6 +42,10 @@ export function setStderrLoggingEnabled(enabled) {
     _stderrEnabled = enabled;
     return previous;
 }
+/** Whether GSD extension diagnostics may write directly to process.stderr. */
+export function isGsdExtensionStderrEnabled() {
+    return _stderrEnabled;
+}
 // ─── Public API ─────────────────────────────────────────────────────────
 /**
  * Record a warning. Warnings are persisted to notifications and buffered for

package/dist/resources/extensions/gsd/workflow-mcp-auto-prep.js

@@ -1,4 +1,5 @@
 import { ensureProjectWorkflowMcpConfig, } from "./mcp-project-config.js";
+import { warmWorkflowMcpProbeInBackground } from "./workflow-mcp-readiness-cache.js";
 import { usesWorkflowMcpTransport } from "./workflow-mcp.js";
 function withModelOverride(ctx, modelOverride) {
     if (!modelOverride)
@@ -46,6 +47,7 @@ export function prepareWorkflowMcpForProject(ctx, projectRoot, modelOverride) {
         if (result.status !== "unchanged") {
             prepCtx.ui?.notify?.(`GSD MCP Server Prepared at ${result.configPath}`, "info");
         }
+        warmWorkflowMcpProbeInBackground(projectRoot);
         return result;
     }
     catch (err) {

package/dist/resources/extensions/gsd/workflow-mcp-readiness-cache.js

@@ -0,0 +1,105 @@
+// Project/App: gsd-pi
+// File Purpose: Share recent workflow MCP probe results across guided-flow and Claude Code SDK preflight.
+import { testMcpServerConnection } from "../mcp-client/manager.js";
+import { mcpToolMatchesBaseName } from "./mcp-tool-name.js";
+import { detectWorkflowMcpLaunchConfig, resolveWorkflowMcpProjectRoot, } from "./workflow-mcp.js";
+import { isWorkflowToolSurfaceName } from "./workflow-tool-surface.js";
+/** Reuse a recent successful probe instead of spawning another stdio server. */
+export const WORKFLOW_MCP_PROBE_CACHE_TTL_MS = 120_000;
+/** Per-probe connect + tools/list budget (server typically ready in ~1–2s). */
+export const WORKFLOW_MCP_PROBE_TIMEOUT_MS = 5_000;
+const cacheByProject = new Map();
+const probeInFlightByProject = new Map();
+let activeWorkflowMcpSdkSessions = 0;
+function cacheKey(projectRoot) {
+    return resolveWorkflowMcpProjectRoot(projectRoot);
+}
+export function beginWorkflowMcpSdkSession() {
+    activeWorkflowMcpSdkSessions++;
+}
+export function endWorkflowMcpSdkSession() {
+    activeWorkflowMcpSdkSessions = Math.max(0, activeWorkflowMcpSdkSessions - 1);
+}
+export function getCachedWorkflowMcpProbe(projectRoot) {
+    const entry = cacheByProject.get(cacheKey(projectRoot));
+    if (!entry)
+        return null;
+    if (Date.now() - entry.probedAt > WORKFLOW_MCP_PROBE_CACHE_TTL_MS) {
+        cacheByProject.delete(cacheKey(projectRoot));
+        return null;
+    }
+    return entry;
+}
+export function recordWorkflowMcpProbe(projectRoot, serverName, tools) {
+    cacheByProject.set(cacheKey(projectRoot), {
+        serverName,
+        tools: [...tools],
+        probedAt: Date.now(),
+    });
+}
+export function clearWorkflowMcpProbeCache(projectRoot) {
+    if (projectRoot === undefined) {
+        cacheByProject.clear();
+        probeInFlightByProject.clear();
+        activeWorkflowMcpSdkSessions = 0;
+        return;
+    }
+    const key = cacheKey(projectRoot);
+    cacheByProject.delete(key);
+    probeInFlightByProject.delete(key);
+}
+export function workflowMcpProbeAdvertisesSurface(tools) {
+    return tools.some((tool) => isWorkflowToolSurfaceName(tool));
+}
+export function cachedWorkflowMcpCoversRequired(projectRoot, serverName, required) {
+    const entry = getCachedWorkflowMcpProbe(projectRoot);
+    if (!entry || entry.serverName !== serverName)
+        return false;
+    return required.every((tool) => entry.tools.some((name) => name === tool || mcpToolMatchesBaseName(name, tool)));
+}
+async function runProbeAndCacheWorkflowMcp(projectRoot, options = {}) {
+    const root = cacheKey(projectRoot);
+    const launch = detectWorkflowMcpLaunchConfig(root);
+    const serverName = launch?.name ?? "gsd-workflow";
+    const cached = getCachedWorkflowMcpProbe(projectRoot);
+    if (cached && workflowMcpProbeAdvertisesSurface(cached.tools)) {
+        return { ok: true, tools: cached.tools, serverName: cached.serverName };
+    }
+    const result = await testMcpServerConnection(serverName, {
+        projectDir: root,
+        timeoutMs: options.timeoutMs ?? WORKFLOW_MCP_PROBE_TIMEOUT_MS,
+    });
+    if (result.ok && workflowMcpProbeAdvertisesSurface(result.tools)) {
+        recordWorkflowMcpProbe(projectRoot, serverName, result.tools);
+    }
+    return {
+        ok: result.ok,
+        tools: result.tools,
+        serverName,
+        error: result.error,
+    };
+}
+export async function probeAndCacheWorkflowMcp(projectRoot, options = {}) {
+    const key = cacheKey(projectRoot);
+    const inFlight = probeInFlightByProject.get(key);
+    if (inFlight)
+        return inFlight;
+    const promise = runProbeAndCacheWorkflowMcp(projectRoot, options).finally(() => {
+        probeInFlightByProject.delete(key);
+    });
+    probeInFlightByProject.set(key, promise);
+    return promise;
+}
+/** Fire-and-forget probe so /gsd dispatch often hits a warm cache. */
+export function warmWorkflowMcpProbeInBackground(projectRoot) {
+    if (activeWorkflowMcpSdkSessions > 0)
+        return;
+    const key = cacheKey(projectRoot);
+    if (getCachedWorkflowMcpProbe(projectRoot))
+        return;
+    if (probeInFlightByProject.has(key))
+        return;
+    void probeAndCacheWorkflowMcp(projectRoot).catch(() => {
+        // Background warm is best-effort.
+    });
+}

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

@@ -17,7 +17,7 @@
  *   3. merge()   — LLM-guided reconciliation of .gsd/ artifacts back to main
  *   4. remove()  — git worktree remove + branch cleanup
  */
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, statSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { join, resolve, sep } from "node:path";
 import { GSDError, GSD_PARSE_ERROR, GSD_STALE_STATE, GSD_LOCK_HELD, GSD_GIT_ERROR, GSD_MERGE_CONFLICT } from "./errors.js";
@@ -25,6 +25,7 @@ import { logWarning } from "./workflow-logger.js";
 import { nativeBranchList, 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";
+import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { canonicalWorktreesDir, worktreePathFor, worktreesDirs } from "./worktree-placement.js";
 function deleteBranchIfPresent(basePath, branch, warningPrefix) {
     try {
@@ -132,6 +133,98 @@ function isRegisteredGitWorktreeAtPath(basePath, wtPath) {
         return false;
     }
 }
+/** True when `wtPath` has a git worktree checkout marker (`.git` file with gitdir pointer). */
+export function isLiveGitWorktreeCheckout(wtPath) {
+    const gitPath = join(wtPath, ".git");
+    if (!existsSync(gitPath))
+        return false;
+    try {
+        return lstatSync(gitPath).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+/** True when a worktree directory should count toward idle milestone residue detection. */
+export function isMilestoneWorktreeResidueCandidate(basePath, wtPath) {
+    return isRegisteredGitWorktreeAtPath(basePath, wtPath) || isLiveGitWorktreeCheckout(wtPath);
+}
+const EPHEMERAL_GHOST_WORKTREE_ENTRIES = new Set([".bg-shell", ".DS_Store"]);
+function isEphemeralGhostWorktreeContents(dirPath) {
+    let entries;
+    try {
+        entries = readdirSync(dirPath);
+    }
+    catch {
+        return false;
+    }
+    if (entries.length === 0)
+        return true;
+    for (const entry of entries) {
+        if (EPHEMERAL_GHOST_WORKTREE_ENTRIES.has(entry))
+            continue;
+        if (entry === ".gsd") {
+            try {
+                const gsdEntries = readdirSync(join(dirPath, ".gsd"));
+                if (gsdEntries.length <= 1 && gsdEntries.every((e) => e === "doctor-history.jsonl")) {
+                    continue;
+                }
+            }
+            catch {
+                return false;
+            }
+            continue;
+        }
+        return false;
+    }
+    return true;
+}
+/**
+ * Remove milestone worktree directories that are not registered with git and
+ * contain only ephemeral runtime content (e.g. bg-shell manifests recreated
+ * after teardown). Returns removed directory paths.
+ */
+export function pruneEphemeralGhostWorktreeDirectories(basePath) {
+    const removed = [];
+    for (const container of allWorktreesDirs(basePath)) {
+        if (!existsSync(container))
+            continue;
+        let entries;
+        try {
+            entries = readdirSync(container);
+        }
+        catch {
+            continue;
+        }
+        for (const entry of entries) {
+            if (!MILESTONE_ID_RE.test(entry))
+                continue;
+            const fullPath = join(container, entry);
+            try {
+                if (!statSync(fullPath).isDirectory())
+                    continue;
+            }
+            catch {
+                continue;
+            }
+            if (isRegisteredGitWorktreeAtPath(basePath, fullPath))
+                continue;
+            if (isLiveGitWorktreeCheckout(fullPath))
+                continue;
+            if (!isEphemeralGhostWorktreeContents(fullPath))
+                continue;
+            try {
+                rmSync(fullPath, { recursive: true, force: true });
+                logWarning("reconcile", `Removed ephemeral ghost worktree directory (not registered with git): ${fullPath}`, { worktree: entry });
+                removed.push(fullPath);
+            }
+            catch (err) {
+                logWarning("worktree", `ghost worktree directory removal failed for ${fullPath}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+    }
+    return removed;
+}
 function removeStaleWorktreeDirectory(wtPath, name) {
     logWarning("reconcile", `Removing stale worktree directory (not registered with git): ${wtPath}`, { worktree: name });
     try {
@@ -528,7 +621,13 @@ export function removeWorktree(basePath, name, opts = {}) {
     // inside .gsd/worktrees/ — a symlink inside the directory could point out.
     const resolvedPathSafe = isInsideWorktreesDir(basePath, resolvedWtPath);
     // If we're inside the worktree, move out first — git can't remove an in-use directory
-    const cwd = process.cwd();
+    let cwd;
+    try {
+        cwd = process.cwd();
+    }
+    catch {
+        cwd = basePath;
+    }
     const resolvedCwd = existsSync(cwd) ? realpathSync(cwd) : cwd;
     if (resolvedCwd === resolvedWtPath || resolvedCwd.startsWith(resolvedWtPath + sep)) {
         process.chdir(basePath);

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

@@ -90,38 +90,40 @@ export function createWorktreeSafetyModule(deps = defaultDeps) {
                 return failure("worktree-git-marker-not-file", `Worktree root ${unitRoot} has a .git directory, not a registered worktree .git file.`, "Use a registered GSD worktree instead of a copied or nested repository.", { gitMarker });
             }
             let registered;
-            try {
-                registered = deps.listRegisteredWorktrees?.(projectRoot);
-            }
-            catch (error) {
-                return failure("worktree-git-probe-failed", `Unable to list registered worktrees for project root ${projectRoot}.`, "Recover or recreate the milestone worktree before dispatching the source-writing Unit.", { projectRoot, error: errorMessage(error) });
-            }
-            if (registered && !registered.some((worktree) => samePath(worktree.path, unitRoot))) {
-                const wasPreviouslyTracked = unregisteredRecoveryFailed.has(unitRoot);
-                let attemptedPrune = false;
-                if (!wasPreviouslyTracked && deps.pruneRegisteredWorktrees) {
-                    attemptedPrune = true;
-                    try {
-                        deps.pruneRegisteredWorktrees(projectRoot);
-                        const rechecked = deps.listRegisteredWorktrees?.(projectRoot);
-                        if (rechecked?.some((worktree) => samePath(worktree.path, unitRoot))) {
-                            unregisteredRecoveryFailed.delete(unitRoot);
-                            registered = rechecked;
+            if (isolationMode === "worktree") {
+                try {
+                    registered = deps.listRegisteredWorktrees?.(projectRoot);
+                }
+                catch (error) {
+                    return failure("worktree-git-probe-failed", `Unable to list registered worktrees for project root ${projectRoot}.`, "Recover or recreate the milestone worktree before dispatching the source-writing Unit.", { projectRoot, error: errorMessage(error) });
+                }
+                if (registered && !registered.some((worktree) => samePath(worktree.path, unitRoot))) {
+                    const wasPreviouslyTracked = unregisteredRecoveryFailed.has(unitRoot);
+                    let attemptedPrune = false;
+                    if (!wasPreviouslyTracked && deps.pruneRegisteredWorktrees) {
+                        attemptedPrune = true;
+                        try {
+                            deps.pruneRegisteredWorktrees(projectRoot);
+                            const rechecked = deps.listRegisteredWorktrees?.(projectRoot);
+                            if (rechecked?.some((worktree) => samePath(worktree.path, unitRoot))) {
+                                unregisteredRecoveryFailed.delete(unitRoot);
+                                registered = rechecked;
+                            }
+                            else {
+                                unregisteredRecoveryFailed.add(unitRoot);
+                            }
                         }
-                        else {
+                        catch (error) {
                             unregisteredRecoveryFailed.add(unitRoot);
+                            return failure("worktree-git-probe-failed", `Unable to recover unregistered worktree root ${unitRoot}.`, "Run 'git worktree prune', then recreate or re-register the milestone worktree before dispatching the source-writing Unit.", { projectRoot, unitRoot, error: errorMessage(error) });
                         }
                     }
-                    catch (error) {
-                        unregisteredRecoveryFailed.add(unitRoot);
-                        return failure("worktree-git-probe-failed", `Unable to recover unregistered worktree root ${unitRoot}.`, "Run 'git worktree prune', then recreate the milestone worktree before dispatching the source-writing Unit.", { projectRoot, unitRoot, error: errorMessage(error) });
+                    if (!registered?.some((worktree) => samePath(worktree.path, unitRoot))) {
+                        return failure("worktree-unregistered", `Worktree root ${unitRoot} is not registered with git worktree list.`, attemptedPrune || wasPreviouslyTracked
+                            ? "Worktree recovery was attempted but the root is still unregistered. Recreate or re-register the milestone worktree before dispatching the source-writing Unit."
+                            : "Run 'git worktree prune'. If still unregistered, recreate or re-register the milestone worktree before dispatching the source-writing Unit.", { unitRoot, attemptedPrune, trackedAsFailed: unregisteredRecoveryFailed.has(unitRoot) });
                     }
                 }
-                if (!registered?.some((worktree) => samePath(worktree.path, unitRoot))) {
-                    return failure("worktree-unregistered", `Worktree root ${unitRoot} is not registered with git worktree list.`, attemptedPrune || wasPreviouslyTracked
-                        ? "Worktree recovery was attempted but the root is still unregistered. Recreate or re-register the milestone worktree before dispatching the source-writing Unit."
-                        : "Run 'git worktree prune'. If still unregistered, recreate or re-register the milestone worktree before dispatching the source-writing Unit.", { unitRoot, attemptedPrune, trackedAsFailed: unregisteredRecoveryFailed.has(unitRoot) });
-                }
             }
             if (input.emptyWorktreeWithProjectContent) {
                 return failure("empty-worktree-with-project-content", `Worktree root ${unitRoot} has no project content, but the project root does.`, "Resolve untracked project-root content or recreate the worktree so source writes stay isolated.", { unitRoot, projectRoot });

package/dist/resources/extensions/gsd/worktree-shell-guard.js

@@ -0,0 +1,113 @@
+// Project/App: gsd-pi
+// File Purpose: Detect shell commands that reference the project root from a milestone worktree.
+import { realpathSync } from "node:fs";
+import path from "node:path";
+import { projectRootFromWorktreePath } from "./worktree-root.js";
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function normalizeScanPath(value) {
+    const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
+    return normalized.startsWith("/private/var/")
+        ? normalized.slice("/private".length)
+        : normalized;
+}
+function parseWorktreeBase(baseDir) {
+    const normalizedBase = normalizeScanPath(baseDir);
+    const originalRoot = projectRootFromWorktreePath(normalizedBase);
+    if (!originalRoot)
+        return null;
+    return { originalRoot, worktreeRoot: normalizedBase };
+}
+function pathInside(parent, target) {
+    const parentWithSep = parent.endsWith("/") ? parent : `${parent}/`;
+    return target === parent || target.startsWith(parentWithSep);
+}
+function comparablePathVariants(value) {
+    const variants = new Set();
+    const normalized = normalizeScanPath(path.resolve(value));
+    variants.add(normalized);
+    try {
+        variants.add(normalizeScanPath(realpathSync(normalized)));
+    }
+    catch {
+        // Nonexistent paths are still compared lexically.
+    }
+    if (normalized.startsWith("/private/var/")) {
+        variants.add(normalized.replace(/^\/private\/var\//, "/var/"));
+    }
+    else if (normalized.startsWith("/var/")) {
+        variants.add(`/private${normalized}`);
+    }
+    return [...variants];
+}
+function pathInsideAny(parents, targets) {
+    return targets.some((target) => parents.some((parent) => pathInside(parent, target)));
+}
+function stripWrappingQuotes(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2)
+        return trimmed;
+    const first = trimmed[0];
+    const last = trimmed[trimmed.length - 1];
+    if ((first === "'" || first === '"' || first === "`") && last === first) {
+        return trimmed.slice(1, -1).trim();
+    }
+    return trimmed;
+}
+function extractPathLikeValues(script) {
+    const values = [];
+    const push = (candidate) => {
+        const cleaned = stripWrappingQuotes(candidate).trim();
+        if (!cleaned)
+            return;
+        values.push(cleaned);
+    };
+    const pushQuotedLiterals = (source, depth = 0) => {
+        for (const match of source.matchAll(/(["'`])((?:\\.|(?!\1).)*)\1/g)) {
+            push(match[2]);
+            if (depth < 2 && /["'`]/.test(match[2])) {
+                pushQuotedLiterals(match[2], depth + 1);
+            }
+        }
+    };
+    for (const match of script.matchAll(/(?:^|[;\n\r]|\&\&|\|\|)\s*cd\s+([^\n\r;|&]+)/g)) {
+        push(match[1]);
+    }
+    for (const match of script.matchAll(/process\.chdir\(\s*([^\n\r;]+?)\s*\)/g)) {
+        push(match[1]);
+        pushQuotedLiterals(match[1]);
+    }
+    pushQuotedLiterals(script);
+    return values;
+}
+export function resolvesToOriginalRootOutsideWorktree(script, baseDir) {
+    const parsed = parseWorktreeBase(baseDir);
+    if (!parsed)
+        return false;
+    const normalizedWorktree = normalizeScanPath(path.resolve(parsed.worktreeRoot));
+    const normalizedOriginalRoot = normalizeScanPath(path.resolve(parsed.originalRoot));
+    const worktreeRoots = comparablePathVariants(normalizedWorktree);
+    const originalRoots = comparablePathVariants(normalizedOriginalRoot);
+    for (const value of extractPathLikeValues(script)) {
+        const resolved = comparablePathVariants(path.resolve(normalizedWorktree, value));
+        if (pathInsideAny(originalRoots, resolved) && !pathInsideAny(worktreeRoots, resolved)) {
+            return true;
+        }
+    }
+    return false;
+}
+export function scriptReferencesOriginalRootFromWorktree(script, baseDir) {
+    const parsed = parseWorktreeBase(baseDir);
+    if (!parsed)
+        return false;
+    const normalizedScript = script.replace(/\\/g, "/");
+    return comparablePathVariants(parsed.originalRoot).some((originalRoot) => {
+        const originalRootPattern = new RegExp(`${escapeRegExp(originalRoot)}(?=$|[\\s'"\\\`;)&|<>]|/(?!\\.gsd(?:-worktrees|/worktrees)(?:/|$)))`);
+        return originalRootPattern.test(normalizedScript);
+    });
+}
+export function bashReferencesProjectRootOutsideWorktree(script, baseDir) {
+    return resolvesToOriginalRootOutsideWorktree(script, baseDir)
+        || scriptReferencesOriginalRootFromWorktree(script, baseDir);
+}

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

@@ -195,7 +195,14 @@ export function resolveGitHeadPath(dir) {
  */
 export function nudgeGitBranchCache(previousCwd) {
     const now = new Date();
-    for (const dir of [previousCwd, process.cwd()]) {
+    let currentCwd = null;
+    try {
+        currentCwd = process.cwd();
+    }
+    catch {
+        currentCwd = null;
+    }
+    for (const dir of [previousCwd, currentCwd].filter((dir) => Boolean(dir))) {
         try {
             const headPath = resolveGitHeadPath(dir);
             if (headPath)

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

@@ -30,6 +30,8 @@ const CHILD_ENV_ALLOWLIST = new Set([
     "XDG_CACHE_HOME",
 ]);
 const MCP_STDERR_MAX_BYTES = 4096;
+/** Short-lived stdio probes must not register/kill production MCP PIDs (see probe-mode.ts). */
+export const GSD_MCP_PROBE_ENV = "GSD_MCP_PROBE";
 let cachedStatus = null;
 let cachedStatusKey = "";
 export function clearMcpConfigCache() {
@@ -259,7 +261,10 @@ export async function testMcpServerConnection(nameOrConfig, options = {}) {
             transport = new StdioClientTransport({
                 command: config.command ?? "",
                 args: config.args,
-                env: buildMcpChildEnv(config.env),
+                env: {
+                    ...buildMcpChildEnv(config.env),
+                    [GSD_MCP_PROBE_ENV]: "1",
+                },
                 cwd: config.cwd,
                 stderr: "pipe",
             });