gsd-pi 2.78.0-dev.aeeb2ca00 → 2.78.1-dev.84a383f51

package/src/resources/extensions/gsd/tests/token-profile.test.ts

@@ -107,6 +107,50 @@ test("profile: resolveProfileDefaults exists and handles all 4 tiers", () => {
   );
 });
 
+test("profile: PROFILE_TIER_MAP defines tier intentions for all profiles", async () => {
+  const { getProfileTierMap } = await import("../preferences-models.ts");
+  const profileMaps = {
+    budget: getProfileTierMap("budget"),
+    balanced: getProfileTierMap("balanced"),
+    quality: getProfileTierMap("quality"),
+  };
+
+  assert.deepEqual(
+    Object.keys(profileMaps).sort(),
+    ["balanced", "budget", "quality"],
+    "PROFILE_TIER_MAP should include the profile default tiers",
+  );
+
+  const expectedPhaseKeys = ["completion", "execution", "execution_simple", "planning", "research", "subagent"];
+  const validTiers = new Set(["light", "standard", "heavy"]);
+  for (const [profile, tierMap] of Object.entries(profileMaps)) {
+    assert.deepEqual(
+      Object.keys(tierMap).sort(),
+      expectedPhaseKeys,
+      `${profile} should define all model-bearing phases`,
+    );
+    for (const [phase, tier] of Object.entries(tierMap)) {
+      assert.ok(validTiers.has(tier), `${profile}.${phase} should be a tier name`);
+      assert.ok(!tier.includes("claude-"), `${profile}.${phase} should not be a model ID`);
+    }
+  }
+});
+
+test("profile: resolveProfileDefaults is provider-agnostic — picks OpenAI when only OpenAI is available", async () => {
+  // Behavioral check: with only OpenAI models in the available list, no slot
+  // should resolve to a claude-* model. Source-grep cannot prove this — only
+  // exercising the function with a controlled available-model list can.
+  const { resolveProfileDefaults } = await import("../preferences-models.ts");
+  const defaults = resolveProfileDefaults("balanced", ["gpt-4o", "gpt-4o-mini"]);
+  assert.ok(defaults.models, "balanced profile should populate models");
+  for (const [phase, modelId] of Object.entries(defaults.models!)) {
+    assert.ok(
+      typeof modelId === "string" && !String(modelId).startsWith("claude-"),
+      `${phase} resolved to ${modelId} but only OpenAI is available`,
+    );
+  }
+});
+
 test("profile: budget profile sets phase skips to true", () => {
   // Extract the budget case block
   const budgetIdx = preferencesSrc.indexOf('case "budget":');
@@ -222,11 +266,14 @@ test("merge: mergePreferences handles phases with spread", () => {
 // Subagent Model Routing
 // ═══════════════════════════════════════════════════════════════════════════
 
-test("subagent: budget profile sets subagent model", () => {
-  const budgetIdx = preferencesSrc.indexOf('case "budget":');
-  const balancedIdx = preferencesSrc.indexOf('case "balanced":');
+test("subagent: budget profile assigns light tier for subagent", () => {
+  // PROFILE_TIER_MAP.budget.subagent should be "light"
+  const tierMapIdx = preferencesSrc.indexOf("PROFILE_TIER_MAP");
+  const budgetIdx = preferencesSrc.indexOf("budget:", tierMapIdx);
+  const balancedIdx = preferencesSrc.indexOf("balanced:", tierMapIdx);
   const budgetBlock = preferencesSrc.slice(budgetIdx, balancedIdx);
-  assert.ok(budgetBlock.includes("subagent:"), "budget profile should set subagent model");
+  assert.ok(budgetBlock.includes("subagent:"), "budget profile should define subagent tier");
+  assert.ok(budgetBlock.includes('"light"'), "budget subagent should use light tier");
 });
 
 test("subagent: resolveModelWithFallbacksForUnit handles subagent unit types", () => {

package/src/resources/extensions/gsd/tests/turn-epoch.test.ts

@@ -144,19 +144,10 @@ test("recoverTimedOutUnit: no top-level bumpTurnGeneration — steering branches
   );
 });
 
-test("recoverTimedOutUnit: bumpAndResolveSynthetic appears exactly four times (one per advance branch)", async () => {
-  const fs = await import("node:fs");
-  const path = await import("node:path");
-  const url = await import("node:url");
-  const here = path.dirname(url.fileURLToPath(import.meta.url));
-  const src = fs.readFileSync(
-    path.join(here, "..", "auto-timeout-recovery.ts"),
-    "utf-8",
-  );
-  const matches = src.match(/bumpAndResolveSynthetic\s*\(/g) ?? [];
-  assert.equal(
-    matches.length,
-    4,
-    `expected 4 advance-branch supersede sites (durableComplete, execute-task-exhausted, artifact-already-exists, non-execute-exhausted); found ${matches.length}`,
-  );
-});
+// Removed: source-grep count of `bumpAndResolveSynthetic\s*\(` occurrences.
+// A literal 4 hardcodes the current branch shape, not behaviour. The
+// behavioural invariant — "advance branches supersede atomically; non-advance
+// branches do not bump" — is enforced by the previous test (no direct
+// bumpTurnGeneration calls) plus the per-branch behavioural tests above
+// (`recoverTimedOutUnit: …`). Refactors that split a branch into two would
+// trip a count test without affecting correctness. Refs #4851.

package/src/resources/extensions/gsd/tests/unstructured-continue-context-injection.test.ts

@@ -76,13 +76,11 @@ describe("#3615 — structural: fallback exists with correct guards", () => {
     );
   });
 
-  test("only one return null at the end", () => {
-    const returnNulls = fnBody.match(/return null;/g);
-    assert.ok(
-      returnNulls && returnNulls.length === 1,
-      `expected exactly 1 'return null' (at end after fallback), got ${returnNulls?.length ?? 0}`,
-    );
-  });
+  // Removed: source-grep count of `return null;` occurrences. The behaviour
+  // we care about ("function returns null only when no auto-dispatch /
+  // guided-resume / fallback path matches") is exercised by the behavioural
+  // tests below — counting literal `return null;` tokens encodes statement
+  // shape, not contract. Refs #4851.
 });
 
 // ── Behavioral tests: RESUME_INTENT_PATTERNS ────────────────────────

package/src/resources/extensions/gsd/tests/uok-gitops-turn-action.test.ts

@@ -4,7 +4,7 @@ import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import { execSync } from "node:child_process";
-import { runTurnGitAction } from "../git-service.ts";
+import { handleTurnGitActionError, runTurnGitAction } from "../git-service.ts";
 
 function run(cmd: string, cwd: string): string {
   return execSync(cmd, { cwd, stdio: "pipe", encoding: "utf-8" }).trim();
@@ -83,3 +83,17 @@ test("uok gitops turn action commit creates commit with unit trailer", () => {
     rmSync(repo, { recursive: true, force: true });
   }
 });
+
+test("uok gitops turn action rethrows infrastructure failures", () => {
+  const err = Object.assign(new Error("ENFILE: file table overflow"), { code: "ENFILE" });
+
+  assert.throws(() => handleTurnGitActionError("commit", err), (thrown) => thrown === err);
+});
+
+test("uok gitops turn action keeps non-infrastructure git failures recoverable", () => {
+  const result = handleTurnGitActionError("commit", new Error("nothing to commit"));
+
+  assert.equal(result.action, "commit");
+  assert.equal(result.status, "failed");
+  assert.equal(result.error, "nothing to commit");
+});

package/src/resources/extensions/gsd/tests/visualizer-overlay.test.ts

@@ -13,7 +13,7 @@
 import { test } from "node:test";
 import assert from "node:assert/strict";
 
-import { GSDVisualizerOverlay } from "../visualizer-overlay.ts";
+import { GSDVisualizerOverlay, TAB_COUNT } from "../visualizer-overlay.ts";
 
 function makeTui() {
   const renders: number[] = [];
@@ -93,16 +93,16 @@ test("overlay switches tabs via 1–9,0 digit keys", (t) => {
 
 test("overlay Tab key cycles forward and wraps around at TAB_COUNT", (t) => {
   const { overlay } = makeOverlay(t);
-  overlay.activeTab = 9;
+  overlay.activeTab = TAB_COUNT - 1;
   overlay.handleInput("\t");
-  assert.equal(overlay.activeTab, 0, "Tab wraps from 9 back to 0");
+  assert.equal(overlay.activeTab, 0, `Tab wraps from ${TAB_COUNT - 1} back to 0`);
 });
 
 test("overlay Shift+Tab cycles backward and wraps", (t) => {
   const { overlay } = makeOverlay(t);
   overlay.activeTab = 0;
   overlay.handleInput("\u001b[Z");
-  assert.equal(overlay.activeTab, 9, "Shift+Tab wraps from 0 to 9");
+  assert.equal(overlay.activeTab, TAB_COUNT - 1, `Shift+Tab wraps from 0 to ${TAB_COUNT - 1}`);
 });
 
 // ─── Filter mode ─────────────────────────────────────────────────────────
@@ -331,9 +331,9 @@ test("overlay footer hint mentions tab navigation, filter, scroll, and help", (t
 
 // ─── Scroll offsets array is sized to TAB_COUNT ──────────────────────────
 
-test("overlay scrollOffsets array has one slot per tab (10 tabs total)", (t) => {
+test("overlay scrollOffsets array has one slot per tab", (t) => {
   const { overlay } = makeOverlay(t);
-  assert.equal(overlay.scrollOffsets.length, 10, "scrollOffsets sized to TAB_COUNT=10");
+  assert.equal(overlay.scrollOffsets.length, TAB_COUNT, "scrollOffsets sized to TAB_COUNT");
   assert.ok(overlay.scrollOffsets.every((n: number) => n === 0), "initialized to zero");
 });
 

package/src/resources/extensions/gsd/tests/write-gate-planning-unit.test.ts

@@ -10,6 +10,7 @@ import assert from 'node:assert/strict';
 import { join, sep } from 'node:path';
 
 import { shouldBlockPlanningUnit } from '../bootstrap/write-gate.ts';
+import { isDeterministicPolicyError } from '../auto-tool-tracking.ts';
 import type { ToolsPolicy } from '../unit-context-manifest.ts';
 
 const BASE = join('/tmp', 'fake-project');
@@ -36,6 +37,20 @@ test('planning-unit: blocks edit to user source (the b23 forensic)', () => {
   assert.match(r.reason!, /discuss-milestone/);
 });
 
+test('planning-unit: deterministic block reason is suitable for retry short-circuiting', () => {
+  const r = shouldBlockPlanningUnit(
+    'edit',
+    'src/main.ts',
+    BASE,
+    'discuss-milestone',
+    PLANNING,
+  );
+  assert.strictEqual(r.block, true);
+  assert.match(r.reason!, /HARD BLOCK/);
+  assert.match(r.reason!, /tools-policy/);
+  assert.strictEqual(isDeterministicPolicyError(r.reason!), true);
+});
+
 test('planning-unit: blocks write to user source via relative path', () => {
   const r = shouldBlockPlanningUnit('write', 'src/main.ts', BASE, 'plan-milestone', PLANNING);
   assert.strictEqual(r.block, true);

package/src/resources/extensions/gsd/tools/memory-tools.ts

@@ -96,8 +96,24 @@ export function executeMemoryCapture(params: MemoryCaptureParams): ToolExecution
   const tags = normalizeTags(params.tags);
 
   const structuredFields = normalizeStructuredFields(params.structuredFields);
-  const id = createMemory({ category, content, confidence, scope, tags, structuredFields });
+  let id: string | null;
+  try {
+    id = createMemory({ category, content, confidence, scope, tags, structuredFields });
+  } catch (err) {
+    // Surface the underlying SQL message (e.g. "database disk image is
+    // malformed", "no such table: memories") so the operator gets the
+    // actionable signal instead of an opaque "create_failed". See #4967.
+    const message = err instanceof Error ? err.message : String(err);
+    return {
+      content: [{ type: "text", text: `Error: failed to create memory: ${message}` }],
+      details: { operation: "memory_capture", error: message },
+      isError: true,
+    };
+  }
   if (!id) {
+    // DB unavailable or adapter missing — distinct from the SQL-error path
+    // above. Keep the legacy create_failed token here so any consumers that
+    // explicitly key on the unavailable case continue to work.
     return {
       content: [{ type: "text", text: "Error: failed to create memory." }],
       details: { operation: "memory_capture", error: "create_failed" },

package/src/resources/extensions/gsd/unit-context-manifest.ts

@@ -93,10 +93,10 @@ export type PreferencesPolicy = "none" | "active-only" | "full";
 /**
  * Tool-access policy per unit type (#4934).
  *
- * Declarative-only in this PR — runtime enforcement (write-gate.ts predicate
- * + dispatch-time isolation) lands in follow-up PRs. The shape is the
- * agreement between manifest authors and enforcement; surfacing it now lets
- * reviewers ratify per-unit policy intent before any blocking logic ships.
+ * Runtime-enforced by the GSD write gate for active auto-mode units. The
+ * manifest declares the allowed tool surface; register-hooks.ts resolves the
+ * active unit's manifest before each tool call and write-gate.ts rejects
+ * violations before the tool executes.
  *
  * Modes:
  *   - "all"        — Read + Edit/Write/MultiEdit/NotebookEdit + Bash + Task.
@@ -214,10 +214,10 @@ export interface UnitContextManifest {
   /** Preferences block policy. */
   readonly preferences: PreferencesPolicy;
   /**
-   * Tool-access policy (#4934). Declarative in this PR; runtime enforcement
-   * (path-scoped write blocking + subagent denial + bash allowlist) lands
-   * in follow-ups. Required on every manifest so missing entries fail loud
-   * via the CI invariant test rather than defaulting to "all" silently.
+   * Tool-access policy (#4934). Runtime enforcement covers path-scoped write
+   * blocking, subagent denial, and bash allowlisting for active auto-mode
+   * units. Required on every manifest so missing entries fail loud via the CI
+   * invariant test rather than defaulting to "all" silently.
    */
   readonly tools: ToolsPolicy;
   /** Artifact handling: inline (full body), excerpt (compact), or on-demand (path only). */

package/src/resources/extensions/gsd/visualizer-overlay.ts

@@ -20,7 +20,7 @@ import { writeExportFile } from "./export.js";
 import { gsdRoot } from "./paths.js";
 import { stripAnsi } from "../shared/mod.js";
 
-const TAB_COUNT = 10;
+export const TAB_COUNT = 10;
 const TAB_LABELS = [
   "1 Progress",
   "2 Timeline",

package/src/resources/extensions/gsd/watch/header-renderer.ts

@@ -98,13 +98,15 @@ export function readGitBranch(projectRoot: string): string {
 }
 
 /**
- * Read MCP server names from .mcp.json or .gsd/mcp.json.
+ * Read MCP server names from .mcp.json, .gsd/mcp.json, and the global
+ * ~/.gsd/mcp.json (or $GSD_HOME/mcp.json).
  * Returns array of server name strings.
  */
 export function readMcpServerNames(projectRoot: string): string[] {
   const configPaths = [
     join(projectRoot, ".mcp.json"),
     join(projectRoot, ".gsd", "mcp.json"),
+    join(process.env.GSD_HOME || join(homedir(), ".gsd"), "mcp.json"),
   ];
   const names: string[] = [];
   const seen = new Set<string>();

package/src/resources/extensions/gsd/workflow-logger.ts

@@ -66,6 +66,7 @@ export type LogComponent =
   | "memory-embeddings" // Memory layer embedding generation
   | "memory-ingest"     // Memory layer ingestion pipeline
   | "memory-backfill"   // ADR-013: decisions->memories backfill
+  | "memory-store"      // Memory CRUD layer — surfaces SQLite/store-level faults (#4967)
   | "context-mode"     // Context-mode exec sandbox and compaction snapshot
   | "preflight"        // Clean-root preflight gate at milestone completion
   | "postUnit";     // Post-unit processing (abandon detection, overrides)

package/src/resources/extensions/gsd/worktree-command.ts

@@ -33,29 +33,21 @@ import { inferCommitType } from "./git-service.js";
 import type { FileLineStat } from "./worktree-manager.js";
 import { existsSync, realpathSync, readdirSync, rmSync, unlinkSync } from "node:fs";
 import { nativeMergeAbort } from "./native-git-bridge.js";
-import { join, sep } from "node:path";
+import { join } from "node:path";
+import {
+  clearWorktreeOriginalCwd,
+  ensureWorktreeOriginalCwdFromPath,
+  getActiveWorktreeName,
+  getWorktreeOriginalCwd,
+  setWorktreeOriginalCwd,
+} from "./worktree-session-state.js";
+
+export { getActiveWorktreeName, getWorktreeOriginalCwd } from "./worktree-session-state.js";
 
 /**
  * Tracks the original project root so we can switch back.
  * Set when we first chdir into a worktree, cleared on return.
  */
-let originalCwd: string | null = null;
-
-/** Get the original project root if currently in a worktree, or null. */
-export function getWorktreeOriginalCwd(): string | null {
-  return originalCwd;
-}
-
-/** Get the name of the active worktree, or null if not in one. */
-export function getActiveWorktreeName(): string | null {
-  if (!originalCwd) return null;
-  const cwd = process.cwd();
-  const wtDir = join(originalCwd, ".gsd", "worktrees");
-  if (!cwd.startsWith(wtDir)) return null;
-  const rel = cwd.slice(wtDir.length + 1);
-  const name = rel.split("/")[0] ?? rel.split("\\")[0];
-  return name || null;
-}
 
 // ─── Shared completions and handler (used by both /worktree and /wt) ────────
 
@@ -145,7 +137,7 @@ async function worktreeHandler(
       return;
     }
     // create and switch both do the same thing: switch if exists, create if not
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
     const existing = listWorktrees(mainBase);
     if (existing.some(wt => wt.name === name)) {
       await handleSwitch(basePath, name, ctx);
@@ -157,7 +149,7 @@ async function worktreeHandler(
 
   if (trimmed === "merge" || trimmed.startsWith("merge ")) {
     const mergeArgs = trimmed.replace(/^merge\s*/, "").trim().split(/\s+/).filter(Boolean);
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
     const activeWt = getActiveWorktreeName();
 
     if (mergeArgs.length === 0) {
@@ -191,7 +183,7 @@ async function worktreeHandler(
 
   if (trimmed === "remove" || trimmed.startsWith("remove ")) {
     const name = trimmed.replace(/^remove\s*/, "").trim();
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
 
     if (name === "all") {
       await handleRemoveAll(mainBase, ctx);
@@ -213,7 +205,7 @@ async function worktreeHandler(
     return;
   }
 
-  const mainBase = originalCwd ?? basePath;
+  const mainBase = getWorktreeOriginalCwd() ?? basePath;
   const nameOnly = trimmed.split(/\s+/)[0]!;
   if (trimmed !== nameOnly) {
     ctx.ui.notify(`Unknown command. Did you mean /${alias} switch ${nameOnly}?`, "warning");
@@ -241,14 +233,7 @@ export function registerWorktreeCommand(pi: ExtensionAPI): void {
   // Restore worktree state after /reload.
   // The module-level originalCwd resets to null when extensions are re-loaded,
   // but process.cwd() is still inside the worktree. Detect this and recover.
-  if (!originalCwd) {
-    const cwd = process.cwd();
-    const marker = `${sep}.gsd${sep}worktrees${sep}`;
-    const markerIdx = cwd.indexOf(marker);
-    if (markerIdx !== -1) {
-      originalCwd = cwd.slice(0, markerIdx);
-    }
-  }
+  ensureWorktreeOriginalCwdFromPath();
 
   pi.registerCommand("worktree", {
     description: "Git worktrees (also /wt): /worktree <name> | list | merge | remove",
@@ -320,7 +305,7 @@ async function handleCreate(
     const commitMsg = autoCommitCurrentBranch(basePath, "worktree-switch", name);
 
     // Create from the main tree, not from inside another worktree
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
     const info = createWorktree(mainBase, name);
 
     // Run user-configured post-create hook (#597) — e.g. copy .env, symlink assets
@@ -330,7 +315,7 @@ async function handleCreate(
     }
 
     // Track original cwd before switching
-    if (!originalCwd) originalCwd = basePath;
+    if (!getWorktreeOriginalCwd()) setWorktreeOriginalCwd(basePath);
 
     const prevCwd = process.cwd();
     process.chdir(info.path);
@@ -390,7 +375,7 @@ async function handleSwitch(
   ctx: ExtensionCommandContext,
 ): Promise<void> {
   try {
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
     const wtPath = worktreePath(mainBase, name);
 
     if (!existsSync(wtPath)) {
@@ -405,7 +390,7 @@ async function handleSwitch(
     const commitMsg = autoCommitCurrentBranch(basePath, "worktree-switch", name);
 
     // Track original cwd before switching
-    if (!originalCwd) originalCwd = basePath;
+    if (!getWorktreeOriginalCwd()) setWorktreeOriginalCwd(basePath);
 
     const prevCwd = process.cwd();
     process.chdir(wtPath);
@@ -433,6 +418,7 @@ async function handleSwitch(
 }
 
 async function handleReturn(ctx: ExtensionCommandContext): Promise<void> {
+  const originalCwd = getWorktreeOriginalCwd();
   if (!originalCwd) {
     ctx.ui.notify("Already in the main project tree.", "info");
     return;
@@ -442,7 +428,7 @@ async function handleReturn(ctx: ExtensionCommandContext): Promise<void> {
   const commitMsg = autoCommitCurrentBranch(process.cwd(), "worktree-return", "worktree");
 
   const returnTo = originalCwd;
-  originalCwd = null;
+  clearWorktreeOriginalCwd();
 
   const prevCwd = process.cwd();
   process.chdir(returnTo);
@@ -504,7 +490,7 @@ async function handleList(
   ctx: ExtensionCommandContext,
 ): Promise<void> {
   try {
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
     const worktrees = listWorktrees(mainBase);
 
     if (worktrees.length === 0) {
@@ -552,6 +538,7 @@ async function handleList(
       lines.push("");
     }
 
+    const originalCwd = getWorktreeOriginalCwd();
     if (originalCwd) {
       lines.push(`  ${CLR.label("main tree")}  ${CLR.path(originalCwd)}`);
     }
@@ -651,11 +638,11 @@ async function handleMerge(
 
     // Switch to the main tree before merging.
     // Must be on the main branch to run git merge --squash.
-    if (originalCwd) {
+    if (getWorktreeOriginalCwd()) {
       const prevCwd = process.cwd();
       process.chdir(basePath);
       nudgeGitBranchCache(prevCwd);
-      originalCwd = null;
+      clearWorktreeOriginalCwd();
     }
 
     // --- Deterministic merge path (preferred) ---
@@ -754,7 +741,7 @@ async function handleRemove(
   ctx: ExtensionCommandContext,
 ): Promise<void> {
   try {
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
 
     // Validate the worktree exists before attempting removal
     const worktrees = listWorktrees(mainBase);
@@ -779,9 +766,9 @@ async function handleRemove(
     removeWorktree(mainBase, name, { deleteBranch: true });
 
     // If we were in that worktree, removeWorktree chdir'd us out — clear tracking
-    if (originalCwd && process.cwd() !== prevCwd) {
+    if (getWorktreeOriginalCwd() && process.cwd() !== prevCwd) {
       nudgeGitBranchCache(prevCwd);
-      originalCwd = null;
+      clearWorktreeOriginalCwd();
     }
 
     ctx.ui.notify(`${CLR.ok("✓")} Worktree ${CLR.name(name)} removed ${CLR.muted("(branch deleted)")}.`, "info");
@@ -796,7 +783,7 @@ async function handleRemoveAll(
   ctx: ExtensionCommandContext,
 ): Promise<void> {
   try {
-    const mainBase = originalCwd ?? basePath;
+    const mainBase = getWorktreeOriginalCwd() ?? basePath;
     const worktrees = listWorktrees(mainBase);
 
     if (worktrees.length === 0) {
@@ -830,9 +817,9 @@ async function handleRemoveAll(
     }
 
     // If we were in a worktree that got removed, clear tracking
-    if (originalCwd && process.cwd() !== prevCwd) {
+    if (getWorktreeOriginalCwd() && process.cwd() !== prevCwd) {
       nudgeGitBranchCache(prevCwd);
-      originalCwd = null;
+      clearWorktreeOriginalCwd();
     }
 
     const lines: string[] = [];

package/src/resources/extensions/gsd/worktree-session-state.ts

@@ -0,0 +1,35 @@
+// GSD worktree session state
+let originalCwd: string | null = null;
+
+export function getWorktreeOriginalCwd(): string | null {
+  return originalCwd;
+}
+
+export function setWorktreeOriginalCwd(cwd: string): void {
+  originalCwd = cwd;
+}
+
+export function clearWorktreeOriginalCwd(): void {
+  originalCwd = null;
+}
+
+export function ensureWorktreeOriginalCwdFromPath(cwd: string = process.cwd()): string | null {
+  if (originalCwd) return originalCwd;
+  const marker = `${/\\/.test(cwd) ? "\\" : "/"}.gsd${/\\/.test(cwd) ? "\\" : "/"}worktrees${/\\/.test(cwd) ? "\\" : "/"}`;
+  const markerIdx = cwd.indexOf(marker);
+  if (markerIdx !== -1) {
+    originalCwd = cwd.slice(0, markerIdx);
+  }
+  return originalCwd;
+}
+
+export function getActiveWorktreeName(): string | null {
+  if (!originalCwd) return null;
+  const cwd = process.cwd();
+  const wtDir = `${originalCwd.replace(/[\\/]+$/, "")}/.gsd/worktrees`.replaceAll("\\", "/");
+  const normalizedCwd = cwd.replaceAll("\\", "/");
+  if (!normalizedCwd.startsWith(`${wtDir}/`)) return null;
+  const rel = normalizedCwd.slice(wtDir.length + 1);
+  const name = rel.split("/")[0];
+  return name || null;
+}

package/src/resources/extensions/mcp-client/index.ts

@@ -2,7 +2,8 @@
  * MCP Client Extension — Native MCP server integration for pi
  *
  * Provides on-demand access to MCP servers configured in project files
- * (.mcp.json, .gsd/mcp.json) using the @modelcontextprotocol/sdk Client
+ * (.mcp.json, .gsd/mcp.json) and the global ~/.gsd/mcp.json (or
+ * $GSD_HOME/mcp.json) using the @modelcontextprotocol/sdk Client
  * directly — no external CLI dependency required.
  *
  * Three tools:
@@ -24,6 +25,7 @@ import { Client } from "@modelcontextprotocol/sdk/client";
 import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
 import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
 import { readFileSync, existsSync } from "node:fs";
+import { homedir } from "node:os";
 import { join } from "node:path";
 import { buildHttpTransportOpts } from "./auth.js";
 import type { McpHttpAuthConfig } from "./auth.js";
@@ -102,6 +104,7 @@ function readConfigs(): McpServerConfig[] {
 	const configPaths = [
 		join(process.cwd(), ".mcp.json"),
 		join(process.cwd(), ".gsd", "mcp.json"),
+		join(process.env.GSD_HOME || join(homedir(), ".gsd"), "mcp.json"),
 	];
 
 	for (const configPath of configPaths) {
@@ -321,7 +324,7 @@ async function closeAll(): Promise<void> {
 // ─── Formatters ───────────────────────────────────────────────────────────────
 
 function formatServerList(servers: McpServerConfig[]): string {
-	if (servers.length === 0) return "No MCP servers configured. Add servers to .mcp.json or .gsd/mcp.json.";
+	if (servers.length === 0) return "No MCP servers configured. Add servers to .mcp.json, .gsd/mcp.json, or $GSD_HOME/mcp.json (default: ~/.gsd/mcp.json).";
 
 	const lines: string[] = [`${servers.length} MCP servers configured:\n`];
 
@@ -384,7 +387,7 @@ export default function (pi: ExtensionAPI) {
 		name: "mcp_servers",
 		label: "MCP Servers",
 		description:
-			"List all available MCP servers configured in project files (.mcp.json, .gsd/mcp.json). " +
+			"List all available MCP servers configured in project files (.mcp.json, .gsd/mcp.json) or globally ($GSD_HOME/mcp.json, default: ~/.gsd/mcp.json). " +
 			"Shows server names, transport type, and connection status. Use mcp_discover to get full tool schemas for a server.",
 		promptSnippet:
 			"List available MCP servers from project configuration",