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

package/dist/resources/extensions/gsd/prompt-loader.js

@@ -7,14 +7,13 @@
  * Templates live at prompts/ relative to this module's directory.
  * They use {{variableName}} syntax for substitution.
  *
- * All templates are eagerly loaded into cache at module init via warmCache().
- * This prevents a running session from being invalidated when another `gsd`
- * launch overwrites ~/.gsd/agent/ with newer templates via initResources().
- * Without eager caching, the in-memory extension code (which knows variable
- * set A) can read a newer template from disk (which expects variable set B),
- * causing a "template declares {{X}} but no value was provided" crash
- * mid-session — especially for late-loading templates like complete-milestone
- * that aren't read until the end of a long auto-mode run.
+ * Templates are snapshotted shortly after module init via warmCache().
+ * This keeps import/extension-registration fast while still preventing a
+ * running session from being invalidated when another `gsd` launch overwrites
+ * ~/.gsd/agent/ with newer templates via initResources(). Without caching, the
+ * in-memory extension code (which knows variable set A) can read a newer
+ * template from disk (which expects variable set B), causing a
+ * "template declares {{X}} but no value was provided" crash mid-session.
  */
 import { readFileSync, readdirSync, existsSync } from "node:fs";
 import { GSDError, GSD_PARSE_ERROR } from "./errors.js";
@@ -69,8 +68,8 @@ const templatesDir = join(__extensionDir, "templates");
 export function getTemplatesDir() {
     return templatesDir;
 }
