gsd-pi 2.57.0 → 2.58.0-dev.778d6ac

package/dist/resources/extensions/gsd/workspace-index.js

@@ -3,6 +3,7 @@ import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveTaskFile, resolveTasksDir, } from "./paths.js";
 import { deriveState } from "./state.js";
+import { extractVerdict } from "./verdict-parser.js";
 import { findMilestoneIds } from "./guided-flow.js";
 import { getSliceBranchName, detectWorktreeName } from "./worktree.js";
 // Extract milestone title from roadmap header without using parsers.
@@ -116,6 +117,29 @@ export async function indexWorkspace(basePath, opts = {}) {
         taskId: state.activeTask?.id,
         phase: state.phase,
     };
+    // Enrich milestones with authoritative status from state registry (#2807)
+    if (state.registry) {
+        const registryMap = new Map(state.registry.map(e => [e.id, e]));
+        for (const milestone of milestones) {
+            const entry = registryMap.get(milestone.id);
+            if (entry) {
+                milestone.status = entry.status;
+            }
+        }
+    }
+    // Populate validationVerdict from VALIDATION files (#2807)
+    for (const milestone of milestones) {
+        const validationPath = resolveMilestoneFile(basePath, milestone.id, "VALIDATION");
+        if (validationPath) {
+            const validationContent = await loadFile(validationPath);
+            if (validationContent) {
+                const verdict = extractVerdict(validationContent);
+                if (verdict === "pass" || verdict === "needs-attention" || verdict === "needs-remediation") {
+                    milestone.validationVerdict = verdict;
+                }
+            }
+        }
+    }
     const scopes = [{ scope: "project", label: "project", kind: "project" }];
     for (const milestone of milestones) {
         scopes.push({ scope: milestone.id, label: `${milestone.id}: ${milestone.title}`, kind: "milestone" });

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

@@ -14,7 +14,7 @@
  *   3. merge()   — LLM-guided reconciliation of .gsd/ artifacts back to main
  *   4. remove()  — git worktree remove + branch cleanup
  */
-import { existsSync, mkdirSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { join, resolve, sep } from "node:path";
 import { GSDError, GSD_PARSE_ERROR, GSD_STALE_STATE, GSD_LOCK_HELD, GSD_GIT_ERROR, GSD_MERGE_CONFLICT } from "./errors.js";
@@ -203,6 +203,73 @@ export function listWorktrees(basePath) {
     }
     return worktrees;
 }
+// ─── Nested .git Detection (#2616) ──────────────────────────────────────
+//
+// Scaffolding tools (create-next-app, cargo init, etc.) create nested .git
+// directories inside worktrees. Git records these as gitlinks (mode 160000)
+// without a .gitmodules entry — so worktree cleanup destroys the only copy
+// of their object database, causing permanent silent data loss.
+/** Directories to skip when scanning for nested .git dirs. */
+const NESTED_GIT_SKIP_DIRS = new Set([
+    ".git", ".gsd", "node_modules", ".next", ".nuxt", "dist", "build",
+    "__pycache__", ".tox", ".venv", "venv", "target", "vendor",
+]);
+/**
+ * Recursively find nested .git directories inside a worktree root.
+ * Returns paths to directories that contain their own .git (directory, not file).
+ * Skips node_modules, .gsd, and other non-project directories for performance.
+ *
+ * A nested .git *directory* (not a .git file — which is a legitimate worktree
+ * pointer) indicates a scaffolded repo that will become an orphaned gitlink.
+ */
+export function findNestedGitDirs(rootPath) {
+    const results = [];
+    function walk(dir, depth) {
+        // Cap recursion depth to avoid runaway scanning
+        if (depth > 10)
+            return;
+        let entries;
+        try {
+            entries = readdirSync(dir);
+        }
+        catch {
+            return; // Permission denied, broken symlink, etc.
+        }
+        for (const entry of entries) {
+            if (NESTED_GIT_SKIP_DIRS.has(entry))
+                continue;
+            const fullPath = join(dir, entry);
+            // Only follow real directories, not symlinks
+            let stat;
+            try {
+                stat = lstatSync(fullPath);
+            }
+            catch {
+                continue;
+            }
+            if (!stat.isDirectory())
+                continue;
+            // Check if this directory contains a .git *directory* (not a .git file).
+            // A .git file is a worktree pointer and is legitimate.
+            // A .git directory is a standalone repo created by scaffolding.
+            const innerGit = join(fullPath, ".git");
+            try {
+                const innerStat = lstatSync(innerGit);
+                if (innerStat.isDirectory()) {
+                    results.push(fullPath);
+                    // Don't recurse into the nested repo — we found what we need
+                    continue;
+                }
+            }
+            catch {
+                // No .git here — continue scanning
+            }
+            walk(fullPath, depth + 1);
+        }
+    }
+    walk(rootPath, 0);
+    return results;
+}
 /**
  * Remove a worktree and optionally delete its branch.
  * If the process is currently inside the worktree, chdir out first.
@@ -269,6 +336,24 @@ export function removeWorktree(basePath, name, opts = {}) {
             // submodule status failed — proceed with normal removal
         }
     }
+    // Nested .git safety (#2616): detect nested .git directories created by
+    // scaffolding tools (create-next-app, cargo init, etc.). These produce
+    // gitlink entries (mode 160000) without .gitmodules — cleanup would destroy
+    // the only copy of the nested object database, causing permanent data loss.
+    // Fix: remove the nested .git dirs so git tracks the files as regular content.
+    const nestedGitDirs = findNestedGitDirs(resolvedWtPath);
+    if (nestedGitDirs.length > 0) {
+        for (const nestedDir of nestedGitDirs) {
+            const nestedGitPath = join(nestedDir, ".git");
+            try {
+                rmSync(nestedGitPath, { recursive: true, force: true });
+                logWarning("reconcile", `Removed nested .git directory from scaffolded project to prevent data loss (#2616)`, { worktree: name, nestedRepo: nestedDir });
+            }
+            catch {
+                logWarning("reconcile", `Failed to remove nested .git directory — files may be lost as orphaned gitlink`, { worktree: name, nestedRepo: nestedDir });
+            }
+        }
+    }
     // Remove worktree: try non-force first when submodules have changes,
     // falling back to force only after submodule state has been preserved.
     const useForce = hasSubmoduleChanges ? false : force;
@@ -283,6 +368,25 @@ export function removeWorktree(basePath, name, opts = {}) {
         }
         catch { /* may fail */ }
     }
