gsd-pi 2.78.1-dev.84a383f51 → 2.78.1

package/dist/resources/extensions/gsd/tests/auto-supervisor.test.mjs

@@ -0,0 +1,53 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { mkdtempSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { writeUnitRuntimeRecord, readUnitRuntimeRecord } from '../unit-runtime.ts';
+import { resolveAutoSupervisorConfig } from '../preferences.ts';
+
+test('resolveAutoSupervisorConfig provides safe timeout defaults', () => {
+  const supervisor = resolveAutoSupervisorConfig();
+  assert.equal(supervisor.soft_timeout_minutes, 20);
+  assert.equal(supervisor.idle_timeout_minutes, 10);
+  assert.equal(supervisor.hard_timeout_minutes, 30);
+});
+
+test('writeUnitRuntimeRecord persists progress and recovery metadata defaults', () => {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-auto-supervisor-'));
+  const startedAt = 1234567890;
+
+  writeUnitRuntimeRecord(base, 'plan-milestone', 'M010', startedAt, {
+    phase: 'dispatched',
+    lastProgressAt: startedAt,
+    progressCount: 1,
+    lastProgressKind: 'dispatch',
+  });
+
+  const runtime = readUnitRuntimeRecord(base, 'plan-milestone', 'M010');
+  assert.ok(runtime);
+  assert.equal(runtime.phase, 'dispatched');
+  assert.equal(runtime.lastProgressAt, startedAt);
+  assert.equal(runtime.progressCount, 1);
+  assert.equal(runtime.lastProgressKind, 'dispatch');
+  assert.equal(runtime.recoveryAttempts, 0);
+});
+
+test('writeUnitRuntimeRecord keeps explicit recovery attempt fields', () => {
+  const base = mkdtempSync(join(tmpdir(), 'gsd-auto-supervisor-'));
+  const startedAt = 2234567890;
+
+  writeUnitRuntimeRecord(base, 'research-milestone', 'M011', startedAt, {
+    phase: 'timeout',
+    recoveryAttempts: 2,
+    lastRecoveryReason: 'idle',
+    lastProgressAt: startedAt + 50,
+    progressCount: 3,
+    lastProgressKind: 'recovery-retry',
+  });
+
+  const runtime = JSON.parse(readFileSync(join(base, '.gsd/runtime/units/research-milestone-M011.json'), 'utf8'));
+  assert.equal(runtime.recoveryAttempts, 2);
+  assert.equal(runtime.lastRecoveryReason, 'idle');
+  assert.equal(runtime.lastProgressKind, 'recovery-retry');
+});

package/dist/resources/extensions/gsd/tests/dist-redirect.mjs

@@ -0,0 +1,112 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { fileURLToPath } from 'node:url';
+
+const require = createRequire(import.meta.url);
+
+const ROOT = new URL("../../../../../", import.meta.url);
+
+export function resolve(specifier, context, nextResolve) {
+  // 1. Redirect all workspace package bare imports to source.
+  //    CI portability runs don't build any packages/ dist artifacts, so every
+  //    @gsd/* specifier (including transitive ones pulled in by pi-coding-agent
+  //    source itself) must resolve to the TypeScript source entrypoint.
+  if (specifier === "../../packages/pi-coding-agent/src/index.js") {
+    specifier = new URL("packages/pi-coding-agent/src/index.ts", ROOT).href;
+  } else if (specifier === "@gsd/pi-coding-agent") {
+    specifier = new URL("packages/pi-coding-agent/src/index.ts", ROOT).href;
+  } else if (specifier === "@gsd/pi-ai/oauth") {
+    specifier = new URL("packages/pi-ai/src/utils/oauth/index.ts", ROOT).href;
+  } else if (specifier === "@gsd/pi-ai") {
+    specifier = new URL("packages/pi-ai/src/index.ts", ROOT).href;
+  } else if (specifier === "@gsd/pi-agent-core") {
+    specifier = new URL("packages/pi-agent-core/src/index.ts", ROOT).href;
+  } else if (specifier === "@gsd/pi-tui") {
+    specifier = new URL("packages/pi-tui/src/index.ts", ROOT).href;
+  } else if (specifier === "@gsd/native") {
+    specifier = new URL("packages/native/src/index.ts", ROOT).href;
+  } else if (specifier.startsWith("@gsd/native/")) {
+    // Sub-path imports like @gsd/native/fd, @gsd/native/text, etc.
+    const subpath = specifier.slice("@gsd/native/".length);
+    specifier = new URL(`packages/native/src/${subpath}/index.ts`, ROOT).href;
+  }
+  // 2. Redirect packages/*/dist/ → packages/*/src/ with .js→.ts for strip-types
+  //    Also handles local imports — skip rewrite for dist/ paths that are real compiled artifacts.
+
+  else if (specifier.endsWith('.js') && (specifier.startsWith('./') || specifier.startsWith('../'))) {
+    if (context.parentURL && context.parentURL.includes('/src/')) {
+      if (specifier.includes('/dist/')) {
+        specifier = specifier.replace('/dist/', '/src/').replace(/\.js$/, '.ts');
+      } else {
+        specifier = specifier.replace(/\.js$/, '.ts');
+      }
+    }
+  }
+  // 3. Extensionless relative imports from web/ (Next.js convention).
+  //    Transpiled .tsx files emit extensionless imports — try .ts then .tsx.
+  else if (
+    (specifier.startsWith('./') || specifier.startsWith('../')) &&
+    !specifier.match(/\.\w+$/) &&
+    context.parentURL &&
+    context.parentURL.includes('/web/')
+  ) {
+    const baseUrl = new URL(specifier, context.parentURL);
+    for (const ext of ['.ts', '.tsx']) {
+      const candidate = fileURLToPath(baseUrl) + ext;
+      if (existsSync(candidate)) {
+        specifier = baseUrl.href + ext;
+        break;
+      }
+
+    }
+  }
+
+  return nextResolve(specifier, context);
+}
+
+export function load(url, context, nextLoad) {
+  // Node's --experimental-strip-types handles plain .ts but not .tsx and not
+  // all TypeScript syntax used by workspace packages (parameter properties,
+  // decorators, etc.). Transpile all workspace package source files and .tsx
+  // files through TypeScript's transpileModule to avoid those crashes.
+  const shouldTranspileWithTypeScript =
+    url.endsWith('.tsx') ||
+    (url.endsWith('.ts') && url.includes('/packages/') && url.includes('/src/'));
+
+  if (shouldTranspileWithTypeScript) {
+    const ts = require('typescript');
+    const source = readFileSync(fileURLToPath(url), 'utf-8');
+    const { outputText } = ts.transpileModule(source, {
+      fileName: fileURLToPath(url),
+      compilerOptions: {
+        jsx: ts.JsxEmit.ReactJSX,
+        module: ts.ModuleKind.ESNext,
+        target: ts.ScriptTarget.ESNext,
+        esModuleInterop: true,
+        experimentalDecorators: true,
+        emitDecoratorMetadata: true,
+      },
+    });
+    // Inject CJS-compatible globals (__dirname, __filename, require) so that
+    // workspace packages compiled as ESM can still use them.  This avoids the
+    // need for import.meta.url behind indirect invocation patterns that fail in
+    // CJS and in dynamically-created scopes.
+    // Only inject globals that the source file doesn't already declare itself.
+    const preambleLines = [
+      'import { fileURLToPath as __preamble_fUTP } from "node:url";',
+      'import { dirname as __preamble_dn } from "node:path";',
+      'import { createRequire as __preamble_cR } from "node:module";',
+    ];
+    if (!outputText.includes('const __filename') && !outputText.includes('let __filename')) {
+      preambleLines.push('const __filename = __preamble_fUTP(import.meta.url);');
+    }
+    if (!outputText.includes('const __dirname') && !outputText.includes('let __dirname')) {
+      preambleLines.push('const __dirname = __preamble_dn(__preamble_fUTP(import.meta.url));');
+    }
+    if (!outputText.includes('const require') && !outputText.includes('let require')) {
+      preambleLines.push('const require = __preamble_cR(import.meta.url);');
+    }
+    return { format: 'module', source: preambleLines.join('\n') + '\n' + outputText, shortCircuit: true };
+  }
+  return nextLoad(url, context);
+}

package/dist/resources/extensions/gsd/tests/resolve-ts-hooks.mjs

@@ -0,0 +1,23 @@
+import { fileURLToPath } from 'node:url';
+
+const ROOT = new URL("../../../../../", import.meta.url);
+const PACKAGES_ROOT = fileURLToPath(new URL("packages/", ROOT));
+
+export function resolve(specifier, context, nextResolve) {
+  let tsSpecifier = specifier;
+  if (specifier.includes('@gsd/')) {
+    tsSpecifier = specifier.replace('@gsd/', PACKAGES_ROOT).replace('/dist/', '/src/');
+    if (tsSpecifier.includes('/packages/pi-ai') && !tsSpecifier.endsWith('.ts')) {
+        tsSpecifier = tsSpecifier.replace(/\/packages\/pi-ai$/, '/packages/pi-ai/src/index.ts');
+    } else if (!tsSpecifier.includes('/src/') && !tsSpecifier.endsWith('.ts')) {
+        // Fallback for other gsd packages like pi-coding-agent, pi-tui, pi-agent-core
+        tsSpecifier = tsSpecifier.replace(/\/packages\/([^\/]+)$/, '/packages/$1/src/index.ts');
+    } else if (!tsSpecifier.endsWith('.ts') && !tsSpecifier.endsWith('.js') && !tsSpecifier.endsWith('.mjs')) {
+        tsSpecifier += '/index.ts';
+    }
+  } else if (specifier.endsWith('.js')) {
+    tsSpecifier = specifier.replace(/\.js$/, '.ts');
+  }
+
+  return nextResolve(tsSpecifier, context);
+}

package/dist/resources/extensions/gsd/tests/resolve-ts.mjs

@@ -0,0 +1,5 @@
+import { register } from 'node:module';
+import { pathToFileURL } from 'node:url';
+
+// Register hook to redirect imports to the dist directory
+register(new URL('./dist-redirect.mjs', import.meta.url), pathToFileURL('./'));

package/dist/resources/extensions/gsd/tools/memory-tools.js

@@ -59,25 +59,8 @@ export function executeMemoryCapture(params) {
     const scope = normalizeScope(params.scope);
     const tags = normalizeTags(params.tags);
     const structuredFields = normalizeStructuredFields(params.structuredFields);
-    let id;
-    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,
-        };
-    }
+    const id = createMemory({ category, content, confidence, scope, tags, structuredFields });
     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/dist/resources/extensions/gsd/visualizer-overlay.js

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

