gsd-pi 2.57.0 → 2.58.0-dev.778d6ac

package/dist/resources/extensions/ollama/ollama-commands.js

@@ -0,0 +1,194 @@
+// GSD2 — Ollama slash commands
+import { Text } from "@gsd/pi-tui";
+import * as client from "./ollama-client.js";
+import { discoverModels, formatModelForDisplay } from "./ollama-discovery.js";
+import { formatModelSize } from "./model-capabilities.js";
+export function registerOllamaCommands(pi) {
+    pi.registerCommand("ollama", {
+        description: "Manage local Ollama models — list | pull | remove | ps",
+        async handler(args, ctx) {
+            const parts = (args ?? "").trim().split(/\s+/);
+            const subcommand = parts[0] || "status";
+            const modelArg = parts.slice(1).join(" ");
+            switch (subcommand) {
+                case "status":
+                    return await handleStatus(ctx);
+                case "list":
+                case "ls":
+                    return await handleList(ctx);
+                case "pull":
+                    return await handlePull(modelArg, ctx);
+                case "remove":
+                case "rm":
+                case "delete":
+                    return await handleRemove(modelArg, ctx);
+                case "ps":
+                    return await handlePs(ctx);
+                default:
+                    ctx.ui.notify(`Unknown subcommand: ${subcommand}. Use: status, list, pull, remove, ps`, "warning");
+            }
+        },
+    });
+}
+async function handleStatus(ctx) {
+    const running = await client.isRunning();
+    if (!running) {
+        ctx.ui.notify("Ollama is not running. Install from https://ollama.com and run 'ollama serve'", "warning");
+        return;
+    }
+    const version = await client.getVersion();
+    const lines = [];
+    lines.push(`Ollama${version ? ` v${version}` : ""} — running (${client.getOllamaHost()})`);
+    // Show loaded models
+    try {
+        const ps = await client.getRunningModels();
+        if (ps.models && ps.models.length > 0) {
+            lines.push("");
+            lines.push("Loaded:");
+            for (const m of ps.models) {
+                const vram = m.size_vram > 0 ? formatModelSize(m.size_vram) + " VRAM" : "CPU";
+                const expiresAt = new Date(m.expires_at);
+                const idleMs = expiresAt.getTime() - Date.now();
+                const idleMin = Math.max(0, Math.floor(idleMs / 60000));
+                lines.push(`  ${m.name}  ${vram}  expires in ${idleMin}m`);
+            }
+        }
+    }
+    catch {
+        // ps endpoint may not be available on older versions
+    }
+    // Show available models
+    try {
+        const models = await discoverModels();
+        if (models.length > 0) {
+            lines.push("");
+            lines.push("Available:");
+            for (const m of models) {
+                lines.push(`  ${formatModelForDisplay(m)}`);
+            }
+        }
+        else {
+            lines.push("");
+            lines.push("No models pulled. Use /ollama pull <model> to get started.");
+        }
+    }
+    catch (err) {
+        lines.push("");
+        lines.push(`Error listing models: ${err instanceof Error ? err.message : String(err)}`);
+    }
+    await ctx.ui.custom((tui, theme, _kb, done) => {
+        const text = new Text(lines.map((l) => theme.fg("fg", l)).join("\n"), 0, 0);
+        setTimeout(() => done(undefined), 0);
+        return text;
+    });
+}
+async function handleList(ctx) {
+    const running = await client.isRunning();
+    if (!running) {
+        ctx.ui.notify("Ollama is not running", "warning");
+        return;
+    }
+    const models = await discoverModels();
+    if (models.length === 0) {
+        ctx.ui.notify("No models available. Use /ollama pull <model> to download one.", "info");
+        return;
+    }
+    const lines = ["Local Ollama models:", ""];
+    for (const m of models) {
+        lines.push(`  ${formatModelForDisplay(m)}`);
+    }
+    await ctx.ui.custom((tui, theme, _kb, done) => {
+        const text = new Text(lines.map((l) => theme.fg("fg", l)).join("\n"), 0, 0);
+        setTimeout(() => done(undefined), 0);
+        return text;
+    });
+}
+async function handlePull(modelName, ctx) {
+    if (!modelName) {
+        ctx.ui.notify("Usage: /ollama pull <model> (e.g. /ollama pull llama3.1:8b)", "warning");
+        return;
+    }
+    const running = await client.isRunning();
+    if (!running) {
+        ctx.ui.notify("Ollama is not running", "warning");
+        return;
+    }
+    ctx.ui.setWidget("ollama-pull", [`Pulling ${modelName}...`]);
+    try {
+        let lastPercent = -1;
+        await client.pullModel(modelName, (progress) => {
+            if (progress.total && progress.completed) {
+                const percent = Math.floor((progress.completed / progress.total) * 100);
+                if (percent !== lastPercent) {
+                    lastPercent = percent;
+                    const completed = formatModelSize(progress.completed);
+                    const total = formatModelSize(progress.total);
+                    ctx.ui.setWidget("ollama-pull", [
+                        `Pulling ${modelName}... ${percent}% (${completed} / ${total})`,
+                    ]);
+                }
+            }
+            else if (progress.status) {
+                ctx.ui.setWidget("ollama-pull", [`${modelName}: ${progress.status}`]);
+            }
+        });
+        ctx.ui.setWidget("ollama-pull", undefined);
+        ctx.ui.notify(`${modelName} pulled successfully`, "success");
+    }
+    catch (err) {
+        ctx.ui.setWidget("ollama-pull", undefined);
+        ctx.ui.notify(`Failed to pull ${modelName}: ${err instanceof Error ? err.message : String(err)}`, "error");
+    }
+}
+async function handleRemove(modelName, ctx) {
+    if (!modelName) {
+        ctx.ui.notify("Usage: /ollama remove <model>", "warning");
+        return;
+    }
+    const running = await client.isRunning();
+    if (!running) {
+        ctx.ui.notify("Ollama is not running", "warning");
+        return;
+    }
+    const confirmed = await ctx.ui.confirm("Delete model", `Are you sure you want to delete ${modelName}?`);
+    if (!confirmed)
+        return;
+    try {
+        await client.deleteModel(modelName);
+        ctx.ui.notify(`${modelName} deleted`, "success");
+    }
+    catch (err) {
+        ctx.ui.notify(`Failed to delete ${modelName}: ${err instanceof Error ? err.message : String(err)}`, "error");
+    }
+}
+async function handlePs(ctx) {
+    const running = await client.isRunning();
+    if (!running) {
+        ctx.ui.notify("Ollama is not running", "warning");
+        return;
+    }
+    try {
+        const ps = await client.getRunningModels();
+        if (!ps.models || ps.models.length === 0) {
+            ctx.ui.notify("No models currently loaded in memory", "info");
+            return;
+        }
+        const lines = ["Running models:", ""];
+        for (const m of ps.models) {
+            const vram = m.size_vram > 0 ? formatModelSize(m.size_vram) + " VRAM" : "CPU only";
+            const totalSize = formatModelSize(m.size);
+            const expiresAt = new Date(m.expires_at);
+            const idleMs = expiresAt.getTime() - Date.now();
+            const idleMin = Math.max(0, Math.floor(idleMs / 60000));
+            lines.push(`  ${m.name}  ${totalSize}  ${vram}  expires in ${idleMin}m`);
+        }
+        await ctx.ui.custom((tui, theme, _kb, done) => {
+            const text = new Text(lines.map((l) => theme.fg("fg", l)).join("\n"), 0, 0);
+            setTimeout(() => done(undefined), 0);
+            return text;
+        });
+    }
+    catch (err) {
+        ctx.ui.notify(`Failed to get running models: ${err instanceof Error ? err.message : String(err)}`, "error");
+    }
+}