+    // (#2821) If the worktree directory STILL exists after both native removal
+    // attempts (e.g. untracked files like ASSESSMENT/UAT-RESULT prevent git
+    // worktree remove), force-remove the git internal worktree metadata first,
+    // then remove the filesystem directory. Without this, the .git/worktrees/<name>
+    // lock prevents rmSync from cleaning up, and the orphaned worktree directory
+    // causes every subsequent `/gsd auto` to re-enter the stale worktree.
+    if (existsSync(resolvedWtPath)) {
+        try {
+            const wtInternalDir = join(basePath, ".git", "worktrees", name);
+            if (existsSync(wtInternalDir)) {
+                rmSync(wtInternalDir, { recursive: true, force: true });
+            }
+            rmSync(resolvedWtPath, { recursive: true, force: true });
+        }
+        catch {
+            logWarning("reconcile", `Worktree directory could not be removed after git internal cleanup: ${resolvedWtPath}. ` +
+                `Manual cleanup: rm -rf "${resolvedWtPath.replaceAll("\\", "/")}"`, { worktree: name });
+        }
+    }
     // Prune stale entries so git knows the worktree is gone
     nativeWorktreePrune(basePath);
     if (deleteBranch) {

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

@@ -248,7 +248,12 @@ export class WorktreeResolver {
             eventType: "worktree-merge-start",
             data: { milestoneId, mode },
         });