package/dist/resources/extensions/gsd/watch/header-renderer.js

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

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

@@ -18,13 +18,28 @@ import { createWorktree, listWorktrees, removeWorktree, mergeWorktreeToMain, dif
 import { inferCommitType } from "./git-service.js";
 import { existsSync, realpathSync, readdirSync, rmSync, unlinkSync } from "node:fs";
 import { nativeMergeAbort } from "./native-git-bridge.js";
-import { join } from "node:path";
-import { clearWorktreeOriginalCwd, ensureWorktreeOriginalCwdFromPath, getActiveWorktreeName, getWorktreeOriginalCwd, setWorktreeOriginalCwd, } from "./worktree-session-state.js";
-export { getActiveWorktreeName, getWorktreeOriginalCwd } from "./worktree-session-state.js";
+import { join, sep } from "node:path";
 /**
  * Tracks the original project root so we can switch back.
  * Set when we first chdir into a worktree, cleared on return.
  */
+let originalCwd = null;
+/** Get the original project root if currently in a worktree, or null. */
+export function getWorktreeOriginalCwd() {
+    return originalCwd;
+}
+/** Get the name of the active worktree, or null if not in one. */
+export function getActiveWorktreeName() {
+    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) ────────
 function worktreeCompletions(prefix) {
     const parts = prefix.trim().split(/\s+/);
@@ -96,7 +111,7 @@ async function worktreeHandler(args, ctx, pi, alias) {
             return;
         }
         // create and switch both do the same thing: switch if exists, create if not
-        const mainBase = getWorktreeOriginalCwd() ?? basePath;
+        const mainBase = originalCwd ?? basePath;
         const existing = listWorktrees(mainBase);
         if (existing.some(wt => wt.name === name)) {
             await handleSwitch(basePath, name, ctx);
@@ -108,7 +123,7 @@ async function worktreeHandler(args, ctx, pi, alias) {
     }
     if (trimmed === "merge" || trimmed.startsWith("merge ")) {
         const mergeArgs = trimmed.replace(/^merge\s*/, "").trim().split(/\s+/).filter(Boolean);
-        const mainBase = getWorktreeOriginalCwd() ?? basePath;
+        const mainBase = originalCwd ?? basePath;
         const activeWt = getActiveWorktreeName();
         if (mergeArgs.length === 0) {
             // Bare "/worktree merge" — only valid when inside a worktree
@@ -139,7 +154,7 @@ async function worktreeHandler(args, ctx, pi, alias) {
     }
     if (trimmed === "remove" || trimmed.startsWith("remove ")) {
         const name = trimmed.replace(/^remove\s*/, "").trim();
-        const mainBase = getWorktreeOriginalCwd() ?? basePath;
+        const mainBase = originalCwd ?? basePath;
         if (name === "all") {
             await handleRemoveAll(mainBase, ctx);
             return;
@@ -156,7 +171,7 @@ async function worktreeHandler(args, ctx, pi, alias) {
         ctx.ui.notify(`Usage: /${alias} ${trimmed}${trimmed === "list" || trimmed === "return" ? "" : " <name>"}`, "warning");
         return;
     }
-    const mainBase = getWorktreeOriginalCwd() ?? basePath;
+    const mainBase = originalCwd ?? basePath;
     const nameOnly = trimmed.split(/\s+/)[0];
     if (trimmed !== nameOnly) {
         ctx.ui.notify(`Unknown command. Did you mean /${alias} switch ${nameOnly}?`, "warning");
@@ -177,7 +192,14 @@ export function registerWorktreeCommand(pi) {
     // 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.
-    ensureWorktreeOriginalCwdFromPath();
+    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);
+        }
+    }
     pi.registerCommand("worktree", {
         description: "Git worktrees (also /wt): /worktree <name> | list | merge | remove",
         getArgumentCompletions: worktreeCompletions,
@@ -238,7 +260,7 @@ async function handleCreate(basePath, name, ctx) {
         // before createWorktree so the new worktree forks from committed HEAD)
         const commitMsg = autoCommitCurrentBranch(basePath, "worktree-switch", name);
         // Create from the main tree, not from inside another worktree
-        const mainBase = getWorktreeOriginalCwd() ?? basePath;
+        const mainBase = originalCwd ?? basePath;
         const info = createWorktree(mainBase, name);
         // Run user-configured post-create hook (#597) — e.g. copy .env, symlink assets
         const hookError = runWorktreePostCreateHook(mainBase, info.path);
@@ -246,8 +268,8 @@ async function handleCreate(basePath, name, ctx) {
             ctx.ui.notify(hookError, "warning");
         }
         // Track original cwd before switching
-        if (!getWorktreeOriginalCwd())
-            setWorktreeOriginalCwd(basePath);
+        if (!originalCwd)
+            originalCwd = basePath;
         const prevCwd = process.cwd();
         process.chdir(info.path);
         nudgeGitBranchCache(prevCwd);
@@ -297,7 +319,7 @@ async function handleCreate(basePath, name, ctx) {
 }
 async function handleSwitch(basePath, name, ctx) {
     try {
-        const mainBase = getWorktreeOriginalCwd() ?? basePath;
+        const mainBase = originalCwd ?? basePath;
         const wtPath = worktreePath(mainBase, name);
         if (!existsSync(wtPath)) {
             ctx.ui.notify(`Worktree "${name}" not found. Run /worktree list to see available worktrees.`, "warning");
@@ -306,8 +328,8 @@ async function handleSwitch(basePath, name, ctx) {
         // Auto-commit dirty files before leaving current workspace
         const commitMsg = autoCommitCurrentBranch(basePath, "worktree-switch", name);
         // Track original cwd before switching
-        if (!getWorktreeOriginalCwd())
-            setWorktreeOriginalCwd(basePath);
+        if (!originalCwd)
+            originalCwd = basePath;
         const prevCwd = process.cwd();
         process.chdir(wtPath);
         nudgeGitBranchCache(prevCwd);
@@ -330,7 +352,6 @@ async function handleSwitch(basePath, name, ctx) {
     }
 }
 async function handleReturn(ctx) {
-    const originalCwd = getWorktreeOriginalCwd();
     if (!originalCwd) {
         ctx.ui.notify("Already in the main project tree.", "info");
         return;
@@ -338,7 +359,7 @@ async function handleReturn(ctx) {
     // Auto-commit dirty files before leaving worktree
     const commitMsg = autoCommitCurrentBranch(process.cwd(), "worktree-return", "worktree");
     const returnTo = originalCwd;
-    clearWorktreeOriginalCwd();
+    originalCwd = null;
     const prevCwd = process.cwd();
     process.chdir(returnTo);
     nudgeGitBranchCache(prevCwd);
@@ -388,7 +409,7 @@ const CLR = {
 };
 async function handleList(basePath, ctx) {
     try {
-        const mainBase = getWorktreeOriginalCwd() ?? basePath;
+        const mainBase = originalCwd ?? basePath;
         const worktrees = listWorktrees(mainBase);
         if (worktrees.length === 0) {
             ctx.ui.notify("No GSD worktrees found. Create one with /worktree <name>.", "info");
@@ -431,7 +452,6 @@ async function handleList(basePath, ctx) {
             }
             lines.push("");
         }
-        const originalCwd = getWorktreeOriginalCwd();
         if (originalCwd) {
             lines.push(`  ${CLR.label("main tree")}  ${CLR.path(originalCwd)}`);
         }
@@ -519,11 +539,11 @@ async function handleMerge(basePath, name, ctx, pi, targetBranch) {
         }
         // Switch to the main tree before merging.
         // Must be on the main branch to run git merge --squash.
-        if (getWorktreeOriginalCwd()) {
+        if (originalCwd) {
             const prevCwd = process.cwd();
             process.chdir(basePath);
             nudgeGitBranchCache(prevCwd);
-            clearWorktreeOriginalCwd();
+            originalCwd = null;
         }
         // --- Deterministic merge path (preferred) ---
         // Try a direct squash-merge first. Only fall back to LLM on conflict.
@@ -600,7 +620,7 @@ async function handleMerge(basePath, name, ctx, pi, targetBranch) {
 }
 async function handleRemove(basePath, name, ctx) {
     try {
-        const mainBase = getWorktreeOriginalCwd() ?? basePath;
+        const mainBase = originalCwd ?? basePath;
         // Validate the worktree exists before attempting removal
         const worktrees = listWorktrees(mainBase);
         const wt = worktrees.find(w => w.name === name);
@@ -621,9 +641,9 @@ async function handleRemove(basePath, name, ctx) {
         const prevCwd = process.cwd();
         removeWorktree(mainBase, name, { deleteBranch: true });
         // If we were in that worktree, removeWorktree chdir'd us out — clear tracking
-        if (getWorktreeOriginalCwd() && process.cwd() !== prevCwd) {
+        if (originalCwd && process.cwd() !== prevCwd) {
             nudgeGitBranchCache(prevCwd);
-            clearWorktreeOriginalCwd();
+            originalCwd = null;
         }
         ctx.ui.notify(`${CLR.ok("✓")} Worktree ${CLR.name(name)} removed ${CLR.muted("(branch deleted)")}.`, "info");
     }
@@ -634,7 +654,7 @@ async function handleRemove(basePath, name, ctx) {
 }
 async function handleRemoveAll(basePath, ctx) {
     try {
-        const mainBase = getWorktreeOriginalCwd() ?? basePath;
+        const mainBase = originalCwd ?? basePath;
         const worktrees = listWorktrees(mainBase);
         if (worktrees.length === 0) {
             ctx.ui.notify("No worktrees to remove.", "info");
@@ -664,9 +684,9 @@ async function handleRemoveAll(basePath, ctx) {
             }
         }
         // If we were in a worktree that got removed, clear tracking
-        if (getWorktreeOriginalCwd() && process.cwd() !== prevCwd) {
+        if (originalCwd && process.cwd() !== prevCwd) {
             nudgeGitBranchCache(prevCwd);
-            clearWorktreeOriginalCwd();
+            originalCwd = null;
         }
         const lines = [];
         if (removed.length > 0)

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

@@ -2,8 +2,7 @@
  * 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) and the global ~/.gsd/mcp.json (or
- * $GSD_HOME/mcp.json) using the @modelcontextprotocol/sdk Client
+ * (.mcp.json, .gsd/mcp.json) using the @modelcontextprotocol/sdk Client
  * directly — no external CLI dependency required.
  *
  * Three tools:
@@ -18,7 +17,6 @@ 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";
 // ─── Connection Manager ───────────────────────────────────────────────────────
@@ -63,7 +61,6 @@ function readConfigs() {
     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) {
         try {
@@ -261,7 +258,7 @@ async function closeAll() {
 // ─── Formatters ───────────────────────────────────────────────────────────────
 function formatServerList(servers) {
     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).";
+        return "No MCP servers configured. Add servers to .mcp.json or .gsd/mcp.json.";
     const lines = [`${servers.length} MCP servers configured:\n`];
     for (const s of servers) {
         const connected = connections.has(s.name) ? "✓" : "○";
@@ -309,7 +306,7 @@ export default function (pi) {
     pi.registerTool({
         name: "mcp_servers",
         label: "MCP Servers",
-        description: "List all available MCP servers configured in project files (.mcp.json, .gsd/mcp.json) or globally ($GSD_HOME/mcp.json, default: ~/.gsd/mcp.json). " +
+        description: "List all available MCP servers configured in project files (.mcp.json, .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",
         promptGuidelines: [

package/dist/resources/extensions/slash-commands/create-extension.js

@@ -193,35 +193,38 @@ function sendPrompt(description, result, pi) {
         ? (Array.isArray(persistenceAnswer.selected) ? persistenceAnswer.selected[0] : persistenceAnswer.selected)
         : "";
     const docHints = [
-        "- `docs/extension-sdk/README.md` — overview, quick start, directory layout",
-        "- `docs/extension-sdk/api-reference.md` — ExtensionAPI and ExtensionContext surfaces",
-        "- `docs/extension-sdk/building-extensions.md` — tools, commands, events, UI, state",
-        "- `docs/extension-sdk/rules.md` — non-negotiable rules and gotchas",
+        "- `~/.gsd/agent/docs/extending-pi/01-what-are-extensions.md` — capabilities overview",
+        "- `~/.gsd/agent/docs/extending-pi/03-getting-started.md` — minimal extension, hot reload",
+        "- `~/.gsd/agent/docs/extending-pi/08-extensioncontext-what-you-can-access.md` — ExtensionContext API",
+        "- `~/.gsd/agent/docs/extending-pi/09-extensionapi-what-you-can-do.md` — ExtensionAPI: registration, messaging",
+        "- `~/.gsd/agent/docs/extending-pi/22-key-rules-gotchas.md` — must-read rules before shipping",
     ];
     if (uiSelected.includes("custom component")) {
-        docHints.push("- `docs/extension-sdk/building-extensions.md#custom-components` — ctx.ui.custom() API");
-        docHints.push("- `docs/dev/pi-ui-tui/06-ctx-ui-custom-full-custom-components.md` — step-by-step component guide");
-        docHints.push("- `docs/dev/pi-ui-tui/07-built-in-components-the-building-blocks.md` — Text, Box, SelectList");
-        docHints.push("- `docs/dev/pi-ui-tui/09-keyboard-input-how-to-handle-keys.md` — Key, matchesKey");
-        docHints.push("- `docs/dev/pi-ui-tui/10-line-width-the-cardinal-rule.md` — truncation, width rules");
+        docHints.push("- `~/.gsd/agent/docs/extending-pi/12-custom-ui-visual-components.md` — dialogs, widgets, overlays");
+        docHints.push("- `~/.gsd/agent/docs/pi-ui-tui/06-ctx-ui-custom-full-custom-components.md` — ctx.ui.custom() API");
+        docHints.push("- `~/.gsd/agent/docs/pi-ui-tui/07-built-in-components-the-building-blocks.md` — Text, Box, SelectList");
+        docHints.push("- `~/.gsd/agent/docs/pi-ui-tui/09-keyboard-input-how-to-handle-keys.md` — Key, matchesKey");
+        docHints.push("- `~/.gsd/agent/docs/pi-ui-tui/10-line-width-the-cardinal-rule.md` — truncation, width rules");
+        docHints.push("- `~/.gsd/agent/docs/pi-ui-tui/19-building-a-complete-component-step-by-step.md` — step-by-step guide");
+        docHints.push("- `~/.gsd/agent/docs/pi-ui-tui/21-common-mistakes-and-how-to-avoid-them.md` — pitfalls");
     }
     else if (uiSelected.includes("Dialogs")) {
-        docHints.push("- `docs/extension-sdk/building-extensions.md#built-in-dialogs` — select, confirm, input");
+        docHints.push("- `~/.gsd/agent/docs/pi-ui-tui/04-built-in-dialog-methods.md` — select, confirm, input, editor");
     }
     else if (uiSelected.includes("Status")) {
-        docHints.push("- `docs/extension-sdk/building-extensions.md#persistent-ui-elements` — status, widgets");
+        docHints.push("- `~/.gsd/agent/docs/pi-ui-tui/05-persistent-ui-elements.md` — status, widgets, footer, header");
     }
     if (uiSelected.includes("tool") || result.answers["purpose"]) {
-        docHints.push("- `docs/dev/extending-pi/14-custom-rendering-controlling-what-the-user-sees.md` — renderCall / renderResult");
+        docHints.push("- `~/.gsd/agent/docs/extending-pi/14-custom-rendering-controlling-what-the-user-sees.md` — renderCall / renderResult");
     }
     if (eventsSelected && !eventsSelected.includes("standalone")) {
-        docHints.push("- `docs/dev/extending-pi/07-events-the-nervous-system.md` — all events reference");
+        docHints.push("- `~/.gsd/agent/docs/extending-pi/07-events-the-nervous-system.md` — all events reference");
     }
     if (eventsSelected.includes("context / prompt")) {
-        docHints.push("- `docs/dev/extending-pi/15-system-prompt-modification.md` — system prompt hooks");
+        docHints.push("- `~/.gsd/agent/docs/extending-pi/15-system-prompt-modification.md` — system prompt hooks");
     }
     if (persistenceSelected.includes("session")) {
-        docHints.push("- `docs/extension-sdk/building-extensions.md#state-management` — state reconstruction, appendEntry");
+        docHints.push("- `~/.gsd/agent/docs/extending-pi/13-state-management-persistence.md` — pi.appendEntry, session state");
     }
     const prompt = `Create a new pi extension based on this description:
 
@@ -235,30 +238,13 @@ ${docHints.join("\n")}
 
 ## Output
 
-Write the complete implementation as a directory-based extension:
+Write the complete implementation as a single self-contained extension file:
 
-\`~/.gsd/agent/extensions/<kebab-case-name>/index.ts\`
-\`~/.gsd/agent/extensions/<kebab-case-name>/extension-manifest.json\`
+\`~/.gsd/agent/extensions/<kebab-case-name>.ts\`
 
-The manifest must follow this format:
-\`\`\`json
-{
-  "id": "<kebab-case-name>",
-  "name": "<Human Name>",
-  "version": "1.0.0",
-  "description": "<one-line description>",
-  "tier": "community",
-  "requires": { "platform": ">=2.29.0" },
-  "provides": {
-    "tools": ["<tool_names_registered>"],
-    "commands": ["<command_names_registered>"],
-    "hooks": ["<event_names_subscribed>"],
-    "shortcuts": ["<shortcut_keys_registered>"]
-  }
-}
-\`\`\`
+Then register it in the main extensions index:
 
-Only include non-empty arrays in \`provides\`. See \`docs/extension-sdk/manifest-spec.md\` for the full spec.
+\`~/.gsd/agent/extensions/index.ts\` — import and call the new extension's default export alongside existing ones
 
 ## Rules you must follow exactly
 

package/dist/resources/skills/create-gsd-extension/SKILL.md

@@ -19,8 +19,8 @@ Note: `~/.gsd/agent/extensions/` is reserved for bundled extensions synced from
 3. **Commands** — Give users slash commands (`pi.registerCommand()`). Users type `/mycommand`.
 
 **Non-negotiable rules:**
-- Use `StringEnum` from `@gsd/pi-ai` for string enum params (NOT `Type.Union`/`Type.Literal` — breaks Google's API)
-- Truncate tool output to 50KB / 2000 lines max (use `truncateHead`/`truncateTail` from `@gsd/pi-coding-agent`)
+- Use `StringEnum` from `@mariozechner/pi-ai` for string enum params (NOT `Type.Union`/`Type.Literal` — breaks Google's API)
+- Truncate tool output to 50KB / 2000 lines max (use `truncateHead`/`truncateTail` from `@mariozechner/pi-coding-agent`)
 - Store stateful tool state in `details` for branching support
 - Check `signal?.aborted` in long-running tool executions
 - Use `pi.exec()` not `child_process` for shell commands
@@ -34,10 +34,10 @@ Note: `~/.gsd/agent/extensions/` is reserved for bundled extensions synced from
 
 | Package | Purpose |
 |---------|---------|
-| `@gsd/pi-coding-agent` | `ExtensionAPI`, `ExtensionContext`, `Theme`, event types, tool utilities, `DynamicBorder`, `BorderedLoader`, `CustomEditor`, `highlightCode` |
+| `@mariozechner/pi-coding-agent` | `ExtensionAPI`, `ExtensionContext`, `Theme`, event types, tool utilities, `DynamicBorder`, `BorderedLoader`, `CustomEditor`, `highlightCode` |
 | `@sinclair/typebox` | `Type.Object`, `Type.String`, `Type.Number`, `Type.Optional`, `Type.Boolean`, `Type.Array` |
-| `@gsd/pi-ai` | `StringEnum` (required for string enums), `Type` re-export |
-| `@gsd/pi-tui` | `Text`, `Box`, `Container`, `Spacer`, `Markdown`, `SelectList`, `Input`, `matchesKey`, `Key`, `truncateToWidth`, `visibleWidth` |
+| `@mariozechner/pi-ai` | `StringEnum` (required for string enums), `Type` re-export |
+| `@mariozechner/pi-tui` | `Text`, `Box`, `Container`, `Spacer`, `Markdown`, `SelectList`, `Input`, `matchesKey`, `Key`, `truncateToWidth`, `visibleWidth` |
 | Node.js built-ins | `node:fs`, `node:path`, `node:child_process`, etc. |
 
 </essential_principles>
@@ -65,9 +65,6 @@ All domain knowledge in `references/`:
 **Capabilities:** custom-tools.md, custom-commands.md, custom-ui.md, custom-rendering.md
 **Patterns:** state-management.md, system-prompt-modification.md, compaction-session-control.md
 **Infrastructure:** model-provider-management.md, remote-execution-overrides.md, packaging-distribution.md, mode-behavior.md
-**Spec:** `docs/extension-sdk/manifest-spec.md` — manifest format, tiers, validation
-**Testing:** `docs/extension-sdk/testing.md` — mock patterns, test conventions
-**SDK:** `docs/extension-sdk/` — the authoritative GSD-2 extension guide
 **Gotchas:** key-rules-gotchas.md
 </reference_index>
 
@@ -81,7 +78,6 @@ All domain knowledge in `references/`:
 
 <success_criteria>
 Extension is complete when:
-- `extension-manifest.json` exists with accurate `provides` listing all registered tools/commands/hooks/shortcuts
 - TypeScript compiles without errors (jiti handles this at runtime)
 - Extension loads on GSD startup or `/reload` without errors
 - Tools appear in the LLM's system prompt and are callable