package/dist/resources/extensions/ollama/ollama-discovery.js

@@ -0,0 +1,69 @@
+// GSD2 — Ollama model discovery and capability detection
+/**
+ * Discovers locally available Ollama models and enriches them with
+ * capability metadata (context window, vision, reasoning) from the
+ * known model table and /api/show responses.
+ *
+ * Returns models in the format expected by pi.registerProvider().
+ */
+import { listModels, getOllamaHost } from "./ollama-client.js";
+import { estimateContextFromParams, formatModelSize, getModelCapabilities, humanizeModelName, } from "./model-capabilities.js";
+const ZERO_COST = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 };
+function enrichModel(info) {
+    const caps = getModelCapabilities(info.name);
+    const parameterSize = info.details?.parameter_size ?? "";
+    // Determine context window: known table > estimate from param size > default
+    const contextWindow = caps.contextWindow ??
+        (parameterSize ? estimateContextFromParams(parameterSize) : 8192);
+    // Determine max tokens: known table > fraction of context > default
+    const maxTokens = caps.maxTokens ?? Math.min(Math.floor(contextWindow / 4), 16384);
+    // Detect vision from families or known table
+    const hasVision = caps.input?.includes("image") ??
+        (info.details?.families?.some((f) => f === "clip" || f === "mllama") ?? false);
+    // Detect reasoning from known table
+    const reasoning = caps.reasoning ?? false;
+    return {
+        id: info.name,
+        name: humanizeModelName(info.name),
+        reasoning,
+        input: hasVision ? ["text", "image"] : ["text"],
+        cost: ZERO_COST,
+        contextWindow,
+        maxTokens,
+        sizeBytes: info.size,
+        parameterSize,
+    };
+}
+/**
+ * Discover all locally available Ollama models with enriched capabilities.
+ */
+export async function discoverModels() {
+    const tags = await listModels();
+    if (!tags.models || tags.models.length === 0)
+        return [];
+    return tags.models.map(enrichModel);
+}
+/**
+ * Format a discovered model for display in model list.
+ */
+export function formatModelForDisplay(model) {
+    const parts = [model.id];
+    if (model.sizeBytes > 0) {
+        parts.push(`(${formatModelSize(model.sizeBytes)})`);
+    }
+    const flags = [];
+    if (model.reasoning)
+        flags.push("reasoning");
+    if (model.input.includes("image"))
+        flags.push("vision");
+    if (flags.length > 0) {
+        parts.push(`[${flags.join(", ")}]`);
+    }
+    return parts.join(" ");
+}
+/**
+ * Build the OpenAI-compat base URL for Ollama.
+ */
+export function getOllamaOpenAIBaseUrl() {
+    return `${getOllamaHost()}/v1`;
+}