-// Cache all templates eagerly at module load — a running session uses the
-// template versions that were on disk at startup, immune to later overwrites.
+// Cache all templates from a startup snapshot — a running session uses the
+// template versions that were on disk near startup, immune to later overwrites.
 const templateCache = new Map();
 /**
  * Eagerly read all .md files from prompts/ and templates/ into cache.
@@ -112,8 +111,20 @@ function warmCache() {
         }
     }
 }
-// Snapshot all templates at module load time
-warmCache();
+let warmCacheScheduled = false;
+function scheduleWarmCache() {
+    if (warmCacheScheduled)
+        return;
+    warmCacheScheduled = true;
+    const run = () => {
+        warmCache();
+    };
+    const timer = setTimeout(run, 1000);
+    timer.unref?.();
+}
+// Snapshot the full prompt/template tree after import so extension startup only
+// pays for prompts that are actually needed immediately.
+scheduleWarmCache();
 /**
  * Load a prompt template and substitute variables.
  *

package/dist/resources/extensions/gsd/slice-parallel-orchestrator.js

@@ -32,6 +32,7 @@ let sliceState = null;
 // on next session start. (Issue #4980 HIGH-8)
 const SLICE_ORCHESTRATOR_STATE_FILE = "slice-orchestrator.json";
 const TMP_SUFFIX = ".tmp";
+export const SLICE_WORKER_AUTO_ARGS = ["headless", "--json", "auto"];
 function sliceStateFilePath(basePath) {
     return join(gsdRoot(basePath), SLICE_ORCHESTRATOR_STATE_FILE);
 }
@@ -272,7 +273,7 @@ export function getSliceOrchestratorState() {
 /**
  * Start parallel execution for eligible slices within a milestone.
  *
- * For each eligible slice: create a worktree, spawn `gsd --mode json --print "/gsd auto"`
+ * For each eligible slice: create a worktree, spawn `gsd headless --json auto`
  * with env GSD_SLICE_LOCK=<SID> + GSD_MILESTONE_LOCK=<MID> + GSD_PARALLEL_WORKER=1.
  */
 export async function startSliceParallel(basePath, milestoneId, eligibleSlices, opts = {}) {
@@ -482,8 +483,13 @@ function resolveGsdBin() {
 }
 /**
  * Spawn a worker process for a slice.
- * The worker runs `gsd --mode json --print "/gsd auto"` in the slice's worktree
+ * The worker runs `gsd headless --json auto` in the slice's worktree
  * with GSD_SLICE_LOCK, GSD_MILESTONE_LOCK, and GSD_PARALLEL_WORKER set.
+ *
+ * Print-mode slash commands return after the command handler schedules
+ * auto-mode, so the worker process can exit before doing any LLM work. The
+ * headless auto entrypoint keeps the process alive until auto-mode reaches a
+ * terminal notification, matching milestone-level parallel workers.
  */
 function spawnSliceWorker(basePath, milestoneId, sliceId) {
     if (!sliceState)
@@ -498,7 +504,7 @@ function spawnSliceWorker(basePath, milestoneId, sliceId) {
         return false;
     let child;
     try {
-        child = spawn(process.execPath, [binPath, "--mode", "json", "--print", "/gsd auto"], {
+        child = spawn(process.execPath, [binPath, ...SLICE_WORKER_AUTO_ARGS], {
             cwd: worker.worktreePath,
             env: {
                 ...process.env,

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

@@ -60,6 +60,48 @@ export function isGhostMilestone(basePath, mid) {
     const summary = resolveMilestoneFile(basePath, mid, "SUMMARY");
     return !context && !draft && !roadmap && !summary;
 }
+/**
+ * A "reusable ghost" milestone is an orphaned filesystem stub that is safe
+ * to reclaim as the next milestone ID.
+ *
+ * Stricter than `isGhostMilestone`: returns true ONLY when ALL of the
+ * following hold:
+ *   1. No DB row exists for `mid` (any status, including "queued") — a DB row
+ *      means the milestone was intentionally registered by
+ *      `gsd_milestone_generate_id` and may have an in-flight discuss flow.
+ *      Reusing it would collide with that flow. (#4996 race window)
+ *   2. No worktree directory exists at `gsdRoot/worktrees/{mid}` — a worktree
+ *      means the milestone is legitimately in-flight.
+ *   3. No content files exist (CONTEXT, CONTEXT-DRAFT, ROADMAP, SUMMARY) —
+ *      any content means the discuss flow already ran.
+ *
+ * The looser `isGhostMilestone` also classifies queued-row-without-content as
+ * a ghost to help state queries filter phantoms. `isReusableGhostMilestone`
+ * intentionally does NOT reclaim those — a queued row is sufficient proof of
+ * a live in-flight ID reservation.
+ *
+ * Used by `nextMilestoneIdReserved` and both MCP ID-generator tools to fill
+ * gaps left by phantom directories before resorting to max+1.
+ */
+export function isReusableGhostMilestone(basePath, mid) {
+    // Condition 1: no DB row (any status).
+    if (!isDbAvailable())
+        return false;
+    const dbRow = getMilestone(mid);
+    if (dbRow != null)
+        return false;
+    // Condition 2: no worktree.
+    const root = gsdRoot(basePath);
+    const wtPath = join(root, 'worktrees', mid);
+    if (existsSync(wtPath))
+        return false;
+    // Condition 3: no content files.
+    const context = resolveMilestoneFile(basePath, mid, "CONTEXT");
+    const draft = resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT");
+    const roadmap = resolveMilestoneFile(basePath, mid, "ROADMAP");
+    const summary = resolveMilestoneFile(basePath, mid, "SUMMARY");
+    return !context && !draft && !roadmap && !summary;
+}
 // ─── Query Functions ───────────────────────────────────────────────────────
 /**
  * Check if all tasks in a slice plan are done.

package/dist/resources/extensions/gsd/templates/PREFERENCES.md

@@ -39,6 +39,7 @@ dynamic_routing:
   budget_pressure:
   cross_provider:
   hooks:
+disabled_model_providers: []
 uok:
   enabled: true
   legacy_fallback:

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

@@ -59,8 +59,25 @@ export function executeMemoryCapture(params) {
     const scope = normalizeScope(params.scope);
     const tags = normalizeTags(params.tags);
     const structuredFields = normalizeStructuredFields(params.structuredFields);
-    const id = createMemory({ category, content, confidence, scope, tags, 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,
+        };
+    }
     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";
-const TAB_COUNT = 10;
+export const TAB_COUNT = 10;
 const TAB_LABELS = [
     "1 Progress",
     "2 Timeline",

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

@@ -96,13 +96,15 @@ export function readGitBranch(projectRoot) {
     }
 }
 /**
- * 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) {
     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,28 +18,13 @@ 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, 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 = 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+/);
@@ -111,7 +96,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 = originalCwd ?? basePath;
+        const mainBase = getWorktreeOriginalCwd() ?? basePath;
         const existing = listWorktrees(mainBase);
         if (existing.some(wt => wt.name === name)) {
             await handleSwitch(basePath, name, ctx);
@@ -123,7 +108,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 = originalCwd ?? basePath;
+        const mainBase = getWorktreeOriginalCwd() ?? basePath;
         const activeWt = getActiveWorktreeName();
         if (mergeArgs.length === 0) {
             // Bare "/worktree merge" — only valid when inside a worktree
@@ -154,7 +139,7 @@ async function worktreeHandler(args, ctx, pi, alias) {
     }
     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);
             return;
@@ -171,7 +156,7 @@ async function worktreeHandler(args, ctx, pi, alias) {
         ctx.ui.notify(`Usage: /${alias} ${trimmed}${trimmed === "list" || trimmed === "return" ? "" : " <name>"}`, "warning");
         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");
@@ -192,14 +177,7 @@ 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.
-    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",
         getArgumentCompletions: worktreeCompletions,
@@ -260,7 +238,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 = originalCwd ?? basePath;
+        const mainBase = getWorktreeOriginalCwd() ?? 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);
@@ -268,8 +246,8 @@ async function handleCreate(basePath, name, ctx) {
             ctx.ui.notify(hookError, "warning");
         }
         // Track original cwd before switching
-        if (!originalCwd)
-            originalCwd = basePath;
+        if (!getWorktreeOriginalCwd())
+            setWorktreeOriginalCwd(basePath);
         const prevCwd = process.cwd();
         process.chdir(info.path);
         nudgeGitBranchCache(prevCwd);
@@ -319,7 +297,7 @@ async function handleCreate(basePath, name, ctx) {
 }
 async function handleSwitch(basePath, name, ctx) {
     try {
-        const mainBase = originalCwd ?? basePath;
+        const mainBase = getWorktreeOriginalCwd() ?? basePath;
         const wtPath = worktreePath(mainBase, name);
         if (!existsSync(wtPath)) {
             ctx.ui.notify(`Worktree "${name}" not found. Run /worktree list to see available worktrees.`, "warning");
@@ -328,8 +306,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 (!originalCwd)
-            originalCwd = basePath;
+        if (!getWorktreeOriginalCwd())
+            setWorktreeOriginalCwd(basePath);
         const prevCwd = process.cwd();
         process.chdir(wtPath);
         nudgeGitBranchCache(prevCwd);
@@ -352,6 +330,7 @@ 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;
@@ -359,7 +338,7 @@ async function handleReturn(ctx) {
     // Auto-commit dirty files before leaving worktree
     const commitMsg = autoCommitCurrentBranch(process.cwd(), "worktree-return", "worktree");
     const returnTo = originalCwd;
-    originalCwd = null;
+    clearWorktreeOriginalCwd();
     const prevCwd = process.cwd();
     process.chdir(returnTo);
     nudgeGitBranchCache(prevCwd);
@@ -409,7 +388,7 @@ const CLR = {
 };
 async function handleList(basePath, ctx) {
     try {
-        const mainBase = originalCwd ?? basePath;
+        const mainBase = getWorktreeOriginalCwd() ?? basePath;
         const worktrees = listWorktrees(mainBase);
         if (worktrees.length === 0) {
             ctx.ui.notify("No GSD worktrees found. Create one with /worktree <name>.", "info");
@@ -452,6 +431,7 @@ async function handleList(basePath, ctx) {
             }
             lines.push("");
         }
+        const originalCwd = getWorktreeOriginalCwd();
         if (originalCwd) {
             lines.push(`  ${CLR.label("main tree")}  ${CLR.path(originalCwd)}`);
         }
@@ -539,11 +519,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 (originalCwd) {
+        if (getWorktreeOriginalCwd()) {
             const prevCwd = process.cwd();
             process.chdir(basePath);
             nudgeGitBranchCache(prevCwd);
-            originalCwd = null;
+            clearWorktreeOriginalCwd();
         }
         // --- Deterministic merge path (preferred) ---
         // Try a direct squash-merge first. Only fall back to LLM on conflict.
@@ -620,7 +600,7 @@ async function handleMerge(basePath, name, ctx, pi, targetBranch) {
 }
 async function handleRemove(basePath, name, ctx) {
     try {
-        const mainBase = originalCwd ?? basePath;
+        const mainBase = getWorktreeOriginalCwd() ?? basePath;
         // Validate the worktree exists before attempting removal
         const worktrees = listWorktrees(mainBase);
         const wt = worktrees.find(w => w.name === name);
@@ -641,9 +621,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 (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");
     }
@@ -654,7 +634,7 @@ async function handleRemove(basePath, name, ctx) {
 }
 async function handleRemoveAll(basePath, ctx) {
     try {
-        const mainBase = originalCwd ?? basePath;
+        const mainBase = getWorktreeOriginalCwd() ?? basePath;
         const worktrees = listWorktrees(mainBase);
         if (worktrees.length === 0) {
             ctx.ui.notify("No worktrees to remove.", "info");
@@ -684,9 +664,9 @@ async function handleRemoveAll(basePath, ctx) {
             }
         }
         // 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 = [];
         if (removed.length > 0)

package/dist/resources/extensions/gsd/worktree-session-state.js

@@ -0,0 +1,33 @@
+// GSD worktree session state
+let originalCwd = null;
+export function getWorktreeOriginalCwd() {
+    return originalCwd;
+}
+export function setWorktreeOriginalCwd(cwd) {
+    originalCwd = cwd;
+}
+export function clearWorktreeOriginalCwd() {
+    originalCwd = null;
+}
+export function ensureWorktreeOriginalCwdFromPath(cwd = process.cwd()) {
+    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() {
+    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/dist/resources/extensions/mcp-client/index.js

@@ -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:
@@ -17,6 +18,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";
 // ─── Connection Manager ───────────────────────────────────────────────────────
@@ -61,6 +63,7 @@ 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 {
@@ -258,7 +261,7 @@ async function closeAll() {
 // ─── Formatters ───────────────────────────────────────────────────────────────
 function formatServerList(servers) {
     if (servers.length === 0)
-        return "No MCP servers configured. Add servers to .mcp.json or .gsd/mcp.json.";
+        return "No MCP servers configured. Add servers to .mcp.json, .gsd/mcp.json, or $GSD_HOME/mcp.json (default: ~/.gsd/mcp.json).";
     const lines = [`${servers.length} MCP servers configured:\n`];
     for (const s of servers) {
         const connected = connections.has(s.name) ? "✓" : "○";
@@ -306,7 +309,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). " +
+        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). " +
             "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,38 +193,35 @@ function sendPrompt(description, result, pi) {
         ? (Array.isArray(persistenceAnswer.selected) ? persistenceAnswer.selected[0] : persistenceAnswer.selected)
         : "";
     const docHints = [
-        "- `~/.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",
+        "- `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",
     ];
     if (uiSelected.includes("custom component")) {
-        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");
+        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");
     }
     else if (uiSelected.includes("Dialogs")) {
-        docHints.push("- `~/.gsd/agent/docs/pi-ui-tui/04-built-in-dialog-methods.md` — select, confirm, input, editor");
+        docHints.push("- `docs/extension-sdk/building-extensions.md#built-in-dialogs` — select, confirm, input");
     }
     else if (uiSelected.includes("Status")) {
-        docHints.push("- `~/.gsd/agent/docs/pi-ui-tui/05-persistent-ui-elements.md` — status, widgets, footer, header");
+        docHints.push("- `docs/extension-sdk/building-extensions.md#persistent-ui-elements` — status, widgets");
     }
     if (uiSelected.includes("tool") || result.answers["purpose"]) {
-        docHints.push("- `~/.gsd/agent/docs/extending-pi/14-custom-rendering-controlling-what-the-user-sees.md` — renderCall / renderResult");
+        docHints.push("- `docs/dev/extending-pi/14-custom-rendering-controlling-what-the-user-sees.md` — renderCall / renderResult");
     }
     if (eventsSelected && !eventsSelected.includes("standalone")) {
-        docHints.push("- `~/.gsd/agent/docs/extending-pi/07-events-the-nervous-system.md` — all events reference");
+        docHints.push("- `docs/dev/extending-pi/07-events-the-nervous-system.md` — all events reference");
     }
     if (eventsSelected.includes("context / prompt")) {
-        docHints.push("- `~/.gsd/agent/docs/extending-pi/15-system-prompt-modification.md` — system prompt hooks");
+        docHints.push("- `docs/dev/extending-pi/15-system-prompt-modification.md` — system prompt hooks");
     }
     if (persistenceSelected.includes("session")) {
-        docHints.push("- `~/.gsd/agent/docs/extending-pi/13-state-management-persistence.md` — pi.appendEntry, session state");
+        docHints.push("- `docs/extension-sdk/building-extensions.md#state-management` — state reconstruction, appendEntry");
     }
     const prompt = `Create a new pi extension based on this description:
 
@@ -238,13 +235,30 @@ ${docHints.join("\n")}
 
 ## Output
 
-Write the complete implementation as a single self-contained extension file:
+Write the complete implementation as a directory-based extension:
 
-\`~/.gsd/agent/extensions/<kebab-case-name>.ts\`
+\`~/.gsd/agent/extensions/<kebab-case-name>/index.ts\`
+\`~/.gsd/agent/extensions/<kebab-case-name>/extension-manifest.json\`
 
-Then register it in the main extensions index:
+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>"]
+  }
+}
+\`\`\`
 
-\`~/.gsd/agent/extensions/index.ts\` — import and call the new extension's default export alongside existing ones
+Only include non-empty arrays in \`provides\`. See \`docs/extension-sdk/manifest-spec.md\` for the full spec.
 
 ## 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 `@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`)
+- 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`)
 - 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 |
 |---------|---------|
-| `@mariozechner/pi-coding-agent` | `ExtensionAPI`, `ExtensionContext`, `Theme`, event types, tool utilities, `DynamicBorder`, `BorderedLoader`, `CustomEditor`, `highlightCode` |
+| `@gsd/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` |
-| `@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` |
+| `@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` |
 | Node.js built-ins | `node:fs`, `node:path`, `node:child_process`, etc. |
 
 </essential_principles>
@@ -65,6 +65,9 @@ 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>
 
@@ -78,6 +81,7 @@ 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

package/dist/resources/skills/create-gsd-extension/references/custom-commands.md

@@ -19,7 +19,7 @@ pi.registerCommand("deploy", {
 Add tab-completion for command arguments:
 
 ```typescript
-import type { AutocompleteItem } from "@mariozechner/pi-tui";
+import type { AutocompleteItem } from "@gsd/pi-tui";
 
 pi.registerCommand("deploy", {
   description: "Deploy to an environment",