gsd-pi 2.58.0 → 2.59.0-dev.023bd39

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -1,7 +1,7 @@
 // GSD Extension — Projection Renderers (DB -> Markdown)
 // Renders PLAN.md, ROADMAP.md, SUMMARY.md, and STATE.md from database rows.
 // Projections are read-only views of engine state (Layer 3 of the architecture).
-import { _getAdapter, isDbAvailable, getMilestone, getMilestoneSlices, getSliceTasks, } from "./gsd-db.js";
+import { _getAdapter, isDbAvailable, getMilestone, getMilestoneSlices, getSliceTasks, getVerificationEvidence, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { join } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
@@ -16,8 +16,10 @@ export function renderPlanContent(sliceRow, taskRows) {
     const lines = [];
     lines.push(`# ${sliceRow.id}: ${sliceRow.title}`);
     lines.push("");
-    lines.push(`**Goal:** ${sliceRow.goal || sliceRow.full_summary_md || "TBD"}`);
-    lines.push(`**Demo:** After this: ${sliceRow.demo || sliceRow.full_uat_md || "TBD"}`);
+    // #2945: never use full_summary_md/full_uat_md as display fallbacks —
+    // they contain multi-line rendered markdown that corrupts single-line fields.
+    lines.push(`**Goal:** ${sliceRow.goal || "TBD"}`);
+    lines.push(`**Demo:** After this: ${sliceRow.demo || "TBD"}`);
     lines.push("");
     lines.push("## Tasks");
     for (const task of taskRows) {
@@ -85,7 +87,10 @@ export function renderRoadmapContent(milestoneRow, sliceRows) {
             depends = slice.depends.join(", ");
         }
         const risk = (slice.risk || "low").toLowerCase();
-        const demo = slice.demo || slice.full_uat_md || "TBD";
+        // #2945 Bug 1: never use full_uat_md as a table cell fallback — it contains
+        // multi-line UAT content (preconditions, steps, expected results) that
+        // corrupts the markdown table and makes subsequent slices invisible.
+        const demo = slice.demo || "TBD";
         lines.push(`| ${slice.id} | ${slice.title} | ${risk} | ${depends} | ${done} | ${demo} |`);
     }
     lines.push("");
@@ -108,64 +113,85 @@ export function renderRoadmapProjection(basePath, milestoneId) {
 // ─── SUMMARY.md Projection ──────────────────────────────────────────────
 /**
  * Render SUMMARY.md content from a task row.
- * Pure function — no side effects.
+ * Single source of truth for summary rendering — used both at completion
+ * time and at projection regeneration time (#2720).
+ *
+ * @param evidence - Optional verification evidence rows. When called from
+ *   complete-task, these are passed directly. When called from projection
+ *   regeneration, they are queried from the DB by renderSummaryProjection.
  */
-export function renderSummaryContent(taskRow, sliceId, milestoneId) {
-    const lines = [];
-    // Frontmatter
-    lines.push("---");
-    lines.push(`id: ${taskRow.id}`);
-    lines.push(`parent: ${sliceId}`);
-    lines.push(`milestone: ${milestoneId}`);
-    lines.push("provides: []");
-    lines.push("requires: []");
-    lines.push("affects: []");
-    // key_files is already parsed to string[]
-    if (taskRow.key_files && taskRow.key_files.length > 0) {
-        lines.push(`key_files: [${taskRow.key_files.map(f => `"${f}"`).join(", ")}]`);
-    }
-    else {
-        lines.push("key_files: []");
-    }
-    // key_decisions is already parsed to string[]
-    if (taskRow.key_decisions && taskRow.key_decisions.length > 0) {
-        lines.push(`key_decisions: [${taskRow.key_decisions.map(d => `"${d}"`).join(", ")}]`);
+export function renderSummaryContent(taskRow, sliceId, milestoneId, evidence) {
+    // ── Frontmatter (YAML list format, matches parseSummary() expectations) ──
+    const keyFilesYaml = taskRow.key_files && taskRow.key_files.length > 0
+        ? taskRow.key_files.map(f => `  - ${f}`).join("\n")
+        : "  - (none)";
+    const keyDecisionsYaml = taskRow.key_decisions && taskRow.key_decisions.length > 0
+        ? taskRow.key_decisions.map(d => `  - ${d}`).join("\n")
+        : "  - (none)";
+    // Derive verification_result from evidence if available
+    const evidenceList = evidence ?? [];
+    const allPassed = evidenceList.length > 0 &&
+        evidenceList.every(e => {
+            const code = e.exitCode ?? e.exit_code ?? -1;
+            return code === 0 || e.verdict.includes("\u2705") || e.verdict.toLowerCase().includes("pass");
+        });
+    const verificationResult = taskRow.verification_result
+        ? (allPassed ? "passed" : (evidenceList.length === 0 ? "untested" : "mixed"))
+        : (allPassed ? "passed" : (evidenceList.length === 0 ? "untested" : "mixed"));
+    // Build verification evidence table
+    let evidenceTable = "| # | Command | Exit Code | Verdict | Duration |\n|---|---------|-----------|---------|----------|\n";
+    if (evidenceList.length > 0) {
+        evidenceList.forEach((e, i) => {
+            const code = e.exitCode ?? e.exit_code ?? 0;
+            const dur = e.durationMs ?? e.duration_ms ?? 0;
+            evidenceTable += `| ${i + 1} | \`${e.command}\` | ${code} | ${e.verdict} | ${dur}ms |\n`;
+        });
     }
     else {
-        lines.push("key_decisions: []");
-    }
-    lines.push("patterns_established: []");
-    lines.push("drill_down_paths: []");
-    lines.push("observability_surfaces: []");
-    lines.push(`duration: "${taskRow.duration || ""}"`);
-    lines.push(`verification_result: "${taskRow.verification_result || ""}"`);
-    lines.push(`completed_at: ${taskRow.completed_at || ""}`);
-    lines.push(`blocker_discovered: ${taskRow.blocker_discovered ? "true" : "false"}`);
-    lines.push("---");
-    lines.push("");
-    lines.push(`# ${taskRow.id}: ${taskRow.title}`);
-    lines.push("");
-    // One-liner (if present)
-    if (taskRow.one_liner) {
-        lines.push(`> ${taskRow.one_liner}`);
-        lines.push("");
+        evidenceTable += "| \u2014 | No verification commands discovered | \u2014 | \u2014 | \u2014 |\n";
     }
-    lines.push("## What Happened");
-    lines.push(taskRow.full_summary_md || taskRow.narrative || "No summary recorded.");
-    lines.push("");
-    // Deviations (if present)
-    if (taskRow.deviations) {
-        lines.push("## Deviations");
-        lines.push(taskRow.deviations);
-        lines.push("");
-    }
-    // Known issues (if present)
-    if (taskRow.known_issues) {
-        lines.push("## Known Issues");
-        lines.push(taskRow.known_issues);
-        lines.push("");
-    }
-    return lines.join("\n");
+    const title = taskRow.one_liner || taskRow.title || taskRow.id;
+    return `---
+id: ${taskRow.id}
+parent: ${sliceId}
+milestone: ${milestoneId}
+key_files:
+${keyFilesYaml}
+key_decisions:
+${keyDecisionsYaml}
+duration: ${taskRow.duration || ""}
+verification_result: ${verificationResult}
+completed_at: ${taskRow.completed_at || ""}
+blocker_discovered: ${taskRow.blocker_discovered ? "true" : "false"}
+---
+
+# ${taskRow.id}: ${title}
+
+**${taskRow.one_liner || ""}**
+
+## What Happened
+
+${taskRow.narrative || "No summary recorded."}
+
+## Verification
+
+${taskRow.verification_result || "No verification recorded."}
+
+## Verification Evidence
+
+${evidenceTable}
+## Deviations
+
+${taskRow.deviations || "None."}
+
+## Known Issues
+
+${taskRow.known_issues || "None."}
+
+## Files Created/Modified
+
+${taskRow.key_files && taskRow.key_files.length > 0 ? taskRow.key_files.map(f => `- \`${f}\``).join("\n") : "None."}
+`;
 }
 /**
  * Render SUMMARY.md projection to disk for a specific task.
@@ -176,7 +202,8 @@ export function renderSummaryProjection(basePath, milestoneId, sliceId, taskId)
     const taskRow = taskRows.find(t => t.id === taskId);
     if (!taskRow)
         return;
-    const content = renderSummaryContent(taskRow, sliceId, milestoneId);
+    const evidenceRows = getVerificationEvidence(milestoneId, sliceId, taskId);
+    const content = renderSummaryContent(taskRow, sliceId, milestoneId, evidenceRows);
     const dir = join(basePath, ".gsd", "milestones", milestoneId, "slices", sliceId, "tasks");
     mkdirSync(dir, { recursive: true });
     atomicWriteSync(join(dir, `${taskId}-SUMMARY.md`), content);
@@ -190,13 +217,18 @@ export function renderSummaryProjection(basePath, milestoneId, sliceId, taskId)
 export function renderStateContent(state) {
     const lines = [];
     lines.push("# GSD State", "");
-    const activeMilestone = state.activeMilestone
-        ? `${state.activeMilestone.id}: ${state.activeMilestone.title}`
-        : "None";
     const activeSlice = state.activeSlice
         ? `${state.activeSlice.id}: ${state.activeSlice.title}`
         : "None";
-    lines.push(`**Active Milestone:** ${activeMilestone}`);
+    if (state.phase === 'complete' && state.lastCompletedMilestone) {
+        lines.push(`**Last Completed Milestone:** ${state.lastCompletedMilestone.id}: ${state.lastCompletedMilestone.title}`);
+    }
+    else {
+        const activeMilestone = state.activeMilestone
+            ? `${state.activeMilestone.id}: ${state.activeMilestone.title}`
+            : "None";
+        lines.push(`**Active Milestone:** ${activeMilestone}`);
+    }
     lines.push(`**Active Slice:** ${activeSlice}`);
     lines.push(`**Phase:** ${state.phase}`);
     if (state.requirements) {

package/dist/resources/extensions/gsd/workflow-reconcile.js

@@ -1,10 +1,39 @@
 import { join } from "node:path";
 import { mkdirSync, existsSync, readFileSync, unlinkSync } from "node:fs";
+import { logWarning, logError } from "./workflow-logger.js";
 import { readEvents, findForkPoint, appendEvent, getSessionId } from "./workflow-events.js";
-import { transaction, updateTaskStatus, updateSliceStatus, insertVerificationEvidence, upsertDecision, openDatabase, } from "./gsd-db.js";
+import { transaction, updateTaskStatus, updateSliceStatus, getSliceTasks, insertVerificationEvidence, upsertDecision, openDatabase, } from "./gsd-db.js";
+import { isClosedStatus } from "./status-guards.js";
 import { writeManifest } from "./workflow-manifest.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { acquireSyncLock, releaseSyncLock } from "./sync-lock.js";
+// ─── Replay Helpers ──────────────────────────────────────────────────────────
+/**
+ * Replay a complete_slice event with task validation.
+ *
+ * #2945 Bug 2: The original replay blindly called updateSliceStatus("done")
+ * without checking whether all tasks in the slice are actually complete.
+ * During API overload or partial execution, a complete_slice event could
+ * be logged even when tasks were skipped, causing the milestone completion
+ * guard to see the slice as "done" and allow premature milestone completion.
+ *
+ * This function validates that every task in the slice has a closed status
+ * before marking the slice as done. If any task is still pending, the slice
+ * status is left unchanged.
+ */
+export function replaySliceComplete(milestoneId, sliceId, ts) {
+    const tasks = getSliceTasks(milestoneId, sliceId);
+    // If there are tasks and any are not closed, skip the status update
+    if (tasks.length > 0) {
+        const incompleteTasks = tasks.filter(t => !isClosedStatus(t.status));
+        if (incompleteTasks.length > 0) {
+            process.stderr.write(`[gsd] reconcile: skipping complete_slice replay for ${sliceId} — ` +
+                `${incompleteTasks.length} task(s) still pending\n`);
+            return;
+        }
+    }
+    updateSliceStatus(milestoneId, sliceId, "done", ts);
+}
 // ─── replayEvents ─────────────────────────────────────────────────────────────
 /**
  * Replay a list of WorkflowEvents by dispatching each to the appropriate
@@ -58,7 +87,8 @@ function replayEvents(events) {
                 case "complete_slice": {
                     const milestoneId = p["milestoneId"];
                     const sliceId = p["sliceId"];
-                    updateSliceStatus(milestoneId, sliceId, "done", event.ts);
+                    // #2945 Bug 2: validate tasks before marking slice done
+                    replaySliceComplete(milestoneId, sliceId, event.ts);
                     break;
                 }
                 case "plan_slice": {
@@ -221,7 +251,7 @@ export function reconcileWorktreeLogs(mainBasePath, worktreeBasePath) {
     // Acquire advisory lock to prevent concurrent reconcile + append races
     const lock = acquireSyncLock(mainBasePath);
     if (!lock.acquired) {
-        process.stderr.write(`[gsd] reconcile: could not acquire sync lock — another reconciliation may be in progress\n`);
+        logWarning("reconcile", "could not acquire sync lock — another reconciliation may be in progress");
         return { autoMerged: 0, conflicts: [] };
     }
     try {
@@ -251,7 +281,7 @@ function _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath) {
     if (conflicts.length > 0) {
         // D-04: atomic all-or-nothing — block entire merge
         writeConflictsFile(mainBasePath, conflicts, worktreeBasePath);
-        process.stderr.write(`[gsd] reconcile: ${conflicts.length} conflict(s) detected — see ${join(mainBasePath, ".gsd", "CONFLICTS.md")}\n`);
+        logError("reconcile", `${conflicts.length} conflict(s) detected`, { count: String(conflicts.length), path: join(mainBasePath, ".gsd", "CONFLICTS.md") });
         return { autoMerged: 0, conflicts };
     }
     // Step 6: Clean merge — stable sort by timestamp (index-based tiebreaker)
@@ -272,7 +302,7 @@ function _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath) {
         writeManifest(mainBasePath);
     }
     catch (err) {
-        process.stderr.write(`[gsd] reconcile: manifest write failed (non-fatal): ${err.message}\n`);
+        logWarning("reconcile", "manifest write failed (non-fatal)", { error: err.message });
     }
     return { autoMerged: merged.length, conflicts: [] };
 }

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;
+    });
+}