package/dist/resources/extensions/ollama/ollama-tool.js

@@ -0,0 +1,184 @@
+// GSD2 — LLM-callable Ollama management tool
+/**
+ * Registers an ollama_manage tool that the LLM can call to interact
+ * with the local Ollama instance — list models, pull new ones, check status.
+ */
+import { Text } from "@gsd/pi-tui";
+import { Type } from "@sinclair/typebox";
+import * as client from "./ollama-client.js";
+import { discoverModels, formatModelForDisplay } from "./ollama-discovery.js";
+import { formatModelSize } from "./model-capabilities.js";
+export function registerOllamaTool(pi) {
+    pi.registerTool({
+        name: "ollama_manage",
+        label: "Ollama",
+        description: "Manage local Ollama models. List available models, pull new ones, " +
+            "check Ollama status, or see running models and resource usage. " +
+            "Use this when you need a specific local model that isn't available yet.",
+        promptSnippet: "Manage local Ollama models (list, pull, status, ps)",
+        promptGuidelines: [
+            "Use 'list' to see what models are available locally before trying to use one.",
+            "Use 'pull' to download a model that isn't available yet.",
+            "Use 'status' to check if Ollama is running.",
+            "Use 'ps' to see which models are loaded in memory and VRAM usage.",
+            "Common models: llama3.1:8b, qwen2.5-coder:7b, deepseek-r1:8b, codestral:22b",
+        ],
+        parameters: Type.Object({
+            action: Type.Union([
+                Type.Literal("list"),
+                Type.Literal("pull"),
+                Type.Literal("status"),
+                Type.Literal("ps"),
+            ], { description: "Action to perform" }),
+            model: Type.Optional(Type.String({ description: "Model name (required for pull)" })),
+        }),
+        async execute(_toolCallId, params, signal, onUpdate, _ctx) {
+            const startTime = Date.now();
+            const { action, model } = params;
+            try {
+                switch (action) {
+                    case "status": {
+                        const running = await client.isRunning();
+                        if (!running) {
+                            return {
+                                content: [{ type: "text", text: "Ollama is not running. It needs to be started with 'ollama serve'." }],
+                                details: { action, durationMs: Date.now() - startTime },
+                            };
+                        }
+                        const version = await client.getVersion();
+                        return {
+                            content: [{ type: "text", text: `Ollama${version ? ` v${version}` : ""} is running at ${client.getOllamaHost()}` }],
+                            details: { action, durationMs: Date.now() - startTime },
+                        };
+                    }
+                    case "list": {
+                        const running = await client.isRunning();
+                        if (!running) {
+                            return {
+                                content: [{ type: "text", text: "Ollama is not running." }],
+                                isError: true,
+                                details: { action, durationMs: Date.now() - startTime, error: "not_running" },
+                            };
+                        }
+                        const models = await discoverModels();
+                        if (models.length === 0) {
+                            return {
+                                content: [{ type: "text", text: "No models available. Pull one with action='pull'." }],
+                                details: { action, modelCount: 0, durationMs: Date.now() - startTime },
+                            };
+                        }
+                        const lines = models.map((m) => formatModelForDisplay(m));
+                        return {
+                            content: [{ type: "text", text: `Available models:\n${lines.join("\n")}` }],
+                            details: { action, modelCount: models.length, durationMs: Date.now() - startTime },
+                        };
+                    }
+                    case "pull": {
+                        if (!model) {
+                            return {
+                                content: [{ type: "text", text: "Error: 'model' parameter is required for pull action." }],
+                                isError: true,
+                                details: { action, durationMs: Date.now() - startTime, error: "missing_model" },
+                            };
+                        }
+                        const running = await client.isRunning();
+                        if (!running) {
+                            return {
+                                content: [{ type: "text", text: "Ollama is not running." }],
+                                isError: true,
+                                details: { action, model, durationMs: Date.now() - startTime, error: "not_running" },
+                            };
+                        }
+                        let lastStatus = "";
+                        await client.pullModel(model, (progress) => {
+                            if (progress.total && progress.completed) {
+                                const pct = Math.floor((progress.completed / progress.total) * 100);
+                                const status = `Pulling ${model}... ${pct}%`;
+                                if (status !== lastStatus) {
+                                    lastStatus = status;
+                                    onUpdate?.({ content: [{ type: "text", text: status }], details: { action, model, durationMs: Date.now() - startTime } });
+                                }
+                            }
+                            else if (progress.status && progress.status !== lastStatus) {
+                                lastStatus = progress.status;
+                                onUpdate?.({ content: [{ type: "text", text: `${model}: ${progress.status}` }], details: { action, model, durationMs: Date.now() - startTime } });
+                            }
+                        }, signal);
+                        return {
+                            content: [{ type: "text", text: `Successfully pulled ${model}` }],
+                            details: { action, model, durationMs: Date.now() - startTime },
+                        };
+                    }
+                    case "ps": {
+                        const running = await client.isRunning();
+                        if (!running) {
+                            return {
+                                content: [{ type: "text", text: "Ollama is not running." }],
+                                isError: true,
+                                details: { action, durationMs: Date.now() - startTime, error: "not_running" },
+                            };
+                        }
+                        const ps = await client.getRunningModels();
+                        if (!ps.models || ps.models.length === 0) {
+                            return {
+                                content: [{ type: "text", text: "No models currently loaded in memory." }],
+                                details: { action, modelCount: 0, durationMs: Date.now() - startTime },
+                            };
+                        }
+                        const lines = ps.models.map((m) => {
+                            const vram = m.size_vram > 0 ? `${formatModelSize(m.size_vram)} VRAM` : "CPU";
+                            return `${m.name} — ${formatModelSize(m.size)} total, ${vram}`;
+                        });
+                        return {
+                            content: [{ type: "text", text: `Loaded models:\n${lines.join("\n")}` }],
+                            details: { action, modelCount: ps.models.length, durationMs: Date.now() - startTime },
+                        };
+                    }
+                    default:
+                        return {
+                            content: [{ type: "text", text: `Unknown action: ${action}` }],
+                            isError: true,
+                            details: { action, durationMs: Date.now() - startTime, error: "unknown_action" },
+                        };
+                }
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                return {
+                    content: [{ type: "text", text: `Ollama error: ${msg}` }],
+                    isError: true,
+                    details: { action, model, durationMs: Date.now() - startTime, error: msg },
+                };
+            }
+        },
+        renderCall(args, theme) {
+            let text = theme.fg("toolTitle", theme.bold("ollama "));
+            text += theme.fg("accent", args.action);
+            if (args.model) {
+                text += theme.fg("dim", ` ${args.model}`);
+            }
+            return new Text(text, 0, 0);
+        },
+        renderResult(result, { isPartial, expanded }, theme) {
+            const d = result.details;
+            if (isPartial)
+                return new Text(theme.fg("warning", "Working..."), 0, 0);
+            if (result.isError || d?.error) {
+                return new Text(theme.fg("error", `Error: ${d?.error ?? "unknown"}`), 0, 0);
+            }
+            let text = theme.fg("success", d?.action ?? "done");
+            if (d?.modelCount !== undefined) {
+                text += theme.fg("dim", ` (${d.modelCount} models)`);
+            }
+            text += theme.fg("dim", ` ${d?.durationMs ?? 0}ms`);
+            if (expanded) {
+                const content = result.content[0];
+                if (content?.type === "text") {
+                    const preview = content.text.split("\n").slice(0, 10).join("\n");
+                    text += "\n\n" + theme.fg("dim", preview);
+                }
+            }
+            return new Text(text, 0, 0);
+        },
+    });
+}

