gsd-pi 2.63.0 → 2.64.0-dev.1a85e85

package/dist/resources/extensions/gsd/tools/complete-slice.js

@@ -25,46 +25,60 @@ import { logWarning } from "../workflow-logger.js";
  */
 function renderSliceSummaryMarkdown(params) {
     const now = new Date().toISOString();
-    const providesYaml = params.provides.length > 0
-        ? params.provides.map(p => `  - ${p}`).join("\n")
+    // Apply defaults for optional enrichment arrays (#2771)
+    const provides = params.provides ?? [];
+    const requires = params.requires ?? [];
+    const affects = params.affects ?? [];
+    const keyFiles = params.keyFiles ?? [];
+    const keyDecisions = params.keyDecisions ?? [];
+    const patternsEstablished = params.patternsEstablished ?? [];
+    const observabilitySurfaces = params.observabilitySurfaces ?? [];
+    const drillDownPaths = params.drillDownPaths ?? [];
+    const requirementsAdvanced = params.requirementsAdvanced ?? [];
+    const requirementsValidated = params.requirementsValidated ?? [];
+    const requirementsSurfaced = params.requirementsSurfaced ?? [];
+    const requirementsInvalidated = params.requirementsInvalidated ?? [];
+    const filesModified = params.filesModified ?? [];
+    const providesYaml = provides.length > 0
+        ? provides.map(p => `  - ${p}`).join("\n")
         : "  - (none)";
-    const requiresYaml = params.requires.length > 0
-        ? params.requires.map(r => `  - slice: ${r.slice}\n    provides: ${r.provides}`).join("\n")
+    const requiresYaml = requires.length > 0
+        ? requires.map(r => `  - slice: ${r.slice}\n    provides: ${r.provides}`).join("\n")
         : "  []";
-    const affectsYaml = params.affects.length > 0
-        ? params.affects.map(a => `  - ${a}`).join("\n")
+    const affectsYaml = affects.length > 0
+        ? affects.map(a => `  - ${a}`).join("\n")
         : "  []";
-    const keyFilesYaml = params.keyFiles.length > 0
-        ? params.keyFiles.map(f => `  - ${f}`).join("\n")
+    const keyFilesYaml = keyFiles.length > 0
+        ? keyFiles.map(f => `  - ${f}`).join("\n")
         : "  - (none)";
-    const keyDecisionsYaml = params.keyDecisions.length > 0
-        ? params.keyDecisions.map(d => `  - ${d}`).join("\n")
+    const keyDecisionsYaml = keyDecisions.length > 0
+        ? keyDecisions.map(d => `  - ${d}`).join("\n")
         : "  - (none)";
-    const patternsYaml = params.patternsEstablished.length > 0
-        ? params.patternsEstablished.map(p => `  - ${p}`).join("\n")
+    const patternsYaml = patternsEstablished.length > 0
+        ? patternsEstablished.map(p => `  - ${p}`).join("\n")
         : "  - (none)";
-    const observabilityYaml = params.observabilitySurfaces.length > 0
-        ? params.observabilitySurfaces.map(o => `  - ${o}`).join("\n")
+    const observabilityYaml = observabilitySurfaces.length > 0
+        ? observabilitySurfaces.map(o => `  - ${o}`).join("\n")
         : "  - none";
-    const drillDownYaml = params.drillDownPaths.length > 0
-        ? params.drillDownPaths.map(d => `  - ${d}`).join("\n")
+    const drillDownYaml = drillDownPaths.length > 0
+        ? drillDownPaths.map(d => `  - ${d}`).join("\n")
         : "  []";
     // Requirements sections
-    const reqAdvanced = params.requirementsAdvanced.length > 0
-        ? params.requirementsAdvanced.map(r => `- ${r.id} — ${r.how}`).join("\n")
+    const reqAdvanced = requirementsAdvanced.length > 0
+        ? requirementsAdvanced.map(r => `- ${r.id} — ${r.how}`).join("\n")
         : "None.";
-    const reqValidated = params.requirementsValidated.length > 0
-        ? params.requirementsValidated.map(r => `- ${r.id} — ${r.proof}`).join("\n")
+    const reqValidated = requirementsValidated.length > 0
+        ? requirementsValidated.map(r => `- ${r.id} — ${r.proof}`).join("\n")
         : "None.";
-    const reqSurfaced = params.requirementsSurfaced.length > 0
-        ? params.requirementsSurfaced.map(r => `- ${r}`).join("\n")
+    const reqSurfaced = requirementsSurfaced.length > 0
+        ? requirementsSurfaced.map(r => `- ${r}`).join("\n")
         : "None.";
-    const reqInvalidated = params.requirementsInvalidated.length > 0
-        ? params.requirementsInvalidated.map(r => `- ${r.id} — ${r.what}`).join("\n")
+    const reqInvalidated = requirementsInvalidated.length > 0
+        ? requirementsInvalidated.map(r => `- ${r.id} — ${r.what}`).join("\n")
         : "None.";
     // Files modified
-    const filesMod = params.filesModified.length > 0
-        ? params.filesModified.map(f => `- \`${f.path}\` — ${f.description}`).join("\n")
+    const filesMod = filesModified.length > 0
+        ? filesModified.map(f => `- \`${f.path}\` — ${f.description}`).join("\n")
         : "None.";
     return `---
 id: ${params.sliceId}

package/dist/resources/extensions/gsd/tools/complete-task.js

@@ -35,11 +35,11 @@ function paramsToTaskRow(params, completedAt) {
         verification_result: params.verification,
         duration: "",
         completed_at: completedAt,
-        blocker_discovered: params.blockerDiscovered,
-        deviations: params.deviations,
-        known_issues: params.knownIssues,
-        key_files: params.keyFiles,
-        key_decisions: params.keyDecisions,
+        blocker_discovered: params.blockerDiscovered ?? false,
+        deviations: params.deviations ?? "",
+        known_issues: params.knownIssues ?? "",
+        key_files: params.keyFiles ?? [],
+        key_decisions: params.keyDecisions ?? [],
         full_summary_md: "",
         description: "",
         estimate: "",
@@ -113,13 +113,13 @@ export async function handleCompleteTask(params, basePath) {
             narrative: params.narrative,
             verificationResult: params.verification,
             duration: "",
-            blockerDiscovered: params.blockerDiscovered,
-            deviations: params.deviations,
-            knownIssues: params.knownIssues,
-            keyFiles: params.keyFiles,
-            keyDecisions: params.keyDecisions,
+            blockerDiscovered: params.blockerDiscovered ?? false,
+            deviations: params.deviations ?? "None.",
+            knownIssues: params.knownIssues ?? "None.",
+            keyFiles: params.keyFiles ?? [],
+            keyDecisions: params.keyDecisions ?? [],
         });
-        for (const evidence of params.verificationEvidence) {
+        for (const evidence of (params.verificationEvidence ?? [])) {
             insertVerificationEvidence({
                 taskId: params.taskId,
                 sliceId: params.sliceId,
@@ -139,7 +139,7 @@ export async function handleCompleteTask(params, basePath) {
     // verifyExpectedArtifact() stay consistent (both say "not done").
     // Render summary markdown via the single source of truth (#2720)
     const taskRow = paramsToTaskRow(params, completedAt);
-    const summaryMd = renderSummaryContent(taskRow, params.sliceId, params.milestoneId, params.verificationEvidence);
+    const summaryMd = renderSummaryContent(taskRow, params.sliceId, params.milestoneId, params.verificationEvidence ?? []);
     // Resolve and write summary to disk
     let summaryPath;
     const tasksDir = resolveTasksDir(basePath, params.milestoneId, params.sliceId);

package/dist/resources/extensions/gsd/tools/plan-milestone.js

@@ -1,7 +1,7 @@
 import { clearParseCache } from "../files.js";
 import { isClosedStatus } from "../status-guards.js";
 import { isNonEmptyString, validateStringArray } from "../validation.js";
-import { transaction, getMilestone, getMilestoneSlices, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
+import { transaction, getMilestone, getMilestoneSlices, getSlice, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb } from "../markdown-renderer.js";
 import { renderAllProjections } from "../workflow-projections.js";
@@ -106,25 +106,20 @@ function validateParams(params) {
         throw new Error("title is required");
     if (!isNonEmptyString(params?.vision))
         throw new Error("vision is required");
-    if (!isNonEmptyString(params?.verificationContract))
-        throw new Error("verificationContract is required");
-    if (!isNonEmptyString(params?.verificationIntegration))
-        throw new Error("verificationIntegration is required");
-    if (!isNonEmptyString(params?.verificationOperational))
-        throw new Error("verificationOperational is required");
-    if (!isNonEmptyString(params?.verificationUat))
-        throw new Error("verificationUat is required");
-    if (!isNonEmptyString(params?.requirementCoverage))
-        throw new Error("requirementCoverage is required");
-    if (!isNonEmptyString(params?.boundaryMapMarkdown))
-        throw new Error("boundaryMapMarkdown is required");
     return {
         ...params,
         dependsOn: params.dependsOn ? validateStringArray(params.dependsOn, "dependsOn") : [],
-        successCriteria: validateStringArray(params.successCriteria, "successCriteria"),
-        keyRisks: validateRiskEntries(params.keyRisks),
-        proofStrategy: validateProofStrategy(params.proofStrategy),
-        definitionOfDone: validateStringArray(params.definitionOfDone, "definitionOfDone"),
+        // Apply defaults for optional enrichment fields (#2771)
+        successCriteria: params.successCriteria ? validateStringArray(params.successCriteria, "successCriteria") : [],
+        keyRisks: params.keyRisks ? validateRiskEntries(params.keyRisks) : [],
+        proofStrategy: params.proofStrategy ? validateProofStrategy(params.proofStrategy) : [],
+        verificationContract: params.verificationContract ?? "Not provided.",
+        verificationIntegration: params.verificationIntegration ?? "Not provided.",
+        verificationOperational: params.verificationOperational ?? "Not provided.",
+        verificationUat: params.verificationUat ?? "Not provided.",
+        definitionOfDone: params.definitionOfDone ? validateStringArray(params.definitionOfDone, "definitionOfDone") : [],
+        requirementCoverage: params.requirementCoverage ?? "Not provided.",
+        boundaryMapMarkdown: params.boundaryMapMarkdown ?? "Not provided.",
         slices: validateSlices(params.slices),
     };
 }
@@ -147,15 +142,19 @@ export async function handlePlanMilestone(rawParams, basePath) {
                 guardError = `cannot re-plan milestone ${params.milestoneId}: it is already complete`;
                 return;
             }
-            // Guard: refuse to re-plan a milestone that has completed slices (#2960).
-            // INSERT OR IGNORE on slices won't overwrite existing rows, but a full
-            // re-plan after worktree recreation or DB resync can create new slice rows
-            // that shadow completed work. Block early when any slice is already done.
+            // Guard: refuse to re-plan a milestone that would drop completed slices (#2960).
+            // Allow re-planning when all completed slices are still present in the
+            // incoming plan — their status is preserved below (#2558). Block only when
+            // the new plan omits a completed slice, which could shadow completed work.
             const existingSlices = getMilestoneSlices(params.milestoneId);
             const completedSlices = existingSlices.filter(s => isClosedStatus(s.status));
             if (completedSlices.length > 0) {
-                guardError = `cannot re-plan milestone ${params.milestoneId}: ${completedSlices.length} slice(s) already completed (${completedSlices.map(s => s.id).join(", ")}). Use gsd_reassess_roadmap to modify the roadmap.`;
-                return;
+                const incomingSliceIds = new Set(params.slices.map(s => s.sliceId));
+                const droppedCompleted = completedSlices.filter(s => !incomingSliceIds.has(s.id));
+                if (droppedCompleted.length > 0) {
+                    guardError = `cannot re-plan milestone ${params.milestoneId}: ${droppedCompleted.length} completed slice(s) would be dropped (${droppedCompleted.map(s => s.id).join(", ")}). Use gsd_reassess_roadmap to modify the roadmap.`;
+                    return;
+                }
             }
             // Validate depends_on: all dependencies must exist and be complete
             if (params.dependsOn && params.dependsOn.length > 0) {
@@ -178,6 +177,8 @@ export async function handlePlanMilestone(rawParams, basePath) {
                 depends_on: params.dependsOn ?? [],
             });
             upsertMilestonePlanning(params.milestoneId, {
+                title: params.title,
+                status: params.status ?? "active",
                 vision: params.vision,
                 successCriteria: params.successCriteria,
                 keyRisks: params.keyRisks,
@@ -189,13 +190,20 @@ export async function handlePlanMilestone(rawParams, basePath) {
                 definitionOfDone: params.definitionOfDone,
                 requirementCoverage: params.requirementCoverage,
                 boundaryMapMarkdown: params.boundaryMapMarkdown,
-            }, params.title);
+            });
             for (const slice of params.slices) {
+                // Preserve completed/done status on re-plan (#2558).
+                // Without this, a re-plan after milestone transition would reset
+                // already-completed slices back to "pending".
+                const existing = getSlice(params.milestoneId, slice.sliceId);
+                const status = existing && (existing.status === "complete" || existing.status === "done")
+                    ? existing.status
+                    : "pending";
                 insertSlice({
                     id: slice.sliceId,
                     milestoneId: params.milestoneId,
                     title: slice.title,
-                    status: "pending",
+                    status,
                     risk: slice.risk,
                     depends: slice.depends,
                     demo: slice.demo,

package/dist/resources/extensions/gsd/tools/plan-slice.js

@@ -72,16 +72,13 @@ function validateParams(params) {
         throw new Error("sliceId is required");
     if (!isNonEmptyString(params?.goal))
         throw new Error("goal is required");
-    if (!isNonEmptyString(params?.successCriteria))
-        throw new Error("successCriteria is required");
-    if (!isNonEmptyString(params?.proofLevel))
-        throw new Error("proofLevel is required");
-    if (!isNonEmptyString(params?.integrationClosure))
-        throw new Error("integrationClosure is required");
-    if (!isNonEmptyString(params?.observabilityImpact))
-        throw new Error("observabilityImpact is required");
     return {
         ...params,
+        // Apply defaults for optional enrichment fields (#2771)
+        successCriteria: params.successCriteria ?? "Not provided.",
+        proofLevel: params.proofLevel ?? "Not provided.",
+        integrationClosure: params.integrationClosure ?? "Not provided.",
+        observabilityImpact: params.observabilityImpact ?? "Not provided.",
         tasks: validateTasks(params.tasks),
     };
 }

package/dist/resources/extensions/gsd/verification-evidence.js

@@ -55,6 +55,24 @@ export function writeVerificationJSON(result, tasksDir, taskId, unitId, retryAtt
     const filePath = join(tasksDir, `${taskId}-VERIFY.json`);
     writeFileSync(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
 }
+/**
+ * Write pre-execution check results to a PRE-EXEC-VERIFY.json artifact
+ * in the slice directory.
+ */
+export function writePreExecutionEvidence(result, sliceDir, milestoneId, sliceId) {
+    mkdirSync(sliceDir, { recursive: true });
+    const evidence = {
+        schemaVersion: 1,
+        milestoneId,
+        sliceId,
+        timestamp: Date.now(),
+        status: result.status,
+        durationMs: result.durationMs,
+        checks: result.checks,
+    };
+    const filePath = join(sliceDir, `${sliceId}-PRE-EXEC-VERIFY.json`);
+    writeFileSync(filePath, JSON.stringify(evidence, null, 2) + "\n", "utf-8");
+}
 // ─── Markdown Evidence Table ─────────────────────────────────────────────────
 /**
  * Format duration in milliseconds as seconds with 1 decimal place.

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

@@ -17,6 +17,7 @@
 // Node process.
 import { appendFileSync, readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
+import { appendNotification } from "./notification-store.js";
 // ─── Buffer & Persistent Audit ──────────────────────────────────────────
 const MAX_BUFFER = 100;
 let _buffer = [];
@@ -179,6 +180,13 @@ function _push(severity, component, message, context) {
     const prefix = severity === "error" ? "ERROR" : "WARN";
     const ctxStr = context ? ` ${JSON.stringify(context)}` : "";
     process.stderr.write(`[gsd:${component}] ${prefix}: ${message}${ctxStr}\n`);
+    // Persist to notification store (both warnings and errors)
+    try {
+        appendNotification(`[${component}] ${message}`, severity === "error" ? "error" : "warning", "workflow-logger");
+    }
+    catch (notifErr) {
+        process.stderr.write(`[gsd:workflow-logger] notification-store append failed: ${notifErr.message}\n`);
+    }
     // Buffer for auto-loop to drain
     _buffer.push(entry);
     if (_buffer.length > MAX_BUFFER) {

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

@@ -7,6 +7,20 @@ import { join } from "node:path";
 import { mkdirSync, existsSync } from "node:fs";
 import { logWarning } from "./workflow-logger.js";
 import { deriveState } from "./state.js";
+// ─── Helpers ─────────────────────────────────────────────────────────────
+/**
+ * Strip a leading ID prefix (e.g. "M001: " or "S04: ") from a title
+ * to prevent double-prefixing when the renderer adds its own prefix.
+ * Handles repeated prefixes (e.g. "M001: M001: M001: Title" → "Title").
+ */
+export function stripIdPrefix(title, id) {
+    const prefix = `${id}: `;
+    let result = title;
+    while (result.startsWith(prefix)) {
+        result = result.slice(prefix.length);
+    }
+    return result.trim() || title;
+}
 // ─── PLAN.md Projection ──────────────────────────────────────────────────
 /**
  * Render PLAN.md content from a slice row and its task rows.
@@ -14,7 +28,8 @@ import { deriveState } from "./state.js";
  */
 export function renderPlanContent(sliceRow, taskRows) {
     const lines = [];
-    lines.push(`# ${sliceRow.id}: ${sliceRow.title}`);
+    const displayTitle = stripIdPrefix(sliceRow.title, sliceRow.id);
+    lines.push(`# ${sliceRow.id}: ${displayTitle}`);
     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.
@@ -71,7 +86,8 @@ export function renderPlanProjection(basePath, milestoneId, sliceId) {
  */
 export function renderRoadmapContent(milestoneRow, sliceRows) {
     const lines = [];
-    lines.push(`# ${milestoneRow.id}: ${milestoneRow.title}`);
+    const displayTitle = stripIdPrefix(milestoneRow.title, milestoneRow.id);
+    lines.push(`# ${milestoneRow.id}: ${displayTitle}`);
     lines.push("");
     lines.push("## Vision");
     lines.push(milestoneRow.vision || milestoneRow.title || "TBD");
@@ -218,14 +234,14 @@ export function renderStateContent(state) {
     const lines = [];
     lines.push("# GSD State", "");
     const activeSlice = state.activeSlice
-        ? `${state.activeSlice.id}: ${state.activeSlice.title}`
+        ? `${state.activeSlice.id}: ${stripIdPrefix(state.activeSlice.title, state.activeSlice.id)}`
         : "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}`
+            ? `${state.activeMilestone.id}: ${stripIdPrefix(state.activeMilestone.title, state.activeMilestone.id)}`
             : "None";
         lines.push(`**Active Milestone:** ${activeMilestone}`);
     }
@@ -238,7 +254,7 @@ export function renderStateContent(state) {
     lines.push("## Milestone Registry");
     for (const entry of state.registry) {
         const glyph = entry.status === "complete" ? "\u2705" : entry.status === "active" ? "\uD83D\uDD04" : entry.status === "parked" ? "\u23F8\uFE0F" : "\u2B1C";
-        lines.push(`- ${glyph} **${entry.id}:** ${entry.title}`);
+        lines.push(`- ${glyph} **${entry.id}:** ${stripIdPrefix(entry.title, entry.id)}`);
     }
     lines.push("");
     lines.push("## Recent Decisions");

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

@@ -65,6 +65,21 @@ export function worktreePath(basePath, name) {
 export function worktreeBranchName(name) {
     return `worktree/${name}`;
 }
+/**
+ * Validate that a path is inside the .gsd/worktrees/ directory.
+ * Resolves symlinks and normalizes ".." traversals before comparison
+ * so that a symlink-resolved or crafted path cannot escape containment.
+ *
+ * Used as a safety gate before any destructive operation (rmSync,
+ * nativeWorktreeRemove --force) to prevent #2365-style data loss.
+ */
+export function isInsideWorktreesDir(basePath, targetPath) {
+    const wtDir = resolve(worktreesDir(basePath));
+    const resolved = resolve(targetPath);
+    // The resolved path must start with the worktrees dir followed by a separator,
+    // not merely be a prefix match (e.g. ".gsd/worktrees-extra" must not match).
+    return resolved === wtDir || resolved.startsWith(wtDir + sep);
+}
 // ─── Core Operations ───────────────────────────────────────────────────────
 /**
  * Create a new git worktree under .gsd/worktrees/<name>/ with branch worktree/<name>.
@@ -286,17 +301,40 @@ export function removeWorktree(basePath, name, opts = {}) {
     // time, so its registered path points to the resolved external location.
     // If syncStateToProjectRoot later creates a real .gsd/ directory that
     // shadows the symlink, the computed path diverges from git's record.
+    let gitReportedPath = null;
     try {
         const entries = nativeWorktreeList(basePath);
         const entry = entries.find(e => e.branch === branch);
         if (entry?.path) {
-            wtPath = entry.path;
+            gitReportedPath = entry.path;
         }
     }
     catch (e) {
         logWarning("worktree", `nativeWorktreeList parse failed: ${e.message}`);
     }
+    // Safety gate (#2365): only use the git-reported path if it is actually
+    // inside .gsd/worktrees/.  When .gsd/ was a symlink, git may have resolved
+    // it to an external directory (e.g. a project data folder).  Using that
+    // path for removal would destroy user data.
+    if (gitReportedPath && isInsideWorktreesDir(basePath, gitReportedPath)) {
+        wtPath = gitReportedPath;
+    }
+    else if (gitReportedPath) {
+        console.error(`[GSD] WARNING: git worktree list reported path outside .gsd/worktrees/: ${gitReportedPath}\n` +
+            `  Refusing to use it for removal — falling back to computed path: ${wtPath}`);
+        // Still tell git to unregister the worktree entry via its reported path,
+        // but do NOT use force and do NOT fall back to rmSync on this path.
+        try {
+            nativeWorktreeRemove(basePath, gitReportedPath, false);
+        }
+        catch (e) {
+            logWarning("worktree", `non-force worktree remove failed for ${gitReportedPath}: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
     const resolvedWtPath = existsSync(wtPath) ? realpathSync(wtPath) : wtPath;
+    // Double-check: the resolved path (after symlink resolution) must also be
+    // inside .gsd/worktrees/ — a symlink inside the directory could point out.
+    const resolvedPathSafe = isInsideWorktreesDir(basePath, resolvedWtPath);
     // If we're inside the worktree, move out first — git can't remove an in-use directory
     const cwd = process.cwd();
     const resolvedCwd = existsSync(cwd) ? realpathSync(cwd) : cwd;
@@ -360,41 +398,56 @@ export function removeWorktree(basePath, name, opts = {}) {
             }
         }
     }
-    // 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;
-    try {
-        nativeWorktreeRemove(basePath, resolvedWtPath, useForce);
-    }
-    catch (e) {
-        logWarning("worktree", `nativeWorktreeRemove failed: ${e.message}`);
-    }
-    // If the directory is still there (e.g. locked), try harder with force
-    if (existsSync(resolvedWtPath)) {
+    // Remove worktree — only use force/rmSync when the path is safely contained
+    if (resolvedPathSafe) {
+        // 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;
         try {
-            nativeWorktreeRemove(basePath, resolvedWtPath, true);
+            nativeWorktreeRemove(basePath, resolvedWtPath, useForce);
         }
         catch (e) {
-            logWarning("worktree", `nativeWorktreeRemove (force) failed: ${e.message}`);
+            logWarning("worktree", `nativeWorktreeRemove failed: ${e.message}`);
+        }
+        // If the directory is still there (e.g. locked), try harder with force
+        if (existsSync(resolvedWtPath)) {
+            try {
+                nativeWorktreeRemove(basePath, resolvedWtPath, true);
+            }
+            catch (e) {
+                logWarning("worktree", `nativeWorktreeRemove (force) failed: ${e.message}`);
+            }
+        }
+        // (#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 });
+            }
         }
     }
-    // (#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)) {
+    else {
+        // Path is outside containment — only do a non-force git worktree remove
+        // (which refuses to delete dirty worktrees) and never fall back to rmSync.
+        console.error(`[GSD] WARNING: Resolved worktree path is outside .gsd/worktrees/: ${resolvedWtPath}\n` +
+            `  Skipping forced removal to prevent data loss.`);
         try {
-            const wtInternalDir = join(basePath, ".git", "worktrees", name);
-            if (existsSync(wtInternalDir)) {
-                rmSync(wtInternalDir, { recursive: true, force: true });
-            }
-            rmSync(resolvedWtPath, { recursive: true, force: true });
+            nativeWorktreeRemove(basePath, resolvedWtPath, false);
         }
-        catch {
-            logWarning("reconcile", `Worktree directory could not be removed after git internal cleanup: ${resolvedWtPath}. ` +
-                `Manual cleanup: rm -rf "${resolvedWtPath.replaceAll("\\", "/")}"`, { worktree: name });
+        catch (e) {
+            logWarning("worktree", `non-force worktree remove failed for ${resolvedWtPath}: ${e instanceof Error ? e.message : String(e)}`);
         }
     }
     // Prune stale entries so git knows the worktree is gone

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

@@ -365,9 +365,10 @@ export class WorktreeResolver {
             });
             // Surface a clear, actionable error. The worktree and milestone branch are
             // intentionally preserved — nothing has been deleted. The user can retry
-            // /gsd dispatch complete-milestone or merge manually once the underlying issue is fixed
-            // (e.g. checkout to wrong branch, unresolved conflicts). (#1668)
-            ctx.notify(`Milestone merge failed: ${msg}. Your worktree and milestone branch are preserved — retry /gsd dispatch complete-milestone or merge manually.`, "warning");
+            // /gsd dispatch complete-milestone or merge manually once the underlying
+            // issue is fixed (e.g. checkout to wrong branch, unresolved conflicts).
+            // (#1668, #1891)
+            ctx.notify(`Milestone merge failed: ${msg}. Your worktree and milestone branch are preserved — retry with \`/gsd dispatch complete-milestone\` or merge manually.`, "warning");
             // Clean up stale merge state left by failed squash-merge (#1389)
             try {
                 const gitDir = join(originalBase || this.s.basePath, ".git");

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

@@ -0,0 +1,101 @@
+/**
+ * MCP Client OAuth / Auth helpers
+ *
+ * Builds transport options (headers, OAuthClientProvider) from MCP server
+ * config entries so that HTTP transports can authenticate with remote
+ * servers (Sentry, Linear, etc.).
+ *
+ * Fixes #2160 — MCP HTTP transport lacked an OAuth auth provider.
+ */
+// ─── Env resolution ───────────────────────────────────────────────────────────
+/** Resolve `${VAR}` references in a string against `process.env`. */
+function resolveEnvValue(value) {
+    return value.replace(/\$\{([^}]+)\}/g, (_match, varName) => process.env[varName] ?? "");
+}
+function resolveHeaders(raw) {
+    const resolved = {};
+    for (const [key, value] of Object.entries(raw)) {
+        resolved[key] = typeof value === "string" ? resolveEnvValue(value) : value;
+    }
+    return resolved;
+}
+// ─── OAuth provider (minimal CLI-friendly implementation) ─────────────────────
+/**
+ * Creates a minimal `OAuthClientProvider` suitable for CLI / headless use.
+ *
+ * This provider supports:
+ *  - Pre-configured client credentials (client_id, optional client_secret)
+ *  - Token storage in memory (per-session)
+ *  - Scopes
+ *
+ * For full interactive OAuth flows (browser redirect), a richer provider would
+ * be needed, but for server-to-server and pre-authed scenarios this is
+ * sufficient.
+ */
+function createCliOAuthProvider(config) {
+    let storedTokens;
+    let storedCodeVerifier = "";
+    return {
+        get redirectUrl() {
+            return config.redirectUrl ?? "http://localhost:0/callback";
+        },
+        get clientMetadata() {
+            return {
+                redirect_uris: [config.redirectUrl ?? "http://localhost:0/callback"],
+                client_name: "gsd",
+                ...(config.scopes ? { scope: config.scopes.join(" ") } : {}),
+            };
+        },
+        clientInformation() {
+            return {
+                client_id: config.clientId,
+                ...(config.clientSecret ? { client_secret: config.clientSecret } : {}),
+            };
+        },
+        tokens() {
+            return storedTokens;
+        },
+        saveTokens(tokens) {
+            storedTokens = tokens;
+        },
+        redirectToAuthorization(authorizationUrl) {
+            // In a CLI context we can't open a browser automatically.
+            // Log the URL so the user can manually visit it.
+            // eslint-disable-next-line no-console
+            console.error(`[MCP OAuth] Authorization required. Visit:\n  ${authorizationUrl.toString()}`);
+        },
+        saveCodeVerifier(codeVerifier) {
+            storedCodeVerifier = codeVerifier;
+        },
+        codeVerifier() {
+            return storedCodeVerifier;
+        },
+    };
+}
+// ─── Public API ───────────────────────────────────────────────────────────────
+/**
+ * Build `StreamableHTTPClientTransportOptions` from an MCP server config's
+ * auth-related fields.
+ *
+ * Supports two auth strategies:
+ *  1. **`headers`** — static Authorization (or other) headers, with `${VAR}` env resolution.
+ *  2. **`oauth`**  — full OAuthClientProvider for servers that implement MCP OAuth.
+ *
+ * When both are provided, `oauth` takes precedence (the SDK's built-in OAuth
+ * flow handles token refresh automatically).
+ */
+export function buildHttpTransportOpts(authConfig) {
+    const opts = {};
+    // OAuth takes precedence
+    if (authConfig.oauth) {
+        opts.authProvider = createCliOAuthProvider(authConfig.oauth);
+        return opts;
+    }
+    // Static headers (with env var resolution)
+    if (authConfig.headers && Object.keys(authConfig.headers).length > 0) {
+        opts.requestInit = {
+            headers: resolveHeaders(authConfig.headers),
+        };
+    }
+    return opts;
+}