@opengsd/gsd-pi 1.2.0-dev.fbdca60b → 1.3.0-dev.65546769

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

@@ -13,7 +13,7 @@ import { isClosedStatus } from "./status-guards.js";
 import { deriveState } from "./state.js";
 import { renderPlanFromDb, renderRoadmapFromDb } from "./markdown-renderer.js";
 import { readManifest } from "./workflow-manifest.js";
-import { gsdRoot } from "./paths.js";
+import { gsdRoot, resolveSliceFile, resolveMilestonePath, resolveSlicePath, gsdProjectionRoot } from "./paths.js";
 // ─── Helpers ─────────────────────────────────────────────────────────────
 /**
  * Strip a leading ID prefix (e.g. "M001: " or "S04: ") from a title
@@ -276,7 +276,24 @@ export function renderSummaryProjection(basePath, milestoneId, sliceId, taskId)
         return;
     const evidenceRows = getVerificationEvidence(milestoneId, sliceId, taskId);
     const content = renderSummaryContent(taskRow, sliceId, milestoneId, evidenceRows);
-    const dir = join(basePath, ".gsd", "milestones", milestoneId, "slices", sliceId, "tasks");
+    // Layout-aware: avoid creating a milestones/ directory as a side effect for
+    // flat-phase projects. If milestonesDir() sees a freshly-created milestones/
+    // dir it treats the project as legacy, breaking all subsequent path resolution.
+    const slicePath = resolveSlicePath(basePath, milestoneId, sliceId);
+    const phaseDir = resolveMilestonePath(basePath, milestoneId);
+    let dir;
+    if (slicePath && phaseDir && slicePath !== phaseDir) {
+        // Legacy layout: slice has its own slices/SID/ subdir → tasks/ subdir
+        dir = join(slicePath, "tasks");
+    }
+    else if (phaseDir) {
+        // Flat-phase: task summaries go in the phase dir (no tasks/ subdir needed)
+        dir = phaseDir;
+    }
+    else {
+        // Fallback: legacy hardcoded path (milestone dir not on disk yet)
+        dir = join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks");
+    }
     mkdirSync(dir, { recursive: true });
     atomicWriteSync(join(dir, `${taskId}-SUMMARY.md`), content);
 }
@@ -447,7 +464,9 @@ export async function regenerateIfMissing(basePath, milestoneId, sliceId, fileTy
     let filePath;
     switch (fileType) {
         case "PLAN":
-            filePath = join(basePath, ".gsd", "milestones", milestoneId, "slices", sliceId, `${sliceId}-PLAN.md`);
+            // Use resolveSliceFile so both flat-phase and legacy layouts are detected.
+            // Falls back to "" (non-existent) when the file hasn't been rendered yet.
+            filePath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN") ?? "";
             break;
         case "ROADMAP":
             filePath = join(basePath, ".gsd", "milestones", milestoneId, `${milestoneId}-ROADMAP.md`);
@@ -497,7 +516,9 @@ export async function regenerateIfMissing(basePath, milestoneId, sliceId, fileTy
         switch (fileType) {
             case "PLAN":
                 await renderPlanFromDb(basePath, milestoneId, sliceId);
-                return existsSync(filePath);
+                // Re-resolve after render: the rendered file may be at a different path
+                // from the pre-check (flat-phase vs legacy). resolveSliceFile finds it.
+                return !!(resolveSliceFile(basePath, milestoneId, sliceId, "PLAN"));
             case "ROADMAP":
                 await renderRoadmapFromDb(basePath, milestoneId);
                 return existsSync(filePath);

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

@@ -454,11 +454,11 @@ async function handleMerge(basePath, name, ctx, pi, targetBranch) {
             return;
         }
         // Gather merge context — full repo diff, not just .gsd/
-        const diffSummary = diffWorktreeAll(basePath, name);
-        const numstat = diffWorktreeNumstat(basePath, name);
-        const gsdDiff = getWorktreeGSDDiff(basePath, name);
-        const codeDiff = getWorktreeCodeDiff(basePath, name);
-        const commitLog = getWorktreeLog(basePath, name);
+        const diffSummary = diffWorktreeAll(basePath, name, undefined, mainBranch);
+        const numstat = diffWorktreeNumstat(basePath, name, undefined, mainBranch);
+        const gsdDiff = getWorktreeGSDDiff(basePath, name, mainBranch);
+        const codeDiff = getWorktreeCodeDiff(basePath, name, mainBranch);
+        const commitLog = getWorktreeLog(basePath, name, mainBranch);
         const totalChanges = diffSummary.added.length + diffSummary.modified.length + diffSummary.removed.length;
         if (totalChanges === 0 && !commitLog.trim()) {
             ctx.ui.notify(`Worktree ${CLR.name(name)} has no changes to merge.`, "info");
@@ -541,7 +541,7 @@ async function handleMerge(basePath, name, ctx, pi, targetBranch) {
             catch { /* non-fatal */ }
         }
         try {
-            mergeWorktreeToMain(basePath, name, commitMessage);
+            mergeWorktreeToMain(basePath, name, commitMessage, undefined, mainBranch);
             ctx.ui.notify([
                 `${CLR.ok("✓")} Merged ${CLR.name(name)} → ${CLR.branch(mainBranch)} ${CLR.muted("(deterministic squash)")}`,
                 "",

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

@@ -19,9 +19,9 @@ const DEFAULT_STALE_DAYS = 14;
  * @param basePath — the main project root (not the worktree path)
  * @param wt — worktree info from listWorktrees()
  * @param staleDays — days without commits to consider stale (default: 14)
+ * @param mainBranch — pre-detected main branch for batched health checks
  */
-export function getWorktreeHealth(basePath, wt, staleDays = DEFAULT_STALE_DAYS) {
-    const mainBranch = nativeDetectMainBranch(basePath);
+export function getWorktreeHealth(basePath, wt, staleDays = DEFAULT_STALE_DAYS, mainBranch = nativeDetectMainBranch(basePath)) {
     // Merge status: is the worktree branch fully contained in main?
     let mergedIntoMain = false;
     try {
@@ -84,7 +84,10 @@ export function getWorktreeHealth(basePath, wt, staleDays = DEFAULT_STALE_DAYS)
  */
 export function getAllWorktreeHealth(basePath, staleDays = DEFAULT_STALE_DAYS) {
     const worktrees = listWorktrees(basePath);
-    return worktrees.map(wt => getWorktreeHealth(basePath, wt, staleDays));
+    if (worktrees.length === 0)
+        return [];
+    const mainBranch = nativeDetectMainBranch(basePath);
+    return worktrees.map(wt => getWorktreeHealth(basePath, wt, staleDays, mainBranch));
 }
 /**
  * Format a human-readable status line for a worktree health entry.

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,7 +133,99 @@ function isRegisteredGitWorktreeAtPath(basePath, wtPath) {
         return false;
     }
 }
-function removeStaleWorktreeDirectory(wtPath, name) {
+/** 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;
+}
+export function removeStaleWorktreeDirectory(wtPath, name) {
     logWarning("reconcile", `Removing stale worktree directory (not registered with git): ${wtPath}`, { worktree: name });
     try {
         rmSync(wtPath, { recursive: true, force: true });
@@ -728,10 +821,10 @@ function parseDiffNameStatus(entries) {
  * Diff the .gsd/ directory between the worktree branch and main branch.
  * Returns a summary of added, modified, and removed GSD artifacts.
  */
-export function diffWorktreeGSD(basePath, name) {
+export function diffWorktreeGSD(basePath, name, mainBranchOverride) {
     basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = worktreeBranchName(name);
-    const mainBranch = nativeDetectMainBranch(basePath);
+    const mainBranch = mainBranchOverride ?? nativeDetectMainBranch(basePath);
     const entries = nativeDiffNameStatus(basePath, mainBranch, branch, ".gsd/", true);
     return parseDiffNameStatus(entries);
 }
@@ -741,10 +834,10 @@ 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, branchOverride) {
+export function diffWorktreeAll(basePath, name, branchOverride, mainBranchOverride) {
     basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = branchOverride ?? worktreeBranchName(name);
-    const mainBranch = nativeDetectMainBranch(basePath);
+    const mainBranch = mainBranchOverride ?? nativeDetectMainBranch(basePath);
     const entries = nativeDiffNameStatus(basePath, mainBranch, branch);
     return parseDiffNameStatus(entries);
 }
@@ -752,10 +845,10 @@ export function diffWorktreeAll(basePath, name, branchOverride) {
  * 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, branchOverride) {
+export function diffWorktreeNumstat(basePath, name, branchOverride, mainBranchOverride) {
     basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = branchOverride ?? worktreeBranchName(name);
-    const mainBranch = nativeDetectMainBranch(basePath);
+    const mainBranch = mainBranchOverride ?? nativeDetectMainBranch(basePath);
     const rawStats = nativeDiffNumstat(basePath, mainBranch, branch);
     const stats = [];
     for (const entry of rawStats) {
@@ -769,29 +862,29 @@ export function diffWorktreeNumstat(basePath, name, branchOverride) {
  * Get the full diff content for .gsd/ between the worktree branch and main.
  * Returns the raw unified diff for LLM consumption.
  */
-export function getWorktreeGSDDiff(basePath, name) {
+export function getWorktreeGSDDiff(basePath, name, mainBranchOverride) {
     basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = worktreeBranchName(name);
-    const mainBranch = nativeDetectMainBranch(basePath);
+    const mainBranch = mainBranchOverride ?? nativeDetectMainBranch(basePath);
     return nativeDiffContent(basePath, mainBranch, branch, ".gsd/", undefined, true);
 }
 /**
  * Get the full diff content for non-.gsd/ files between the worktree branch and main.
  * Returns the raw unified diff for LLM consumption.
  */
-export function getWorktreeCodeDiff(basePath, name) {
+export function getWorktreeCodeDiff(basePath, name, mainBranchOverride) {
     basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = worktreeBranchName(name);
-    const mainBranch = nativeDetectMainBranch(basePath);
+    const mainBranch = mainBranchOverride ?? nativeDetectMainBranch(basePath);
     return nativeDiffContent(basePath, mainBranch, branch, undefined, ".gsd/", true);
 }
 /**
  * Get commit log for the worktree branch since it diverged from main.
  */
-export function getWorktreeLog(basePath, name) {
+export function getWorktreeLog(basePath, name, mainBranchOverride) {
     basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = worktreeBranchName(name);
-    const mainBranch = nativeDetectMainBranch(basePath);
+    const mainBranch = mainBranchOverride ?? nativeDetectMainBranch(basePath);
     const entries = nativeLogOneline(basePath, mainBranch, branch);
     return entries.map(e => `${e.sha} ${e.message}`).join("\n");
 }
@@ -800,10 +893,10 @@ 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, branchOverride) {
+export function mergeWorktreeToMain(basePath, name, commitMessage, branchOverride, mainBranchOverride) {
     basePath = normalizeBasePathForWorktreeOps(basePath);
     const branch = branchOverride ?? worktreeBranchName(name);
-    const mainBranch = nativeDetectMainBranch(basePath);
+    const mainBranch = mainBranchOverride ?? nativeDetectMainBranch(basePath);
     const current = nativeGetCurrentBranch(basePath);
     if (current !== mainBranch) {
         throw new GSDError(GSD_GIT_ERROR, `Must be on ${mainBranch} to merge. Currently on ${current}.`);

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

@@ -5,7 +5,7 @@ import { execFileSync } from "node:child_process";
 import { join, resolve } from "node:path";
 import { normalizeWorktreePathForCompare } from "./worktree-root.js";
 import { worktreesDirs } from "./worktree-placement.js";
-import { listWorktrees } from "./worktree-manager.js";
+import { listWorktrees, removeStaleWorktreeDirectory } from "./worktree-manager.js";
 import { getCurrentBranch } from "./worktree.js";
 const fsOnlyDeps = {
     existsSync,
@@ -25,6 +25,7 @@ const defaultDeps = {
             stdio: "pipe",
         });
     },
+    removeStaleWorktreeDirectory,
     getCurrentBranch,
 };
 function isValidMilestoneId(milestoneId) {
@@ -40,7 +41,6 @@ function errorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }
 export function createWorktreeSafetyModule(deps = defaultDeps) {
-    const unregisteredRecoveryFailed = new Set();
     return {
         validateUnitRoot(input) {
             if (input.writeScope === "planning-only") {
@@ -98,30 +98,39 @@ export function createWorktreeSafetyModule(deps = defaultDeps) {
                     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) {
+                    if (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);
-                            }
                         }
                         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) });
                         }
                     }
                     if (!registered?.some((worktree) => samePath(worktree.path, unitRoot))) {
-                        return failure("worktree-unregistered", `Worktree root ${unitRoot} is not registered with git worktree list.`, attemptedPrune || wasPreviouslyTracked
+                        // The directory exists on disk with a .git marker but git no longer
+                        // tracks it as a worktree (e.g. a prior removeWorktree crash left the
+                        // directory while `git worktree prune` cleaned the registry). Remove
+                        // the orphaned directory — the same cleanup createWorktree performs —
+                        // so the next dispatch recreates the milestone worktree from scratch
+                        // instead of looping forever on worktree-unregistered (#803, #590).
+                        if (deps.removeStaleWorktreeDirectory) {
+                            try {
+                                deps.removeStaleWorktreeDirectory(unitRoot, milestoneId);
+                                return failure("worktree-missing", `Worktree root ${unitRoot} was not registered with git; removed the orphaned directory so it can be recreated.`, "Recreate the milestone worktree before dispatching the source-writing Unit. Auto-mode recreates it automatically on the next dispatch.", { unitRoot, attemptedPrune, removedStaleDirectory: true });
+                            }
+                            catch (error) {
+                                return failure("worktree-unregistered", `Worktree root ${unitRoot} is not registered with git worktree list and the orphaned directory could not be removed.`, "Remove the orphaned worktree directory manually (it may be locked by another process), then recreate or re-register the milestone worktree before dispatching the source-writing Unit.", { unitRoot, attemptedPrune, removedStaleDirectory: false, error: errorMessage(error) });
+                            }
+                        }
+                        return failure("worktree-unregistered", `Worktree root ${unitRoot} is not registered with git worktree list.`, attemptedPrune
                             ? "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) });
+                            : "Run 'git worktree prune'. If still unregistered, recreate or re-register the milestone worktree before dispatching the source-writing Unit.", { unitRoot, attemptedPrune });
                     }
                 }
             }

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/mcp-client/manager.js

@@ -355,14 +355,14 @@ function normalizeRawServerConfig(name, config, source) {
         cwd: typeof config.cwd === "string" ? config.cwd : undefined,
         headers,
         oauth: config.oauth && typeof config.oauth === "object" ? config.oauth : undefined,
-        envWarnings: collectEnvWarnings([
+        envWarnings: collectMcpEnvWarnings([
             ["url", url],
             ...Object.entries(env ?? {}).map(([key, value]) => [`env.${key}`, value]),
             ...Object.entries(headers ?? {}).map(([key, value]) => [`headers.${key}`, value]),
         ]),
     };
 }
-function detectTransport(config) {
+export function detectTransport(config) {
     const type = typeof config.type === "string" ? config.type.toLowerCase() : undefined;
     if (type && type !== "stdio" && type !== "http")
         return "unsupported";
@@ -397,7 +397,7 @@ function serializeServerInput(input) {
         _gsdImportedFrom: input.importedFrom,
     });
 }
-function collectEnvWarnings(values) {
+export function collectMcpEnvWarnings(values) {
     const warnings = [];
     for (const [label, value] of values) {
         if (!value)

package/dist/resources/extensions/search-the-web/index.js

@@ -3,30 +3,62 @@
  *
  * Native Anthropic hooks stay eager. Heavy tool registration is deferred in
  * interactive mode so startup is not blocked on the full search tool stack.
+ *
+ * Provider gating: the Brave/Tavily/Ollama-backed tools (search-the-web,
+ * search_and_read) are only registered when a provider API key is actually
+ * configured (resolveSearchProvider() !== null). Without a key these tools can
+ * only return an auth error, so presenting them to the model is pure confusion
+ * — the agent reaches for a tool that cannot work. fetch_page is always
+ * registered because it works key-free via Jina Reader.
  */
 import { importExtensionModule } from "@gsd/pi-coding-agent";
 import { registerSearchProviderCommand } from "./command-search-provider.js";
 import { registerNativeSearchHooks } from "./native-search.js";
-let toolsPromise = null;
+import { resolveSearchProvider } from "./provider.js";
+// fetch_page registration — always available (key-free via Jina Reader).
+let fetchToolPromise = null;
+// search-the-web + search_and_read registration — gated on provider key.
+let searchToolsPromise = null;
 let resetSearchLoopGuardStateRef = null;
-async function registerSearchTools(pi) {
-    if (!toolsPromise) {
-        toolsPromise = (async () => {
-            const [{ registerSearchTool, resetSearchLoopGuardState }, { registerFetchPageTool }, { registerLLMContextTool },] = await Promise.all([
+async function registerFetchTool(pi) {
+    if (!fetchToolPromise) {
+        fetchToolPromise = (async () => {
+            const { registerFetchPageTool } = await importExtensionModule(import.meta.url, "./tool-fetch-page.js");
+            registerFetchPageTool(pi);
+        })().catch((error) => {
+            fetchToolPromise = null;
+            throw error;
+        });
+    }
+    return fetchToolPromise;
+}
+/**
+ * Register the provider-backed search tools, but only when a search provider
+ * key is configured. Memoized so it registers at most once per process; the
+ * guard is re-evaluated on each session_start so a key added before a later
+ * session is picked up without a restart.
+ */
+async function registerProviderSearchTools(pi) {
+    if (resolveSearchProvider() === null)
+        return;
+    if (!searchToolsPromise) {
+        searchToolsPromise = (async () => {
+            const [{ registerSearchTool, resetSearchLoopGuardState }, { registerLLMContextTool },] = await Promise.all([
                 importExtensionModule(import.meta.url, "./tool-search.js"),
-                importExtensionModule(import.meta.url, "./tool-fetch-page.js"),
                 importExtensionModule(import.meta.url, "./tool-llm-context.js"),
             ]);
             resetSearchLoopGuardStateRef = resetSearchLoopGuardState;
             registerSearchTool(pi);
-            registerFetchPageTool(pi);
             registerLLMContextTool(pi);
         })().catch((error) => {
-            toolsPromise = null;
+            searchToolsPromise = null;
             throw error;
         });
     }
-    return toolsPromise;
+    return searchToolsPromise;
+}
+async function registerSearchTools(pi) {
+    await Promise.all([registerFetchTool(pi), registerProviderSearchTools(pi)]);
 }
 export default function (pi) {
     registerSearchProviderCommand(pi);

package/dist/resources/extensions/search-the-web/native-search.js

@@ -6,6 +6,7 @@
  */
 import { isAnthropicApi } from "@gsd/pi-ai";
 import { resolveSearchProviderFromPreferences } from "../gsd/preferences.js";
+import { resolveSearchProvider } from "./provider.js";
 /** Tool names for the Brave-backed custom search tools */
 export const BRAVE_TOOL_NAMES = ["search-the-web", "search_and_read"];
 /** All custom search tool names that should be disabled when native search is active */
@@ -166,11 +167,24 @@ export function registerNativeSearchHooks(pi) {
             pi.setActiveTools(active.filter((t) => !CUSTOM_SEARCH_TOOL_NAMES.includes(t)));
         }
         else if (!isAnthropicProvider && wasAnthropic) {
-            // Switching away from Anthropic — re-enable custom search tools (they
-            // were disabled while native search was active). If keys are missing,
-            // user sees the error rather than tools silently vanishing.
+            // Switching away from Anthropic — re-enable custom search tools that were
+            // disabled while native search was active. Only re-add the Brave/Tavily/
+            // Ollama-backed tools when a provider key is actually configured: without
+            // a key they can only return an auth error, and re-adding their names
+            // would advertise a tool the model cannot use (and, when unregistered,
+            // leak a schema-less phantom name into the tool surface). google_search
+            // is owned by its own extension (which now gates its registration on
+            // Gemini creds); re-adding its name here is harmless either way — it
+            // activates if registered, or is dropped as a no-op if not.
             const active = pi.getActiveTools();
-            const toAdd = CUSTOM_SEARCH_TOOL_NAMES.filter((t) => !active.includes(t));
+            const providerConfigured = resolveSearchProvider() !== null;
+            const toAdd = CUSTOM_SEARCH_TOOL_NAMES.filter((t) => {
+                if (active.includes(t))
+                    return false;
+                if (BRAVE_TOOL_NAMES.includes(t))
+                    return providerConfigured;
+                return true;
+            });
             if (toAdd.length > 0) {
                 pi.setActiveTools([...active, ...toAdd]);
             }