gsd-pi 2.58.0-dev.778d6ac → 2.58.0-dev.d63175c

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

@@ -9,25 +9,6 @@ function requireDb() {
         throw new Error("workflow-manifest: No database open");
     return db;
 }
-/**
- * Coerce a raw DB value to a number, returning `fallback` for
- * null/undefined/non-numeric strings (e.g. "-", "N/A", "").
- * SQLite can store TEXT in INTEGER columns after migrations or manual inserts.
- */
-export function toNumeric(value, fallback = null) {
-    if (value === null || value === undefined)
-        return fallback;
-    if (typeof value === "number")
-        return Number.isFinite(value) ? value : fallback;
-    if (typeof value === "string") {
-        const trimmed = value.trim();
-        if (trimmed === "" || trimmed === "-" || trimmed === "N/A")
-            return fallback;
-        const n = Number(trimmed);
-        return Number.isFinite(n) ? n : fallback;
-    }
-    return fallback;
-}
 // ─── snapshotState ───────────────────────────────────────────────────────
 /**
  * Capture complete DB state as a StateManifest.
@@ -81,7 +62,7 @@ export function snapshotState() {
             proof_level: r["proof_level"] ?? "",
             integration_closure: r["integration_closure"] ?? "",
             observability_impact: r["observability_impact"] ?? "",
-            sequence: toNumeric(r["sequence"], 0),
+            sequence: r["sequence"] ?? 0,
             replan_triggered_at: r["replan_triggered_at"] ?? null,
         }));
         const rawTasks = db.prepare("SELECT * FROM tasks ORDER BY milestone_id, slice_id, sequence, id").all();
@@ -110,11 +91,11 @@ export function snapshotState() {
             expected_output: JSON.parse(r["expected_output"] || "[]"),
             observability_impact: r["observability_impact"] ?? "",
             full_plan_md: r["full_plan_md"] ?? "",
-            sequence: toNumeric(r["sequence"], 0),
+            sequence: r["sequence"] ?? 0,
         }));
         const rawDecisions = db.prepare("SELECT * FROM decisions ORDER BY seq").all();
         const decisions = rawDecisions.map((r) => ({
-            seq: toNumeric(r["seq"], 0),
+            seq: r["seq"],
             id: r["id"],
             when_context: r["when_context"] ?? "",
             scope: r["scope"] ?? "",
@@ -132,9 +113,9 @@ export function snapshotState() {
             slice_id: r["slice_id"],
             milestone_id: r["milestone_id"],
             command: r["command"],
-            exit_code: toNumeric(r["exit_code"]),
+            exit_code: r["exit_code"] ?? null,
             verdict: r["verdict"] ?? "",
-            duration_ms: toNumeric(r["duration_ms"]),
+            duration_ms: r["duration_ms"] ?? null,
             created_at: r["created_at"],
         }));
         const result = {

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, getVerificationEvidence, } from "./gsd-db.js";
+import { _getAdapter, isDbAvailable, getMilestone, getMilestoneSlices, getSliceTasks, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { join } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
@@ -16,10 +16,8 @@ export function renderPlanContent(sliceRow, taskRows) {
     const lines = [];
     lines.push(`# ${sliceRow.id}: ${sliceRow.title}`);
     lines.push("");
-    // #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(`**Goal:** ${sliceRow.goal || sliceRow.full_summary_md || "TBD"}`);
+    lines.push(`**Demo:** After this: ${sliceRow.demo || sliceRow.full_uat_md || "TBD"}`);
     lines.push("");
     lines.push("## Tasks");
     for (const task of taskRows) {
@@ -87,10 +85,7 @@ export function renderRoadmapContent(milestoneRow, sliceRows) {
             depends = slice.depends.join(", ");
         }
         const risk = (slice.risk || "low").toLowerCase();
-        // #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";
+        const demo = slice.demo || slice.full_uat_md || "TBD";
         lines.push(`| ${slice.id} | ${slice.title} | ${risk} | ${depends} | ${done} | ${demo} |`);
     }
     lines.push("");
@@ -113,85 +108,64 @@ export function renderRoadmapProjection(basePath, milestoneId) {
 // ─── SUMMARY.md Projection ──────────────────────────────────────────────
 /**
  * Render SUMMARY.md content from a task row.
- * 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.
+ * Pure function — no side effects.
  */
-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`;
-        });
+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(", ")}]`);
     }
     else {
-        evidenceTable += "| \u2014 | No verification commands discovered | \u2014 | \u2014 | \u2014 |\n";
+        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("");
     }
-    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."}
-`;
+    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");
 }
 /**
  * Render SUMMARY.md projection to disk for a specific task.
@@ -202,8 +176,7 @@ export function renderSummaryProjection(basePath, milestoneId, sliceId, taskId)
     const taskRow = taskRows.find(t => t.id === taskId);
     if (!taskRow)
         return;
-    const evidenceRows = getVerificationEvidence(milestoneId, sliceId, taskId);
-    const content = renderSummaryContent(taskRow, sliceId, milestoneId, evidenceRows);
+    const content = renderSummaryContent(taskRow, sliceId, milestoneId);
     const dir = join(basePath, ".gsd", "milestones", milestoneId, "slices", sliceId, "tasks");
     mkdirSync(dir, { recursive: true });
     atomicWriteSync(join(dir, `${taskId}-SUMMARY.md`), content);
@@ -217,18 +190,13 @@ 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";
-    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 Milestone:** ${activeMilestone}`);
     lines.push(`**Active Slice:** ${activeSlice}`);
     lines.push(`**Phase:** ${state.phase}`);
     if (state.requirements) {

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

@@ -1,39 +1,10 @@
 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, getSliceTasks, insertVerificationEvidence, upsertDecision, openDatabase, } from "./gsd-db.js";
