gsd-pi 2.82.0-dev.3709f22a5 → 2.82.0-dev.4285182e8

package/dist/resources/extensions/gsd/auto.js

@@ -689,6 +689,8 @@ export async function rerootCommandSession(cmdCtx, workspaceRoot) {
     }
 }
 export async function cleanupAfterLoopExit(ctx) {
+    const preserveStepSurface = s.preserveStepSurfaceAfterLoopExit;
+    const preservePausedSurface = s.paused;
     s.currentUnit = null;
     s.active = false;
     deactivateGSD();
@@ -712,19 +714,24 @@ export async function cleanupAfterLoopExit(ctx) {
     // A transient provider-error pause intentionally leaves the paused badge
     // visible so the user still has a resumable auto-mode signal on screen.
     if (!s.paused) {
-        ctx.ui.setStatus("gsd-auto", undefined);
-        ctx.ui.setWidget("gsd-progress", undefined);
-        if (s.completionStopInProgress) {
-            s.completionStopInProgress = false;
+        if (preserveStepSurface) {
+            s.preserveStepSurfaceAfterLoopExit = false;
+        }
+        else {
+            ctx.ui.setStatus("gsd-auto", undefined);
+            ctx.ui.setWidget("gsd-progress", undefined);
+            if (s.completionStopInProgress) {
+                s.completionStopInProgress = false;
+            }
+            initHealthWidget(ctx);
         }
-        initHealthWidget(ctx);
     }
     // ADR-016 phase 3 (#5693): the stop-path basePath restore + chdir routes
     // through `Lifecycle.restoreToProjectRoot()`, the sole owner of both
     // `s.basePath` mutation and the paired `process.chdir` for auto-loop
     // transitions. The verb assigns `s.basePath` before any throwable work, so
     // a thrown error still leaves basePath restored.
-    if (s.originalBasePath) {
+    if (s.originalBasePath && !preserveStepSurface && !preservePausedSurface) {
         try {
             buildLifecycle().restoreToProjectRoot();
         }
@@ -732,7 +739,7 @@ export async function cleanupAfterLoopExit(ctx) {
             logWarning("engine", `restore project root failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
     }
-    if (s.originalBasePath && s.cmdCtx) {
+    if (s.originalBasePath && s.cmdCtx && !preserveStepSurface && !preservePausedSurface) {
         const result = await rerootCommandSession(s.cmdCtx, s.originalBasePath);
         if (result.status === "cancelled") {
             logWarning("engine", "post-loop session re-root was cancelled", { file: "auto.ts", basePath: s.originalBasePath });
@@ -1325,7 +1332,6 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     restoreProjectRootEnv();
     restoreMilestoneLockEnv();
     s.pendingVerificationRetry = null;
-    s.verificationRetryCount.clear();
     ctx?.ui.setStatus("gsd-auto", "paused");
     ctx?.ui.setWidget("gsd-progress", undefined);
     const resumeCmd = s.stepMode ? "/gsd next" : "/gsd auto";

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -61,6 +61,11 @@ export function isUserInitiatedAbortMessage(message) {
         return false;
     return /\b(?:claude code process aborted by user|request aborted by user|process aborted by user)\b/i.test(message);
 }
+export function shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg) {
+    if (!isTransient(cls) || cls.kind === "rate-limit")
+        return false;
+    return !/retry failed after \d+ attempts:/i.test(rawErrorMsg);
+}
 function isBareClaudeCodeSessionSwitchAbortMarker(message) {
     if (!message)
         return false;
@@ -394,7 +399,7 @@ export async function handleAgentEnd(pi, event, ctx) {
         // Core retries transient failures in-session after this handler.
         // Keep that behavior for non-rate-limit classes to avoid pause/retry races,
         // but let rate-limit continue into model fallback logic below (#4373).
-        if (isTransient(cls) && cls.kind !== "rate-limit") {
+        if (shouldDeferTransientErrorToCoreRetry(cls, rawErrorMsg)) {
             return;
         }
         // Cap rate-limit backoff for CLI-style providers (openai-codex, google-gemini-cli)

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -848,7 +848,7 @@ export function registerDbTools(pi) {
         name: "gsd_skip_slice",
         label: "Skip Slice",
         description: "Mark a slice as skipped so auto-mode advances past it without executing. " +
-            "Non-closed tasks within the slice are cascaded to skipped so milestone completion is not blocked by leftover pending tasks (#4375). " +
+            "Non-closed tasks within the slice are cascaded to skipped so milestone completion is not blocked by leftover pending tasks. " +
             "The slice data is preserved for reference. The state machine treats skipped slices like completed ones for dependency satisfaction.",
         promptSnippet: "Skip a GSD slice (mark as skipped, auto-mode will advance past it)",
         promptGuidelines: [

package/dist/resources/extensions/gsd/bootstrap/write-gate.js

@@ -625,7 +625,7 @@ function matchesAllowedGlob(absPath, basePath, globs) {
 function blockReason(unitType, mode, what) {
     return [
         `HARD BLOCK: unit "${unitType}" runs under tools-policy "${mode}" — ${what}.`,
-        `This is a mechanical gate enforced by manifest.tools (#4934). You MUST NOT proceed,`,
+        `This is a mechanical gate enforced by manifest.tools. You MUST NOT proceed,`,
         `retry the same call, or rationalize past this block. If you need to write user source,`,
         `the work belongs in execute-task, not in a planning unit.`,
     ].join(" ");

package/dist/resources/extensions/gsd/commands/catalog.js

@@ -3,7 +3,7 @@ import { join, resolve } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
 import { gsdHome } from "../gsd-home.js";
 import { VISUAL_BRIEF_MODES } from "../../visual-brief/prompts.js";
-export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|brief|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|debug|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|new-project|parallel|cmux|park|unpark|init|setup|onboarding|inspect|extensions|update|fast|mcp|rethink|workflow|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests|scan|language|worktree|eval-review";
+export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|brief|queue|quick|discuss|capture|triage|dispatch|verdict|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|debug|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|new-project|parallel|cmux|park|unpark|init|setup|onboarding|inspect|extensions|update|fast|mcp|rethink|workflow|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests|scan|language|worktree|eval-review";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -21,6 +21,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "changelog", desc: "Show categorized release notes" },
     { cmd: "triage", desc: "Manually trigger triage of pending captures" },
     { cmd: "dispatch", desc: "Dispatch a specific phase directly" },
+    { cmd: "verdict", desc: "Override the recorded milestone validation verdict (pass|needs-attention|needs-remediation)" },
     { cmd: "history", desc: "View execution history" },
     { cmd: "undo", desc: "Revert last completed unit" },
     { cmd: "undo-task", desc: "Reset a specific task's completion state (DB + markdown)" },
@@ -235,6 +236,11 @@ const NESTED_COMPLETIONS = {
         { cmd: "uat", desc: "Run user acceptance testing" },
         { cmd: "replan", desc: "Replan the current slice" },
     ],
+    verdict: [
+        { cmd: "pass", desc: "Override the milestone validation verdict to pass" },
+        { cmd: "needs-attention", desc: "Override the verdict to needs-attention (requires --rationale)" },
+        { cmd: "needs-remediation", desc: "Override the verdict to needs-remediation (requires --rationale)" },
+    ],
     rate: [
         { cmd: "over", desc: "Model was overqualified for this task" },
         { cmd: "ok", desc: "Model was appropriate for this task" },

package/dist/resources/extensions/gsd/commands/handlers/core.js

@@ -65,6 +65,7 @@ export function showHelp(ctx, args = "") {
         "  /gsd new-project    Bootstrap a new project (use --deep for staged project-level discovery)",
         "  /gsd quick          Execute a quick task without full planning overhead",
         "  /gsd dispatch       Dispatch a specific phase directly  [research|plan|execute|complete|uat|replan]",
+        "  /gsd verdict <v>    Override milestone validation verdict  [pass|needs-attention|needs-remediation] [--milestone Mxxx] [--rationale \"...\"]",
         "  /gsd parallel       Parallel milestone orchestration  [start|status|stop|pause|resume|merge|watch]",
         "  /gsd workflow       Custom workflow lifecycle  [new|run|list|validate|pause|resume]",
         "",

package/dist/resources/extensions/gsd/commands/handlers/ops.js

@@ -183,6 +183,11 @@ Examples:
         await dispatchDirectPhase(ctx, pi, phase, projectRoot());
         return true;
     }
+    if (trimmed === "verdict" || trimmed.startsWith("verdict ")) {
+        const { handleVerdict } = await import("../../commands-verdict.js");
+        await handleVerdict(trimmed.replace(/^verdict\s*/, "").trim(), ctx, projectRoot());
+        return true;
+    }
     if (trimmed === "notifications" || trimmed.startsWith("notifications ")) {
         const { handleNotificationsCommand } = await import("./notifications-handler.js");
         await handleNotificationsCommand(trimmed.replace(/^notifications\s*/, "").trim(), ctx, pi);

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -571,10 +571,15 @@ async function configureModels(ctx, prefs) {
     ];
     const models = prefs.models ?? {};
     const availableModels = ctx.modelRegistry.getAvailable();
-    if (availableModels.length > 0) {
+    const getAllWithDiscovered = ctx.modelRegistry.getAllWithDiscovered;
+    const availableProviders = new Set(availableModels.map((m) => m.provider));
+    const selectableModels = typeof getAllWithDiscovered === "function"
+        ? getAllWithDiscovered().filter((m) => availableProviders.has(m.provider))
+        : availableModels;
+    if (selectableModels.length > 0) {
         // Group models by provider, sorted alphabetically
         const byProvider = new Map();
-        for (const m of availableModels) {
+        for (const m of selectableModels) {
             let group = byProvider.get(m.provider);
             if (!group) {
                 group = [];

package/dist/resources/extensions/gsd/commands-verdict.js

@@ -0,0 +1,139 @@
+import { loadFile } from "./files.js";
+import { resolveMilestoneFile } from "./paths.js";
+import { deriveState } from "./state.js";
+import { executeValidateMilestone } from "./tools/workflow-tool-executors.js";
+import { VALIDATION_VERDICTS, extractVerdict, isValidMilestoneVerdict, } from "./verdict-parser.js";
+const USAGE = 'Usage: /gsd verdict <pass|needs-attention|needs-remediation> [--milestone Mxxx] [--rationale "..."]';
+function tokenize(raw) {
+    const tokens = [];
+    const re = /"([^"]*)"|(\S+)/g;
+    let match;
+    while ((match = re.exec(raw)) !== null) {
+        tokens.push(match[1] ?? match[2]);
+    }
+    return tokens;
+}
+function parseArgs(raw) {
+    const tokens = tokenize(raw);
+    const out = {};
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t === "--milestone") {
+            const next = tokens[++i];
+            if (!next)
+                return { error: "--milestone requires a milestone ID" };
+            out.milestoneId = next;
+        }
+        else if (t === "--rationale") {
+            const next = tokens[++i];
+            if (next == null)
+                return { error: "--rationale requires a value" };
+            out.rationale = next;
+        }
+        else if (!out.verdict) {
+            if (!isValidMilestoneVerdict(t)) {
+                return {
+                    error: `Invalid verdict "${t}". Must be one of: ${VALIDATION_VERDICTS.join(", ")}`,
+                };
+            }
+            out.verdict = t;
+        }
+        else {
+            return { error: `Unexpected argument: ${t}` };
+        }
+    }
+    return out;
+}
+function extractRemediationRound(content) {
+    const fm = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fm)
+        return 0;
+    const m = fm[1].match(/^remediation_round:\s*(\d+)/im);
+    return m ? Number.parseInt(m[1], 10) : 0;
+}
+function extractSection(content, heading) {
+    const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    // Match section bodies bounded by the next "## " heading or end-of-string.
+    // Leading "\n" prefix lets a single pattern handle first-line headings too.
+    // No /m flag — we want `$` to mean end-of-string, not end-of-line.
+    const re = new RegExp(`\\n## ${escaped}\\s*\\n([\\s\\S]*?)(?=\\n## |$)`);
+    const m = ("\n" + content).match(re);
+    if (!m)
+        return undefined;
+    return m[1].replace(/\s+$/, "");
+}
+export function parseValidationFile(content) {
+    return {
+        verdict: extractVerdict(content),
+        remediationRound: extractRemediationRound(content),
+        successCriteriaChecklist: extractSection(content, "Success Criteria Checklist") ?? "",
+        sliceDeliveryAudit: extractSection(content, "Slice Delivery Audit") ?? "",
+        crossSliceIntegration: extractSection(content, "Cross-Slice Integration") ?? "",
+        requirementCoverage: extractSection(content, "Requirement Coverage") ?? "",
+        verificationClasses: extractSection(content, "Verification Class Compliance"),
+        verdictRationale: extractSection(content, "Verdict Rationale") ?? "",
+        remediationPlan: extractSection(content, "Remediation Plan"),
+    };
+}
+export async function handleVerdict(rawArgs, ctx, basePath) {
+    if (!rawArgs.trim()) {
+        ctx.ui.notify(USAGE, "warning");
+        return;
+    }
+    const parsed = parseArgs(rawArgs);
+    if ("error" in parsed) {
+        ctx.ui.notify(`${parsed.error}\n${USAGE}`, "warning");
+        return;
+    }
+    if (!parsed.verdict) {
+        ctx.ui.notify(USAGE, "warning");
+        return;
+    }
+    let milestoneId = parsed.milestoneId;
+    if (!milestoneId) {
+        const state = await deriveState(basePath);
+        if (!state.activeMilestone) {
+            ctx.ui.notify("No active milestone — pass --milestone Mxxx to target a specific milestone.", "warning");
+            return;
+        }
+        milestoneId = state.activeMilestone.id;
+    }
+    const validationPath = resolveMilestoneFile(basePath, milestoneId, "VALIDATION");
+    if (!validationPath) {
+        ctx.ui.notify(`No VALIDATION file found for ${milestoneId}. Run gsd_validate_milestone first to produce one.`, "warning");
+        return;
+    }
+    const existing = await loadFile(validationPath);
+    if (!existing) {
+        ctx.ui.notify(`Could not read VALIDATION file for ${milestoneId} (${validationPath}).`, "warning");
+        return;
+    }
+    const current = parseValidationFile(existing);
+    if (parsed.verdict !== "pass" && !parsed.rationale) {
+        ctx.ui.notify(`--rationale is required when overriding to ${parsed.verdict}.`, "warning");
+        return;
+    }
+    const verdictRationale = parsed.rationale ?? "Manually overridden via /gsd verdict";
+    const result = await executeValidateMilestone({
+        milestoneId,
+        verdict: parsed.verdict,
+        remediationRound: current.remediationRound,
+        successCriteriaChecklist: current.successCriteriaChecklist,
+        sliceDeliveryAudit: current.sliceDeliveryAudit,
+        crossSliceIntegration: current.crossSliceIntegration,
+        requirementCoverage: current.requirementCoverage,
+        verificationClasses: current.verificationClasses,
+        verdictRationale,
+        remediationPlan: current.remediationPlan,
+    }, basePath);
+    if (result.isError) {
+        const msg = result.content[0]?.type === "text" ? result.content[0].text : "Unknown error";
+        ctx.ui.notify(msg, "error");
+        return;
+    }
+    const prevVerdict = current.verdict ?? "unknown";
+    ctx.ui.notify(`Milestone ${milestoneId} verdict: ${prevVerdict} -> ${parsed.verdict}`, "success");
+    if (parsed.verdict === "needs-remediation") {
+        ctx.ui.notify("Follow up with gsd_reassess_roadmap to add remediation slices, then re-run /gsd auto.", "info");
+    }
+}

package/dist/resources/extensions/gsd/crash-recovery.js

@@ -23,7 +23,8 @@
 import { emitJournalEvent, queryJournal, } from "./journal.js";
 import { readFileSync, unlinkSync, existsSync } from "node:fs";
 import { join } from "node:path";
-import { findStaleWorkerForProject, getAllAutoWorkers, markWorkerCrashed, } from "./db/auto-workers.js";
+import { findStaleWorkerForProject, getAllAutoWorkers, markWorkerCrashed, markWorkerStopping, } from "./db/auto-workers.js";
+import { forceReleaseLeasesForWorker } from "./db/milestone-leases.js";
 import { markLatestActiveForWorkerCanceled } from "./db/unit-dispatches.js";
 import { getRuntimeKv, setRuntimeKv, deleteRuntimeKv } from "./db/runtime-kv.js";
 import { _getAdapter, isDbAvailable } from "./gsd-db.js";
@@ -182,10 +183,21 @@ export function clearLock(basePath) {
         return;
     try {
         const projectRoot = normalizeRealPath(basePath);
-        const worker = findActiveWorkerForCurrentProcess(projectRoot);
-        if (!worker)
+        const staleWorker = findStaleWorkerForProject(projectRoot);
+        if (staleWorker) {
+            markWorkerCrashed(staleWorker.worker_id);
+            forceReleaseLeasesForWorker(staleWorker.worker_id);
+            deleteRuntimeKv("worker", staleWorker.worker_id, SESSION_FILE_KV_KEY);
             return;
-        deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
+        }
+        const worker = findActiveWorkerForCurrentProcess(projectRoot);
+        if (worker)
+            deleteRuntimeKv("worker", worker.worker_id, SESSION_FILE_KV_KEY);
+        const stale = findStaleWorkerForProject(projectRoot);
+        if (stale) {
+            markWorkerStopping(stale.worker_id);
+            deleteRuntimeKv("worker", stale.worker_id, SESSION_FILE_KV_KEY);
+        }
     }
     catch {
         // Best-effort.

package/dist/resources/extensions/gsd/db/milestone-leases.js

@@ -193,6 +193,30 @@ export function releaseMilestoneLease(workerId, milestoneId, fencingToken) {
         return changes === 1;
     });
 }
+/**
+ * Force-release all held leases for a worker.
+ *
+ * Used by crash recovery once PID liveness has confirmed the worker is dead.
+ * No fencing token is required because this path is cleanup-only for a
+ * non-running process.
+ */
+export function forceReleaseLeasesForWorker(workerId) {
+    if (!isDbAvailable())
+        return 0;
+    const db = _getAdapter();
+    let changes = 0;
+    transaction(() => {
+        const result = db.prepare(`UPDATE milestone_leases
+       SET status = 'released'
+       WHERE worker_id = :worker_id
+         AND status = 'held'`).run({ ":worker_id": workerId });
+        changes =
+            typeof result.changes === "number"
+                ? result.changes
+                : 0;
+    });
+    return changes;
+}
 /**
  * Read current lease row for diagnostics. Returns null if no row exists.
  */

package/dist/resources/extensions/gsd/forensics.js

@@ -677,7 +677,7 @@ export function detectWorktreeOrphans(summary, anomalies) {
             type: "worktree-unmerged-exit",
             severity: "warning",
             summary: `${summary.exitsWithUnmergedWork} auto-exit(s) left milestone work unmerged`,
-            details: `Exit reasons: ${reasonBreakdown || "(none)"} · Producer-side signal for #4761-class orphans. Inspect .gsd/journal/*.jsonl with eventType:"auto-exit" for per-exit detail.`,
+            details: `Exit reasons: ${reasonBreakdown || "(none)"} · Producer-side signal for orphaned worktrees. Inspect .gsd/journal/*.jsonl with eventType:"auto-exit" for per-exit detail.`,
         });
     }
 }
@@ -884,7 +884,7 @@ function saveForensicReport(basePath, report, problemDescription) {
                 .map(([r, n]) => `${r}=${n}`).join(", ");
             sections.push(`  - Exit reasons: ${breakdown}`);
         }
-        sections.push(`- Canonical-root redirects (#4761 fix fired): ${t.canonicalRedirects}`);
+        sections.push(`- Canonical-root redirects: ${t.canonicalRedirects}`);
         // #4765 slice-cadence counters
         if (t.slicesMerged + t.sliceMergeConflicts + t.milestoneResquashes > 0) {
             sections.push(`- Slices merged: ${t.slicesMerged} · Slice merge conflicts: ${t.sliceMergeConflicts}`);
@@ -1033,7 +1033,7 @@ function formatReportForPrompt(report) {
         if (hasSignal) {
             sections.push("### Worktree Telemetry");
             sections.push(`- Created: ${t.worktreesCreated} · Merged: ${t.worktreesMerged} · Conflicts: ${t.mergeConflicts}`);
-            sections.push(`- Orphans: ${t.orphansDetected} · Unmerged exits: ${t.exitsWithUnmergedWork} · Redirects (#4761): ${t.canonicalRedirects}`);
+            sections.push(`- Orphans: ${t.orphansDetected} · Unmerged exits: ${t.exitsWithUnmergedWork} · Redirects: ${t.canonicalRedirects}`);
             if (t.orphansDetected > 0) {
                 const breakdown = Object.entries(t.orphansByReason)
                     .map(([r, n]) => `${r}=${n}`).join(", ");

package/dist/resources/extensions/gsd/git-service.js

@@ -237,6 +237,8 @@ export function readIntegrationBranch(basePath, milestoneId) {
         return null;
     }
 }
+/** Re-export for backward compatibility — canonical definitions in branch-patterns.ts */
+export { QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
 /**
  * Persist the integration branch for a milestone.
  *
@@ -247,9 +249,11 @@ export function readIntegrationBranch(basePath, milestoneId) {
  *
  * The file is committed immediately so the metadata is persisted in git.
  */
-/** Re-export for backward compatibility — canonical definitions in branch-patterns.ts */
-export { QUICK_BRANCH_RE, WORKFLOW_BRANCH_RE } from "./branch-patterns.js";
 export function writeIntegrationBranch(basePath, milestoneId, branch) {
+    // Never persist milestone branches as integration targets.
+    // They are ephemeral execution branches and can cause self-diff corruption.
+    if (branch.startsWith("milestone/"))
+        return;
     // Don't record slice branches as the integration target
     if (SLICE_BRANCH_RE.test(branch))
         return;

package/dist/resources/extensions/gsd/gsd-db.js

@@ -54,18 +54,19 @@ const providerLoader = createSqliteProviderLoader({
     writeStderr: (message) => process.stderr.write(message),
 });
 export const SCHEMA_VERSION = 28;
-function initSchema(db, fileBacked) {
+function initSchema(db, fileBacked, dbPath) {
+    const conservativeFilePragmas = fileBacked && _isLikelyWslDrvFsPathForTest(dbPath);
     if (fileBacked)
-        db.exec("PRAGMA journal_mode=WAL");
+        db.exec(conservativeFilePragmas ? "PRAGMA journal_mode=DELETE" : "PRAGMA journal_mode=WAL");
     if (fileBacked)
         db.exec("PRAGMA busy_timeout = 5000");
     if (fileBacked)
-        db.exec("PRAGMA synchronous = NORMAL");
+        db.exec(conservativeFilePragmas ? "PRAGMA synchronous = FULL" : "PRAGMA synchronous = NORMAL");
     if (fileBacked)
         db.exec("PRAGMA auto_vacuum = INCREMENTAL");
     if (fileBacked)
         db.exec("PRAGMA cache_size = -8000"); // 8 MB page cache
-    if (fileBacked && process.platform !== "darwin")
+    if (fileBacked && !conservativeFilePragmas && process.platform !== "darwin")
         db.exec("PRAGMA mmap_size = 67108864"); // 64 MB mmap
     db.exec("PRAGMA temp_store = MEMORY");
     db.exec("PRAGMA foreign_keys = ON");
@@ -99,6 +100,19 @@ function initSchema(db, fileBacked) {
     }
     migrateSchema(db);
 }
+export function _isLikelyWslDrvFsPathForTest(dbPath) {
+    if (!dbPath || process.platform !== "linux")
+        return false;
+    const drvFsPathPattern = /^\/mnt\/[a-z](?:\/|$)/i;
+    if (drvFsPathPattern.test(dbPath))
+        return true;
+    try {
+        return drvFsPathPattern.test(realpathSync(dbPath));
+    }
+    catch {
+        return false;
+    }
+}
 /**
  * Create the FTS5 virtual table for memories plus the triggers that keep it
  * in sync with the base table. FTS5 may be unavailable on stripped-down
@@ -504,7 +518,7 @@ export function openDatabase(path) {
     const adapter = createDbAdapter(rawDb);
     const fileBacked = path !== ":memory:";
     try {
-        initSchema(adapter, fileBacked);
+        initSchema(adapter, fileBacked, path);
     }
     catch (err) {
         // Corrupt freelist: DDL fails with "malformed" but VACUUM can rebuild.
@@ -512,7 +526,7 @@ export function openDatabase(path) {
         if (fileBacked && err instanceof Error && err.message?.includes("malformed")) {
             try {
                 adapter.exec("VACUUM");
-                initSchema(adapter, fileBacked);
+                initSchema(adapter, fileBacked, path);
                 process.stderr.write("gsd-db: recovered corrupt database via VACUUM\n");
             }
             catch (retryErr) {

package/dist/resources/extensions/gsd/guided-flow-queue.js

@@ -18,6 +18,7 @@ import { nativeAddPaths, nativeCommit } from "./native-git-bridge.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { saveQueueOrder } from "./queue-order.js";
 import { findMilestoneIds, nextMilestoneId } from "./milestone-ids.js";
+import { isFutureMilestoneStatus } from "./status-guards.js";
 // ─── Queue Entry Point ──────────────────────────────────────────────────────
 /**
  * Queue future milestones via conversational intake.
@@ -48,7 +49,7 @@ export async function showQueue(ctx, pi, basePath) {
         return;
     }
     // ── Count pending milestones ────────────────────────────────────────
-    const pendingMilestones = state.registry.filter(m => m.status === "pending" || m.status === "active");
+    const pendingMilestones = state.registry.filter(m => isFutureMilestoneStatus(m.status) || m.status === "active");
     const completeCount = state.registry.filter(m => m.status === "complete").length;
     const parkedCount = state.registry.filter(m => m.status === "parked").length;
     // ── If multiple pending milestones, show queue management hub ──────
@@ -140,7 +141,7 @@ export async function showQueueAdd(ctx, pi, basePath, state) {
     const activePart = state.activeMilestone
         ? `Currently executing: ${state.activeMilestone.id} — ${state.activeMilestone.title} (phase: ${state.phase}).`
         : "No milestone currently active.";
-    const pendingCount = state.registry.filter(m => m.status === "pending").length;
+    const pendingCount = state.registry.filter(m => isFutureMilestoneStatus(m.status)).length;
     const completeCount = state.registry.filter(m => m.status === "complete").length;
     const preamble = [
         `Queuing new work onto an existing GSD project.`,
@@ -223,7 +224,7 @@ export async function buildExistingMilestonesContext(basePath, milestoneIds, sta
         }
         // For active/pending/parked milestones, include the roadmap if it exists
         // (shows what's planned but not yet built)
-        if (status === "active" || status === "pending" || status === "parked") {
+        if (status === "active" || isFutureMilestoneStatus(status) || status === "parked") {
             const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
             if (roadmapFile) {
                 const content = await loadFile(roadmapFile);

package/dist/resources/extensions/gsd/guided-flow.js

@@ -30,6 +30,7 @@ import { getIsolationMode, loadEffectiveGSDPreferences } from "./preferences.js"
 import { resolveUokFlags } from "./uok/flags.js";
 import { ensurePlanV2Graph, isMissingFinalizedContextResult } from "./uok/plan-v2.js";
 import { detectProjectState, hasGsdBootstrapArtifacts } from "./detection.js";
+import { isFutureMilestoneStatus } from "./status-guards.js";
 import { showProjectInit, offerMigration } from "./init-wizard.js";
 import { validateDirectory } from "./validate-directory.js";
 import { showConfirm } from "../shared/tui.js";
@@ -811,6 +812,7 @@ async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType,
                     ? ctx.modelRegistry.getProviderAuthMode(ctx.model.provider)
                     : undefined,
             baseUrl: result.appliedModel?.baseUrl ?? ctx.model?.baseUrl,
+            activeTools: typeof pi.getActiveTools === "function" ? pi.getActiveTools() : [],
         });
         if (compatibilityError) {
             ctx.ui.notify(compatibilityError, "error");
@@ -1164,7 +1166,7 @@ export async function showDiscuss(ctx, pi, basePath) {
     // No active milestone (or corrupted milestone with undefined id) —
     // check for pending milestones to discuss instead
     if (!state.activeMilestone?.id) {
-        const pendingMilestones = state.registry.filter(m => m.status === "pending");
+        const pendingMilestones = state.registry.filter(m => isFutureMilestoneStatus(m.status));
         if (pendingMilestones.length === 0) {
             ctx.ui.notify("No active milestone. Run /gsd to create one first.", "warning");
             return;
@@ -1269,7 +1271,7 @@ export async function showDiscuss(ctx, pi, basePath) {
     const pendingSlices = normSlices.filter(s => !s.done);
     if (pendingSlices.length === 0) {
         // All slices complete — but queued milestones may still need discussion (#3150)
-        const pendingMilestones = state.registry.filter(m => m.status === "pending");
+        const pendingMilestones = state.registry.filter(m => isFutureMilestoneStatus(m.status));
         if (pendingMilestones.length > 0) {
             await showDiscussQueuedMilestone(ctx, pi, basePath, pendingMilestones);
             return;
@@ -1290,7 +1292,7 @@ export async function showDiscuss(ctx, pi, basePath) {
         // If all pending slices are discussed, check for queued milestones before exiting (#3150)
         const allDiscussed = pendingSlices.every(s => discussedMap.get(s.id));
         if (allDiscussed) {
-            const pendingMilestones = state.registry.filter(m => m.status === "pending");
+            const pendingMilestones = state.registry.filter(m => isFutureMilestoneStatus(m.status));
             if (pendingMilestones.length > 0) {
                 await showDiscussQueuedMilestone(ctx, pi, basePath, pendingMilestones);
                 return;
@@ -1321,7 +1323,7 @@ export async function showDiscuss(ctx, pi, basePath) {
             };
         });
         // Offer access to queued milestones when any exist
-        const pendingMilestones = state.registry.filter(m => m.status === "pending");
+        const pendingMilestones = state.registry.filter(m => isFutureMilestoneStatus(m.status));
         if (pendingMilestones.length > 0) {
             actions.push({
                 id: "discuss_queued_milestone",
@@ -1385,10 +1387,11 @@ async function showDiscussQueuedMilestone(ctx, pi, basePath, pendingMilestones)
         const hasContext = !!resolveMilestoneFile(basePath, m.id, "CONTEXT");
         const hasDraft = !hasContext && !!resolveMilestoneFile(basePath, m.id, "CONTEXT-DRAFT");
         const contextStatus = hasContext ? "context ✓" : hasDraft ? "draft context" : "no context yet";
+        const statusLabel = m.status === "planned" ? "planned" : "queued";
         return {
             id: m.id,
             label: `${m.id}: ${m.title}`,
-            description: `[queued] · ${contextStatus}`,
+            description: `[${statusLabel}] · ${contextStatus}`,
             recommended: i === 0,
         };
     });

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -14,7 +14,7 @@ import { isClosedStatus } from "./status-guards.js";
 import { join, relative } from "node:path";
 import { createRequire } from "node:module";
 import { getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getTask, getSlice, getArtifact, insertArtifact, getGateResults, } from "./gsd-db.js";
-import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, gsdRoot, buildTaskFileName, buildSliceFileName, } from "./paths.js";
+import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, gsdProjectionRoot, gsdRoot, buildTaskFileName, buildSliceFileName, } from "./paths.js";
 import { saveFile, clearParseCache } from "./files.js";
 import { invalidateStateCache } from "./state.js";
 import { clearPathCache } from "./paths.js";
@@ -24,7 +24,11 @@ import { clearPathCache } from "./paths.js";
  * E.g. "/project/.gsd/milestones/M001/M001-ROADMAP.md" → "milestones/M001/M001-ROADMAP.md"
  */
 function toArtifactPath(absPath, basePath) {
-    const root = gsdRoot(basePath);
+    const projectionRoot = gsdProjectionRoot(basePath);
+    const projectionRel = relative(projectionRoot, absPath);
+    const root = projectionRel && !projectionRel.startsWith("..") && !projectionRel.startsWith("/")
+        ? projectionRoot
+        : gsdRoot(basePath);
     const rel = relative(root, absPath);
     // Normalize to forward slashes for consistent DB keys
     return rel.replace(/\\/g, "/");
@@ -305,10 +309,9 @@ export async function renderPlanFromDb(basePath, milestoneId, sliceId) {
     if (tasks.length === 0) {
         throw new Error(`no tasks found for ${milestoneId}/${sliceId}`);
     }
-    const slicePath = resolveSlicePath(basePath, milestoneId, sliceId)
-        ?? join(gsdRoot(basePath), "milestones", milestoneId, "slices", sliceId);
-    const absPath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN")
-        ?? join(slicePath, `${sliceId}-PLAN.md`);
+    const slicePath = join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId);
+    mkdirSync(slicePath, { recursive: true });
+    const absPath = join(slicePath, `${sliceId}-PLAN.md`);
     const artifactPath = toArtifactPath(absPath, basePath);
     const sliceGates = getGateResults(milestoneId, sliceId, "slice");
     const content = renderSlicePlanMarkdown(slice, tasks, sliceGates);
@@ -329,8 +332,7 @@ export async function renderTaskPlanFromDb(basePath, milestoneId, sliceId, taskI
     if (!task) {
         throw new Error(`task ${milestoneId}/${sliceId}/${taskId} not found`);
     }
-    const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId)
-        ?? join(gsdRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks");
+    const tasksDir = join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks");
     mkdirSync(tasksDir, { recursive: true });
     const absPath = join(tasksDir, buildTaskFileName(taskId, "PLAN"));
     const artifactPath = toArtifactPath(absPath, basePath);