-        if (mode === "none") {
+        // #2625: If we are physically inside an auto-worktree, we MUST merge
+        // regardless of the current isolation config. This prevents data loss when
+        // the default isolation mode changes between versions (e.g., "worktree" ->
+        // "none"): the worktree branch still holds real commits that need merging.
+        const inWorktree = this.deps.isInAutoWorktree(this.s.basePath) && this.s.originalBasePath;
+        if (mode === "none" && !inWorktree) {
             debugLog("WorktreeResolver", {
                 action: "mergeAndExit",
                 milestoneId,
@@ -257,8 +262,7 @@ export class WorktreeResolver {
             });
             return;
         }
-        if (mode === "worktree" ||
-            (this.deps.isInAutoWorktree(this.s.basePath) && this.s.originalBasePath)) {
+        if (mode === "worktree" || inWorktree) {
             this._mergeWorktreeMode(milestoneId, ctx);
         }
         else if (mode === "branch") {
@@ -308,6 +312,19 @@ export class WorktreeResolver {
             if (roadmapPath) {
                 const roadmapContent = this.deps.readFileSync(roadmapPath, "utf-8");
                 const mergeResult = this.deps.mergeMilestoneToMain(originalBase, milestoneId, roadmapContent);
+                // #2945 Bug 3: mergeMilestoneToMain performs best-effort worktree
+                // cleanup internally (step 12), but it can silently fail on Windows
+                // or when the worktree directory is locked. Perform a secondary
+                // teardown here to ensure the worktree is properly cleaned up.
+                // This is idempotent — if the worktree was already removed,
+                // teardownAutoWorktree handles the no-op case gracefully.
+                try {
+                    this.deps.teardownAutoWorktree(originalBase, milestoneId);
+                }
+                catch {
+                    // Best-effort — the primary cleanup in mergeMilestoneToMain may
+                    // have already removed the worktree.
+                }
                 if (mergeResult.codeFilesChanged) {
                     ctx.notify(`Milestone ${milestoneId} merged to main.${mergeResult.pushed ? " Pushed to remote." : ""}`, "info");
                 }

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

@@ -74,7 +74,9 @@ function readConfigs() {
     return servers;
 }
 function getServerConfig(name) {
-    return readConfigs().find((s) => s.name === name);
+    const trimmed = name.trim();
+    return readConfigs().find((s) => s.name === trimmed ||
+        s.name.toLowerCase() === trimmed.toLowerCase());
 }
 /** Resolve ${VAR} references in env values against process.env. */
 function resolveEnv(env) {
@@ -90,12 +92,14 @@ function resolveEnv(env) {
     return resolved;
 }
 async function getOrConnect(name, signal) {
-    const existing = connections.get(name);
-    if (existing)
-        return existing.client;
     const config = getServerConfig(name);
     if (!config)
         throw new Error(`Unknown MCP server: "${name}". Use mcp_servers to list available servers.`);
+    // Always use config.name as the canonical cache key so that variant
+    // casing / whitespace still hits the same connection.
+    const existing = connections.get(config.name);
+    if (existing)
+        return existing.client;
     const client = new Client({ name: "gsd", version: "1.0.0" });
     let transport;
     if (config.transport === "stdio" && config.command) {
@@ -108,14 +112,14 @@ async function getOrConnect(name, signal) {
         });
     }
     else if (config.transport === "http" && config.url) {
-        const resolvedUrl = config.url.replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] ?? "");
+        const resolvedUrl = config.url.replace(/\$\{([^}]+)\}/g, (_, varName) => process.env[varName] ?? "");
         transport = new StreamableHTTPClientTransport(new URL(resolvedUrl));
     }
     else {
-        throw new Error(`Server "${name}" has unsupported transport: ${config.transport}`);
+        throw new Error(`Server "${config.name}" has unsupported transport: ${config.transport}`);
     }
     await client.connect(transport, { signal, timeout: 30000 });
-    connections.set(name, { client, transport });
+    connections.set(config.name, { client, transport });
     return client;
 }
 async function closeAll() {

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

@@ -0,0 +1,112 @@
+// GSD2 — Ollama Extension: First-class local LLM support
+/**
+ * Ollama Extension
+ *
+ * Auto-detects a running Ollama instance, discovers locally pulled models,
+ * and registers them as a first-class provider. No configuration required —
+ * if Ollama is running, models appear automatically.
+ *
+ * Features:
+ * - Auto-discovery of local models via /api/tags
+ * - Capability detection (vision, reasoning, context window)
+ * - /ollama slash commands for model management
+ * - ollama_manage tool for LLM-driven model operations
+ * - Zero-cost model registration (local inference)
+ *
+ * Respects OLLAMA_HOST env var for non-default endpoints.
+ */
+import { importExtensionModule } from "@gsd/pi-coding-agent";
+import * as client from "./ollama-client.js";
+import { discoverModels, getOllamaOpenAIBaseUrl } from "./ollama-discovery.js";
+import { registerOllamaCommands } from "./ollama-commands.js";
+/** Default compat settings for Ollama models via OpenAI-compat endpoint */
+const OLLAMA_COMPAT = {
+    supportsDeveloperRole: false,
+    supportsReasoningEffort: false,
+    supportsUsageInStreaming: false,
+    maxTokensField: "max_tokens",
+    supportsStore: false,
+};
+let toolsPromise = null;
+async function registerOllamaTools(pi) {
+    if (!toolsPromise) {
+        toolsPromise = (async () => {
+            const { registerOllamaTool } = await importExtensionModule(import.meta.url, "./ollama-tool.js");
+            registerOllamaTool(pi);
+        })().catch((error) => {
+            toolsPromise = null;
+            throw error;
+        });
+    }
+    return toolsPromise;
+}
+/** Track whether we've registered models so we can clean up on shutdown */
+let providerRegistered = false;
+/**
+ * Probe Ollama and register discovered models.
+ * Safe to call multiple times — re-discovers and re-registers.
+ */
+async function probeAndRegister(pi) {
+    const running = await client.isRunning();
+    if (!running) {
+        if (providerRegistered) {
+            pi.unregisterProvider("ollama");
+            providerRegistered = false;
+        }
+        return false;
+    }
+    const models = await discoverModels();
+    if (models.length === 0)
+        return true; // Running but no models pulled
+    const baseUrl = getOllamaOpenAIBaseUrl();
+    pi.registerProvider("ollama", {
+        authMode: "none",
+        baseUrl,
+        api: "openai-completions",
+        isReady: () => true,
+        models: models.map((m) => ({
+            id: m.id,
+            name: m.name,
+            reasoning: m.reasoning,
+            input: m.input,
+            cost: m.cost,
+            contextWindow: m.contextWindow,
+            maxTokens: m.maxTokens,
+            compat: OLLAMA_COMPAT,
+        })),
+    });
+    providerRegistered = true;
+    return true;
+}
+export default function ollama(pi) {
+    // Register slash commands immediately (they check Ollama availability themselves)
+    registerOllamaCommands(pi);
+    pi.on("session_start", async (_event, ctx) => {
+        // Register tool (deferred to avoid blocking startup)
+        if (ctx.hasUI) {
+            void registerOllamaTools(pi).catch((error) => {
+                ctx.ui.notify(`Ollama tool failed to load: ${error instanceof Error ? error.message : String(error)}`, "warning");
+            });
+        }
+        else {
+            await registerOllamaTools(pi);
+        }
+        // Async probe — don't block startup
+        probeAndRegister(pi)
+            .then((found) => {
+            if (found && ctx.hasUI) {
+                ctx.ui.setStatus("ollama", "Ollama");
+            }
+        })
+            .catch(() => {
+            // Silently ignore probe failures
+        });
+    });
+    pi.on("session_shutdown", async () => {
+        if (providerRegistered) {
+            pi.unregisterProvider("ollama");
+            providerRegistered = false;
+        }
+        toolsPromise = null;
+    });
+}

package/dist/resources/extensions/ollama/model-capabilities.js

@@ -0,0 +1,115 @@
+// GSD2 — Known model capability table for Ollama models
+/**
+ * Known model family capabilities.
+ * Keys are matched as prefixes against the model name (before the colon/tag).
+ * More specific entries should appear first.
+ */
+const KNOWN_MODELS = [
+    // ─── Reasoning models ───────────────────────────────────────────────
+    ["deepseek-r1", { contextWindow: 131072, reasoning: true }],
+    ["qwq", { contextWindow: 131072, reasoning: true }],
+    // ─── Vision models ──────────────────────────────────────────────────
+    ["llava", { contextWindow: 4096, input: ["text", "image"] }],
+    ["bakllava", { contextWindow: 4096, input: ["text", "image"] }],
+    ["moondream", { contextWindow: 8192, input: ["text", "image"] }],
+    ["llama3.2-vision", { contextWindow: 131072, input: ["text", "image"] }],
+    ["minicpm-v", { contextWindow: 4096, input: ["text", "image"] }],
+    // ─── Code models ────────────────────────────────────────────────────
+    ["codestral", { contextWindow: 262144, maxTokens: 32768 }],
+    ["qwen2.5-coder", { contextWindow: 131072, maxTokens: 32768 }],
+    ["deepseek-coder-v2", { contextWindow: 131072, maxTokens: 16384 }],
+    ["starcoder2", { contextWindow: 16384, maxTokens: 8192 }],
+    ["codegemma", { contextWindow: 8192, maxTokens: 8192 }],
+    ["codellama", { contextWindow: 16384, maxTokens: 8192 }],
+    ["devstral", { contextWindow: 131072, maxTokens: 32768 }],
+    // ─── Llama family ───────────────────────────────────────────────────
+    ["llama3.3", { contextWindow: 131072, maxTokens: 16384 }],
+    ["llama3.2", { contextWindow: 131072, maxTokens: 16384 }],
+    ["llama3.1", { contextWindow: 131072, maxTokens: 16384 }],
+    ["llama3", { contextWindow: 8192, maxTokens: 8192 }],
+    ["llama2", { contextWindow: 4096, maxTokens: 4096 }],
+    // ─── Qwen family ────────────────────────────────────────────────────
+    ["qwen3", { contextWindow: 131072, maxTokens: 32768 }],
+    ["qwen2.5", { contextWindow: 131072, maxTokens: 32768 }],
+    ["qwen2", { contextWindow: 131072, maxTokens: 32768 }],
+    // ─── Gemma family ───────────────────────────────────────────────────
+    ["gemma3", { contextWindow: 131072, maxTokens: 16384 }],
+    ["gemma2", { contextWindow: 8192, maxTokens: 8192 }],
+    // ─── Mistral family ─────────────────────────────────────────────────
+    ["mistral-large", { contextWindow: 131072, maxTokens: 16384 }],
+    ["mistral-small", { contextWindow: 131072, maxTokens: 16384 }],
+    ["mistral-nemo", { contextWindow: 131072, maxTokens: 16384 }],
+    ["mistral", { contextWindow: 32768, maxTokens: 8192 }],
+    ["mixtral", { contextWindow: 32768, maxTokens: 8192 }],
+    // ─── Phi family ─────────────────────────────────────────────────────
+    ["phi4", { contextWindow: 16384, maxTokens: 16384 }],
+    ["phi3.5", { contextWindow: 131072, maxTokens: 16384 }],
+    ["phi3", { contextWindow: 131072, maxTokens: 4096 }],
+    // ─── Command R ──────────────────────────────────────────────────────
+    ["command-r-plus", { contextWindow: 131072, maxTokens: 16384 }],
+    ["command-r", { contextWindow: 131072, maxTokens: 16384 }],
+];
+/**
+ * Look up capabilities for a model by name.
+ * Matches the longest prefix from the known models table.
+ */
+export function getModelCapabilities(modelName) {
+    // Strip tag (everything after the colon) for matching
+    const baseName = modelName.split(":")[0].toLowerCase();
+    for (const [pattern, caps] of KNOWN_MODELS) {
+        if (baseName === pattern || baseName.startsWith(pattern)) {
+            return caps;
+        }
+    }
+    return {};
+}
+/**
+ * Estimate context window from parameter size string (e.g. "7B", "70B", "1.5B").
+ * Used as fallback when model isn't in the known table.
+ */
+export function estimateContextFromParams(parameterSize) {
+    const match = parameterSize.match(/([\d.]+)\s*([BbMm])/);
+    if (!match)
+        return 8192;
+    const size = parseFloat(match[1]);
+    const unit = match[2].toUpperCase();
+    // Convert to billions
+    const billions = unit === "M" ? size / 1000 : size;
+    // Rough heuristics: larger models tend to support larger contexts
+    if (billions >= 70)
+        return 131072;
+    if (billions >= 30)
+        return 65536;
+    if (billions >= 13)
+        return 32768;
+    if (billions >= 7)
+        return 16384;
+    return 8192;
+}
+/**
+ * Humanize a model name for display (e.g. "llama3.1:8b" → "Llama 3.1 8B").
+ */
+export function humanizeModelName(modelName) {
+    const [base, tag] = modelName.split(":");
+    // Capitalize first letter, add spaces around version numbers
+    let name = base
+        .replace(/([a-z])(\d)/g, "$1 $2")
+        .replace(/(\d)([a-z])/g, "$1 $2")
+        .replace(/^./, (c) => c.toUpperCase());
+    // Clean up common patterns
+    name = name.replace(/\s*-\s*/g, " ");
+    if (tag && tag !== "latest") {
+        name += ` ${tag.toUpperCase()}`;
+    }
+    return name;
+}
+/**
+ * Format byte size for display (e.g. 4700000000 → "4.7 GB").
+ */
+export function formatModelSize(bytes) {
+    if (bytes >= 1e9)
+        return `${(bytes / 1e9).toFixed(1)} GB`;
+    if (bytes >= 1e6)
+        return `${(bytes / 1e6).toFixed(1)} MB`;
+    return `${(bytes / 1e3).toFixed(0)} KB`;
+}

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

@@ -0,0 +1,168 @@
+// GSD2 — HTTP client for Ollama REST API
+const DEFAULT_HOST = "http://localhost:11434";
+const PROBE_TIMEOUT_MS = 1500;
+const REQUEST_TIMEOUT_MS = 10000;
+/**
+ * Get the Ollama host URL from OLLAMA_HOST or default.
+ */
+export function getOllamaHost() {
+    const host = process.env.OLLAMA_HOST;
+    if (!host)
+        return DEFAULT_HOST;
+    // OLLAMA_HOST can be just a host:port without scheme
+    if (host.startsWith("http://") || host.startsWith("https://"))
+        return host;
+    return `http://${host}`;
+}
+async function fetchWithTimeout(url, options = {}, timeoutMs = REQUEST_TIMEOUT_MS) {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        return await fetch(url, { ...options, signal: controller.signal });
+    }
+    finally {
+        clearTimeout(timeout);
+    }
+}
+/**
+ * Check if Ollama is running and reachable.
+ */
+export async function isRunning() {
+    try {
+        const response = await fetchWithTimeout(`${getOllamaHost()}/`, {}, PROBE_TIMEOUT_MS);
+        return response.ok;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Get Ollama version.
+ */
+export async function getVersion() {
+    try {
+        const response = await fetchWithTimeout(`${getOllamaHost()}/api/version`);
+        if (!response.ok)
+            return null;
+        const data = (await response.json());
+        return data.version;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * List all locally available models.
+ */
+export async function listModels() {
+    const response = await fetchWithTimeout(`${getOllamaHost()}/api/tags`);
+    if (!response.ok) {
+        throw new Error(`Ollama /api/tags returned ${response.status}: ${response.statusText}`);
+    }
+    return (await response.json());
+}
+/**
+ * Get detailed information about a specific model.
+ */
+export async function showModel(name) {
+    const response = await fetchWithTimeout(`${getOllamaHost()}/api/show`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name }),
+    });
+    if (!response.ok) {
+        throw new Error(`Ollama /api/show returned ${response.status}: ${response.statusText}`);
+    }
+    return (await response.json());
+}
+/**
+ * List currently loaded/running models.
+ */
+export async function getRunningModels() {
+    const response = await fetchWithTimeout(`${getOllamaHost()}/api/ps`);
+    if (!response.ok) {
+        throw new Error(`Ollama /api/ps returned ${response.status}: ${response.statusText}`);
+    }
+    return (await response.json());
+}
+/**
+ * Pull a model with streaming progress.
+ * Calls onProgress for each progress update.
+ * Returns when the pull is complete.
+ */
+export async function pullModel(name, onProgress, signal) {
+    const response = await fetch(`${getOllamaHost()}/api/pull`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name, stream: true }),
+        signal,
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Ollama /api/pull returned ${response.status}: ${text}`);
+    }
+    if (!response.body) {
+        throw new Error("Ollama /api/pull returned no body");
+    }
+    const reader = response.body.getReader();
+    const decoder = new TextDecoder();
+    let buffer = "";
+    while (true) {
+        const { done, value } = await reader.read();
+        if (done)
+            break;
+        buffer += decoder.decode(value, { stream: true });
+        const lines = buffer.split("\n");
+        buffer = lines.pop() ?? "";
+        for (const line of lines) {
+            const trimmed = line.trim();
+            if (!trimmed)
+                continue;
+            try {
+                const progress = JSON.parse(trimmed);
+                onProgress?.(progress);
+            }
+            catch {
+                // Skip malformed lines
+            }
+        }
+    }
+    // Process remaining buffer
+    if (buffer.trim()) {
+        try {
+            const progress = JSON.parse(buffer.trim());
+            onProgress?.(progress);
+        }
+        catch {
+            // Ignore
+        }
+    }
+}
+/**
+ * Delete a local model.
+ */
+export async function deleteModel(name) {
+    const response = await fetchWithTimeout(`${getOllamaHost()}/api/delete`, {
+        method: "DELETE",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ name }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Ollama /api/delete returned ${response.status}: ${text}`);
+    }
+}
+/**
+ * Copy a model to a new name.
+ */
+export async function copyModel(source, destination) {
+    const response = await fetchWithTimeout(`${getOllamaHost()}/api/copy`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ source, destination }),
+    });
+    if (!response.ok) {
+        const text = await response.text();
+        throw new Error(`Ollama /api/copy returned ${response.status}: ${text}`);
+    }
+}