-import { isClosedStatus } from "./status-guards.js";
+import { transaction, updateTaskStatus, updateSliceStatus, insertVerificationEvidence, upsertDecision, openDatabase, } from "./gsd-db.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
@@ -87,8 +58,7 @@ function replayEvents(events) {
                 case "complete_slice": {
                     const milestoneId = p["milestoneId"];
                     const sliceId = p["sliceId"];
-                    // #2945 Bug 2: validate tasks before marking slice done
-                    replaySliceComplete(milestoneId, sliceId, event.ts);
+                    updateSliceStatus(milestoneId, sliceId, "done", event.ts);
                     break;
                 }
                 case "plan_slice": {
@@ -251,7 +221,7 @@ export function reconcileWorktreeLogs(mainBasePath, worktreeBasePath) {
     // Acquire advisory lock to prevent concurrent reconcile + append races
     const lock = acquireSyncLock(mainBasePath);
     if (!lock.acquired) {
-        logWarning("reconcile", "could not acquire sync lock — another reconciliation may be in progress");
+        process.stderr.write(`[gsd] reconcile: could not acquire sync lock — another reconciliation may be in progress\n`);
         return { autoMerged: 0, conflicts: [] };
     }
     try {
@@ -281,7 +251,7 @@ function _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath) {
     if (conflicts.length > 0) {
         // D-04: atomic all-or-nothing — block entire merge
         writeConflictsFile(mainBasePath, conflicts, worktreeBasePath);
-        logError("reconcile", `${conflicts.length} conflict(s) detected`, { count: String(conflicts.length), path: join(mainBasePath, ".gsd", "CONFLICTS.md") });
+        process.stderr.write(`[gsd] reconcile: ${conflicts.length} conflict(s) detected — see ${join(mainBasePath, ".gsd", "CONFLICTS.md")}\n`);
         return { autoMerged: 0, conflicts };
     }
     // Step 6: Clean merge — stable sort by timestamp (index-based tiebreaker)
@@ -302,7 +272,7 @@ function _reconcileWorktreeLogsInner(mainBasePath, worktreeBasePath) {
         writeManifest(mainBasePath);
     }
     catch (err) {
-        logWarning("reconcile", "manifest write failed (non-fatal)", { error: err.message });
+        process.stderr.write(`[gsd] reconcile: manifest write failed (non-fatal): ${err.message}\n`);
     }
     return { autoMerged: merged.length, conflicts: [] };
 }

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

@@ -3,7 +3,6 @@ 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.
@@ -117,29 +116,6 @@ 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, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { existsSync, mkdirSync, 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,73 +203,6 @@ 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.
@@ -336,24 +269,6 @@ 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;
@@ -368,25 +283,6 @@ 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,12 +248,7 @@ export class WorktreeResolver {
             eventType: "worktree-merge-start",
             data: { milestoneId, mode },
         });
-        // #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) {
+        if (mode === "none") {
             debugLog("WorktreeResolver", {
                 action: "mergeAndExit",
                 milestoneId,
@@ -262,7 +257,8 @@ export class WorktreeResolver {
             });
             return;
         }
-        if (mode === "worktree" || inWorktree) {
+        if (mode === "worktree" ||
+            (this.deps.isInAutoWorktree(this.s.basePath) && this.s.originalBasePath)) {
             this._mergeWorktreeMode(milestoneId, ctx);
         }
         else if (mode === "branch") {
@@ -312,19 +308,6 @@ 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,9 +74,7 @@ function readConfigs() {
     return servers;
 }
 function getServerConfig(name) {
-    const trimmed = name.trim();
-    return readConfigs().find((s) => s.name === trimmed ||
-        s.name.toLowerCase() === trimmed.toLowerCase());
+    return readConfigs().find((s) => s.name === name);
 }
 /** Resolve ${VAR} references in env values against process.env. */
 function resolveEnv(env) {
@@ -92,14 +90,12 @@ 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) {
@@ -112,14 +108,14 @@ async function getOrConnect(name, signal) {
         });
     }
     else if (config.transport === "http" && config.url) {
-        const resolvedUrl = config.url.replace(/\$\{([^}]+)\}/g, (_, varName) => process.env[varName] ?? "");
+        const resolvedUrl = config.url.replace(/\$\{([^}]+)\}/g, (_, name) => process.env[name] ?? "");
         transport = new StreamableHTTPClientTransport(new URL(resolvedUrl));
     }
     else {
-        throw new Error(`Server "${config.name}" has unsupported transport: ${config.transport}`);
+        throw new Error(`Server "${name}" has unsupported transport: ${config.transport}`);
     }
     await client.connect(transport, { signal, timeout: 30000 });
-    connections.set(config.name, { client, transport });
+    connections.set(name, { client, transport });
     return client;
 }
 async function closeAll() {

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": ["session_start", "model_select", "before_provider_request"]
+    "hooks": ["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 = "Select to type your own answer.";
+const OTHER_OPTION_DESCRIPTION = "Press TAB to add optional notes.";
 // ─── Wrap-up screen ───────────────────────────────────────────────────────────
 export async function showWrapUpScreen(opts, ctx) {
     return ctx.ui.custom((tui, theme, _kb, done) => {
@@ -199,16 +199,6 @@ 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++) {