package/dist/resources/extensions/ollama/types.js

@@ -0,0 +1,2 @@
+// GSD2 — Ollama API response types
+export {};

package/dist/resources/extensions/search-the-web/extension-manifest.json

@@ -8,6 +8,6 @@
   "provides": {
     "tools": ["search-the-web", "fetch_page", "search_and_read", "web_search"],
     "commands": ["search-provider"],
-    "hooks": ["model_select", "before_provider_request"]
+    "hooks": ["session_start", "model_select", "before_provider_request"]
   }
 }

package/dist/resources/extensions/shared/interview-ui.js

@@ -28,7 +28,7 @@ import { Editor, Key, matchesKey, truncateToWidth, } from "@gsd/pi-tui";
 import { makeUI, INDENT } from "./ui.js";
 // ─── Constants ────────────────────────────────────────────────────────────────
 const OTHER_OPTION_LABEL = "None of the above";
-const OTHER_OPTION_DESCRIPTION = "Press TAB to add optional notes.";
+const OTHER_OPTION_DESCRIPTION = "Select to type your own answer.";
 // ─── Wrap-up screen ───────────────────────────────────────────────────────────
 export async function showWrapUpScreen(opts, ctx) {
     return ctx.ui.custom((tui, theme, _kb, done) => {
@@ -199,6 +199,16 @@ export async function showInterviewRound(questions, opts, ctx) {
             if (!isMultiSelect(currentIdx)) {
                 states[currentIdx].committedIndex = states[currentIdx].cursorIndex;
             }
+            // Auto-open the notes field when "None of the above" is selected
+            // so the user can immediately provide a free-text explanation
+            // instead of being trapped in a re-asking loop (bug #2715).
+            if (!isMultiSelect(currentIdx) && states[currentIdx].cursorIndex === noneOrDoneIdx(currentIdx)) {
+                states[currentIdx].notesVisible = true;
+                focusNotes = true;
+                loadStateToEditor();
+                refresh();
+                return;
+            }
             if (isMultiQuestion && currentIdx < questions.length - 1) {
                 let next = currentIdx + 1;
                 for (let i = 0; i < questions.length; i++) {

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

@@ -7,9 +7,11 @@ description: Create, debug, and iterate on GSD extensions (TypeScript modules th
 
 **Extensions are TypeScript modules** that hook into GSD's runtime (built on pi). They export a default function receiving `ExtensionAPI` and use it to subscribe to events, register tools/commands/shortcuts, and interact with the session.
 
-**GSD extension paths:**
-- Global extensions: `~/.gsd/agent/extensions/*.ts` or `~/.gsd/agent/extensions/*/index.ts`
-- Project-local extensions: `.gsd/extensions/*.ts` or `.gsd/extensions/*/index.ts`
+**GSD extension paths (community/user-installed extensions):**
+- Global: `~/.pi/agent/extensions/*.ts` or `~/.pi/agent/extensions/*/index.ts`
+- Project-local: `.gsd/extensions/*.ts` or `.gsd/extensions/*/index.ts`
+
+Note: `~/.gsd/agent/extensions/` is reserved for bundled extensions synced from the gsd-pi package. Community extensions placed there are silently ignored by the loader.
 
 **The three primitives:**
 1. **Events** — Listen and react (`pi.on("event", handler)`). Can block tool calls, modify messages, inject context.

package/dist/resources/skills/create-gsd-extension/references/key-rules-gotchas.md

@@ -26,11 +26,12 @@ Non-negotiable rules and common gotchas when building GSD extensions.
 </common_patterns>
 
 <gsd_paths>
-**GSD extension paths:**
-- Global: `~/.gsd/agent/extensions/*.ts`
-- Global (subdir): `~/.gsd/agent/extensions/*/index.ts`
+**GSD extension paths (community/user-installed extensions):**
+- Global: `~/.pi/agent/extensions/*.ts`
+- Global (subdir): `~/.pi/agent/extensions/*/index.ts`
 - Project-local: `.gsd/extensions/*.ts`
 - Project-local (subdir): `.gsd/extensions/*/index.ts`
 
-The upstream pi docs reference `~/.pi` paths — GSD uses `~/.gsd` everywhere instead.
+Note: `~/.gsd/agent/extensions/` is reserved for bundled extensions synced from the gsd-pi package.
+Community extensions placed there are silently ignored by the loader.
 </gsd_paths>

package/dist/resources/skills/create-gsd-extension/workflows/add-capability.md

@@ -14,7 +14,7 @@ Read the reference file for the specific capability being added:
 ## Step 1: Identify the Extension
 
 Locate the existing extension file. Check:
-- `~/.gsd/agent/extensions/` (global)
+- `~/.pi/agent/extensions/` (global community extensions)
 - `.gsd/extensions/` (project-local)
 
 Read the current extension code to understand its structure.
@@ -28,7 +28,7 @@ If the extension needs new imports, add them at the top of the file.
 ## Step 3: Handle Structural Changes
 
 **Single file → Directory**: If the extension is outgrowing a single file:
-1. Create `~/.gsd/agent/extensions/my-extension/`
+1. Create `~/.pi/agent/extensions/my-extension/`
 2. Move the file to `index.ts`
 3. Extract helpers to separate files
 

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

@@ -12,7 +12,7 @@
 ## Step 1: Determine Scope and Placement
 
 Ask the user:
-- **Global** (`~/.gsd/agent/extensions/`) — Available in all GSD sessions
+- **Global** (`~/.pi/agent/extensions/`) — Available in all GSD sessions
 - **Project-local** (`.gsd/extensions/`) — Available only in this project
 
 ## Step 2: Determine Extension Capabilities
@@ -36,12 +36,12 @@ Identify what the extension needs from the user's description:
 
 **Single file** — for small extensions (1-2 tools/commands, simple hooks):
 ```
-~/.gsd/agent/extensions/my-extension.ts
+~/.pi/agent/extensions/my-extension.ts
 ```
 
 **Directory with index.ts** — for multi-file extensions:
 ```
-~/.gsd/agent/extensions/my-extension/
+~/.pi/agent/extensions/my-extension/
 ├── index.ts
 ├── tools.ts
 └── utils.ts
@@ -49,7 +49,7 @@ Identify what the extension needs from the user's description:
 
 **Package with dependencies** — when npm packages are needed:
 ```
-~/.gsd/agent/extensions/my-extension/
+~/.pi/agent/extensions/my-extension/
 ├── package.json
 ├── src/index.ts
 └── node_modules/

package/dist/resources/skills/create-gsd-extension/workflows/debug-extension.md

@@ -32,12 +32,14 @@ gsd -e ./path/to/extension.ts
 
 ## Step 3: Verify File Location
 
-Extensions must be in auto-discovery paths:
-- `~/.gsd/agent/extensions/*.ts`
-- `~/.gsd/agent/extensions/*/index.ts`
+Community extensions must be in auto-discovery paths:
+- `~/.pi/agent/extensions/*.ts`
+- `~/.pi/agent/extensions/*/index.ts`
 - `.gsd/extensions/*.ts`
 - `.gsd/extensions/*/index.ts`
 
+Note: `~/.gsd/agent/extensions/` is reserved for bundled extensions synced from the gsd-pi package.
+
 The file must `export default function(pi: ExtensionAPI) { ... }`.
 
 ## Step 4: Check for Common Mistakes

package/dist/startup-model-validation.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Startup model validation — extracted from cli.ts so it can be called
+ * AFTER extensions register their models in the ModelRegistry.
+ *
+ * Before this extraction (bug #2626), the validation ran before
+ * createAgentSession(), meaning extension-provided models (e.g.
+ * claude-code/claude-sonnet-4-6) were not yet in the registry.
+ * configuredExists was always false for extension models, causing the
+ * user's valid choice to be silently overwritten with a built-in fallback.
+ */
+interface MinimalModel {
+    provider: string;
+    id: string;
+}
+interface MinimalModelRegistry {
+    getAll(): MinimalModel[];
+    getAvailable(): MinimalModel[];
+}
+type ThinkingLevel = 'off' | 'minimal' | 'low' | 'medium' | 'high' | 'xhigh';
+interface MinimalSettingsManager {
+    getDefaultProvider(): string | undefined;
+    getDefaultModel(): string | undefined;
+    getDefaultThinkingLevel(): ThinkingLevel | undefined;
+    setDefaultModelAndProvider(provider: string, modelId: string): void;
+    setDefaultThinkingLevel(level: ThinkingLevel): void;
+}
+/**
+ * Validate the configured default model against the registry.
+ *
+ * If the configured model exists in the registry, this is a no-op — the
+ * user's choice is preserved.  If it does not exist (stale settings from a
+ * prior install, or genuinely removed model), a fallback is selected and
+ * written to settings.
+ *
+ * IMPORTANT: Call this AFTER createAgentSession() so that extension-
+ * provided models have been registered in the ModelRegistry.
+ */
+export declare function validateConfiguredModel(modelRegistry: MinimalModelRegistry, settingsManager: MinimalSettingsManager): void;
+export {};