gsd-pi 2.43.0-next.8 → 2.44.0-dev.0b97ffd

package/README.md

@@ -24,10 +24,34 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.42.0
+## What's New in v2.44.0
 
 ### New Features
 
+- **Non-API-key provider extensions** — support for provider extensions like Claude Code CLI that don't require traditional API keys. (#2382)
+- **Docker sandbox template** — official Docker template for running GSD auto mode in an isolated container. (#2360)
+- **Per-prompt token cost display** — opt-in `show_token_cost` preference shows per-prompt and cumulative session cost in the footer. (#2357)
+- **"Change project root" in web UI** — switch project directories from the web interface without restarting. (#2355)
+- **DB-backed planning tools** — write-side state transitions now use atomic SQLite tool calls instead of markdown mutation, improving reliability and enabling structured queries. (#2141)
+
+### Key Fixes
+
+- **Post-migration cleanup** — pragmas, rollbacks, tool gaps, and stale code cleaned up after DB migration. (#2410)
+- **Planning data loss prevention** — destructive upsert and post-unit re-import no longer overwrite planning data. (#2370)
+- **Memory and resource leaks** — fixes across TUI, LSP, DB, and automation subsystems. (#2314)
+- **DECISIONS.md preservation** — freeform content in DECISIONS.md is no longer overwritten on decision save. (#2319)
+- **Auto-stash before squash merge** — dirty files are automatically stashed before merge, with filenames surfaced in errors. (#2298)
+- **Extension TypeScript detection** — `.js` extension files containing TypeScript syntax are detected with a suggestion to rename. (#2386)
+
+### v2.43.0 Highlights
+
+- **Forensics dedup** — opt-in duplicate detection before issue creation. (#2105)
+- **Fast service tier outside auto-mode** — `/gsd fast` now applies in interactive sessions too. (#2126)
+- **Startup optimizations** — pre-compiled extensions, compile cache, and batch discovery for faster boot. (#2125)
+- **Stale process cleanup** — web server kills stale process before launch to prevent EADDRINUSE. (#2034)
+
+### v2.42.0 Highlights
+
 - **Declarative workflow engine** — define YAML workflows that execute through auto-loop, enabling repeatable multi-step automations without code. (#2024)
 - **Unified rule registry & event journal** — centralized rule registry, event journal with query tool, and standardized tool naming convention. (#1928)
 - **PR risk checker** — CI classifies changed files by system area and surfaces risk level on pull requests. (#1930)
@@ -35,16 +59,6 @@ One command. Walk away. Come back to a built project with clean git history.
 - **Web mode CLI flags** — `--host`, `--port`, and `--allowed-origins` flags give full control over the web server bind address and CORS policy. (#1873)
 - **ADR attribution** — architecture decision records now distinguish human, agent, and collaborative authorship. (#1830)
 
-### Key Fixes
-
-- **Node v24 web boot** — resolved `ERR_UNSUPPORTED_NODE_MODULES_TYPE_STRIPPING` that prevented `gsd --web` from starting on Node v24. (#1864)
-- **Worktree health check for all ecosystems** — broadened from JS-only to 17+ ecosystems (Rust, Go, Python, Java, etc.). (#1860)
-- **Doctor roadmap atomicity** — roadmap checkbox gating now checks summary on disk, not issue detection, preventing false unchecks. (#1915)
-- **Windows path handling** — 8.3 short path resolution, backslash normalization in bash commands, PowerShell browser launch, and parenthesis escaping. (#1960, #1863, #1870, #1872)
-- **Auth token persistence** — web UI auth token survives page refreshes via sessionStorage. (#1877)
-- **German/non-English locale git errors** — git commands now force `LC_ALL=C` to prevent locale-dependent parse failures.
-- **Orphan web server process** — stale web server processes on port 3000 are now cleaned up automatically.
-
 ---
 
 ## What's New in v2.41.0
@@ -107,12 +121,14 @@ This release includes 7 fixes preventing silent data loss in auto-mode:
 
 See the full [Changelog](./CHANGELOG.md) for all 70+ fixes in this release.
 
-### Previous highlights (v2.39–v2.40)
+### Previous highlights (v2.39–v2.41)
 
+- **Browser-based web interface** — run GSD from the browser with `gsd --web`
 - **GitHub sync extension** — auto-sync milestones to GitHub Issues, PRs, and Milestones
 - **Skill tool resolution** — skills auto-activate in dispatched prompts
 - **Health check phase 2** — real-time doctor issues in dashboard and visualizer
 - **Forensics upgrade** — full-access GSD debugger with anomaly detection
+- **7 data-loss prevention fixes** — hallucination guard, merge anchor verification, dirty tree detection, and more
 - **Pipeline decomposition** — auto-loop rewritten as linear phase pipeline
 - **Sliding-window stuck detection** — pattern-aware, fewer false positives
 - **Data-loss recovery** — automatic detection and recovery from v2.30–v2.38 migration issues
@@ -141,7 +157,9 @@ Full documentation is available in the [`docs/`](./docs/) directory:
 - **[Visualizer](./docs/visualizer.md)** — workflow visualizer with stats and discussion status
 - **[Remote Questions](./docs/remote-questions.md)** — route decisions to Slack or Discord when human input is needed
 - **[Dynamic Model Routing](./docs/dynamic-model-routing.md)** — complexity-based model selection and budget pressure
+- **[Web Interface](./docs/web-interface.md)** — browser-based project management and real-time progress
 - **[Pipeline Simplification (ADR-003)](./docs/ADR-003-pipeline-simplification.md)** — merged research into planning, mechanical completion
+- **[Docker Sandbox](./docker/README.md)** — run GSD auto mode in an isolated Docker container
 - **[Migration from v1](./docs/migration.md)** — `.planning` → `.gsd` migration
 
 ---

package/dist/cli.js

@@ -1,4 +1,4 @@
-import { AuthStorage, DefaultResourceLoader, ModelRegistry, SettingsManager, SessionManager, createAgentSession, InteractiveMode, runPrintMode, runRpcMode, } from '@gsd/pi-coding-agent';
+import { AuthStorage, DefaultResourceLoader, ModelRegistry, runPackageCommand, SettingsManager, SessionManager, createAgentSession, InteractiveMode, runPrintMode, runRpcMode, } from '@gsd/pi-coding-agent';
 import { readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { agentDir, sessionsDir, authFilePath } from './app-paths.js';
@@ -121,6 +121,18 @@ if (subcommand && process.argv.includes('--help')) {
         process.exit(0);
     }
 }
+const packageCommand = await runPackageCommand({
+    appName: 'gsd',
+    args: process.argv.slice(2),
+    cwd: process.cwd(),
+    agentDir,
+    stdout: process.stdout,
+    stderr: process.stderr,
+    allowedCommands: new Set(['install', 'remove', 'list']),
+});
+if (packageCommand.handled) {
+    process.exit(packageCommand.exitCode);
+}
 // `gsd config` — replay the setup wizard and exit
 if (cliFlags.messages[0] === 'config') {
     const authStorage = AuthStorage.create(authFilePath);

package/dist/help-text.js

@@ -29,6 +29,27 @@ const SUBCOMMAND_HELP = {
         '',
         'Compare with --continue (-c) which always resumes the most recent session.',
     ].join('\n'),
+    install: [
+        'Usage: gsd install <source> [-l, --local]',
+        '',
+        'Install a package/extension source and run declared lifecycle hooks.',
+        '',
+        'Examples:',
+        '  gsd install npm:@foo/bar',
+        '  gsd install git:github.com/user/repo',
+        '  gsd install https://github.com/user/repo',
+        '  gsd install ./local/path',
+    ].join('\n'),
+    remove: [
+        'Usage: gsd remove <source> [-l, --local]',
+        '',
+        'Remove an installed package source and its settings entry.',
+    ].join('\n'),
+    list: [
+        'Usage: gsd list',
+        '',
+        'List installed package sources from user and project settings.',
+    ].join('\n'),
     worktree: [
         'Usage: gsd worktree <command> [args]',
         '',
@@ -122,6 +143,9 @@ export function printHelp(version) {
     process.stdout.write('  --help, -h               Print this help and exit\n');
     process.stdout.write('\nSubcommands:\n');
     process.stdout.write('  config                   Re-run the setup wizard\n');
+    process.stdout.write('  install <source>         Install a package/extension source\n');
+    process.stdout.write('  remove <source>          Remove an installed package source\n');
+    process.stdout.write('  list                     List installed package sources\n');
     process.stdout.write('  update                   Update GSD to the latest version\n');
     process.stdout.write('  sessions                 List and resume a past session\n');
     process.stdout.write('  worktree <cmd>           Manage worktrees (list, merge, clean, remove)\n');

package/dist/resources/extensions/gsd/auto-direct-dispatch.js

@@ -5,7 +5,8 @@
 import { deriveState } from "./state.js";
 import { loadFile } from "./files.js";
 import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
-import { resolveSliceFile, relSliceFile, } from "./paths.js";
+import { parseRoadmap } from "./parsers-legacy.js";
+import { resolveMilestoneFile, resolveSliceFile, relSliceFile, } from "./paths.js";
 import { buildResearchSlicePrompt, buildResearchMilestonePrompt, buildPlanSlicePrompt, buildPlanMilestonePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildReassessRoadmapPrompt, buildRunUatPrompt, buildReplanSlicePrompt, } from "./auto-prompts.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { pauseAuto } from "./auto.js";
@@ -118,14 +119,20 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
         }
         case "reassess":
         case "reassess-roadmap": {
-            // DB primary path — get completed slices
+            // DB primary path — get completed slices, fall back to file parsing when DB has no data
             let completedSliceIds = [];
             if (isDbAvailable()) {
                 completedSliceIds = getMilestoneSlices(mid).filter(s => s.status === "complete").map(s => s.id);
             }
-            else {
-                ctx.ui.notify("Cannot dispatch reassess-roadmap: DB unavailable.", "warning");
-                return;
+            if (completedSliceIds.length === 0) {
+                // File-based fallback: parse roadmap checkboxes
+                const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+                if (roadmapPath) {
+                    const roadmapContent = await loadFile(roadmapPath);
+                    if (roadmapContent) {
+                        completedSliceIds = parseRoadmap(roadmapContent).slices.filter(s => s.done).map(s => s.id);
+                    }
+                }
             }
             if (completedSliceIds.length === 0) {
                 ctx.ui.notify("Cannot dispatch reassess-roadmap: no completed slices.", "warning");
@@ -147,9 +154,15 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             if (isDbAvailable()) {
                 uatCompletedSliceIds = getMilestoneSlices(mid).filter(s => s.status === "complete").map(s => s.id);
             }
-            else {
-                ctx.ui.notify("Cannot dispatch run-uat: DB unavailable.", "warning");
-                return;
+            if (uatCompletedSliceIds.length === 0) {
+                // File-based fallback: parse roadmap checkboxes
+                const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+                if (roadmapPath) {
+                    const roadmapContent = await loadFile(roadmapPath);
+                    if (roadmapContent) {
+                        uatCompletedSliceIds = parseRoadmap(roadmapContent).slices.filter(s => s.done).map(s => s.id);
+                    }
+                }
             }
             if (uatCompletedSliceIds.length === 0) {
                 ctx.ui.notify("Cannot dispatch run-uat: no completed slices.", "warning");

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

@@ -9,6 +9,7 @@ import { loadFile, parseContinue, parseSummary, extractUatType, loadActiveOverri
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
 import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences, resolveAllSkillReferences } from "./preferences.js";
+import { parseRoadmap } from "./parsers-legacy.js";
 import { getLoadedSkills } from "@gsd/pi-coding-agent";
 import { join, basename } from "node:path";
 import { existsSync } from "node:fs";
@@ -145,15 +146,31 @@ export async function inlineDependencySummaries(mid, sid, base, budgetChars) {
         const { isDbAvailable, getSlice } = await import("./gsd-db.js");
         if (isDbAvailable()) {
             const slice = getSlice(mid, sid);
-            if (!slice || slice.depends.length === 0)
-                return "- (no dependencies)";
-            depends = slice.depends;
+            if (slice) {
+                if (slice.depends.length === 0)
+                    return "- (no dependencies)";
+                depends = slice.depends;
+            }
+            // If slice not found in DB, fall through to file-based parsing
         }
     }
     catch { /* fall through */ }
-    // If DB didn't provide depends, we can't determine them without parsers
+    // If DB didn't provide depends, fall back to roadmap parsing
     if (!depends) {
-        return "- (no dependencies)";
+        const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+        if (roadmapPath) {
+            const roadmapContent = await loadFile(roadmapPath);
+            if (roadmapContent) {
+                const parsed = parseRoadmap(roadmapContent);
+                const slice = parsed.slices.find(s => s.id === sid);
+                if (slice && slice.depends.length > 0) {
+                    depends = slice.depends;
+                }
+            }
+        }
+        if (!depends) {
+            return "- (no dependencies)";
+        }
     }
     const sections = [];
     const seen = new Set();
@@ -565,32 +582,52 @@ export async function getDependencyTaskSummaryPaths(mid, sid, currentTid, depend
  * - All slices are complete (milestone done — no point reassessing)
  */
 export async function checkNeedsReassessment(base, mid, state) {
-    // DB primary path
-    let completedSliceIds = [];
-    let hasIncomplete = false;
+    // DB primary path — fall through to file-based when DB has no data for this milestone
     try {
         const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
         if (isDbAvailable()) {
             const slices = getMilestoneSlices(mid);
-            completedSliceIds = slices.filter(s => s.status === "complete").map(s => s.id);
-            hasIncomplete = slices.some(s => s.status !== "complete");
-            if (completedSliceIds.length === 0 || !hasIncomplete)
-                return null;
-            const lastCompleted = completedSliceIds[completedSliceIds.length - 1];
-            const assessmentFile = resolveSliceFile(base, mid, lastCompleted, "ASSESSMENT");
-            const hasAssessment = !!(assessmentFile && await loadFile(assessmentFile));
-            if (hasAssessment)
-                return null;
-            const summaryFile = resolveSliceFile(base, mid, lastCompleted, "SUMMARY");
-            const hasSummary = !!(summaryFile && await loadFile(summaryFile));
-            if (!hasSummary)
-                return null;
-            return { sliceId: lastCompleted };
+            if (slices.length > 0) {
+                const completedSliceIds = slices.filter(s => s.status === "complete").map(s => s.id);
+                const hasIncomplete = slices.some(s => s.status !== "complete");
+                if (completedSliceIds.length === 0 || !hasIncomplete)
+                    return null;
+                const lastCompleted = completedSliceIds[completedSliceIds.length - 1];
+                const assessmentFile = resolveSliceFile(base, mid, lastCompleted, "ASSESSMENT");
+                const hasAssessment = !!(assessmentFile && await loadFile(assessmentFile));
+                if (hasAssessment)
+                    return null;
+                const summaryFile = resolveSliceFile(base, mid, lastCompleted, "SUMMARY");
+                const hasSummary = !!(summaryFile && await loadFile(summaryFile));
+                if (!hasSummary)
+                    return null;
+                return { sliceId: lastCompleted };
+            }
         }
     }
     catch { /* fall through */ }
-    // DB unavailable — cannot determine assessment needs
-    return null;
+    // File-based fallback using roadmap checkboxes
+    const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+    if (!roadmapPath)
+        return null;
+    const roadmapContent = await loadFile(roadmapPath);
+    if (!roadmapContent)
+        return null;
+    const parsed = parseRoadmap(roadmapContent);
+    const fileCompletedIds = parsed.slices.filter(s => s.done).map(s => s.id);
+    const fileHasIncomplete = parsed.slices.some(s => !s.done);
+    if (fileCompletedIds.length === 0 || !fileHasIncomplete)
+        return null;
+    const lastDone = fileCompletedIds[fileCompletedIds.length - 1];
+    const assessFile = resolveSliceFile(base, mid, lastDone, "ASSESSMENT");
+    const hasAssess = !!(assessFile && await loadFile(assessFile));
+    if (hasAssess)
+        return null;
+    const summFile = resolveSliceFile(base, mid, lastDone, "SUMMARY");
+    const hasSumm = !!(summFile && await loadFile(summFile));
+    if (!hasSumm)
+        return null;
+    return { sliceId: lastDone };
 }
 /**
  * Check if the most recently completed slice needs a UAT run.
@@ -604,40 +641,70 @@ export async function checkNeedsReassessment(base, mid, state) {
  * - UAT result file already exists (idempotent — already ran)
  */
 export async function checkNeedsRunUat(base, mid, state, prefs) {
-    // DB primary path
+    // DB primary path — fall through to file-based when DB has no data for this milestone
     try {
         const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
         if (isDbAvailable()) {
             const slices = getMilestoneSlices(mid);
-            const completedSlices = slices.filter(s => s.status === "complete");
-            const incompleteSlices = slices.filter(s => s.status !== "complete");
-            if (completedSlices.length === 0)
-                return null;
-            if (incompleteSlices.length === 0)
-                return null;
-            if (!prefs?.uat_dispatch)
-                return null;
-            const lastCompleted = completedSlices[completedSlices.length - 1];
-            const sid = lastCompleted.id;
-            const uatFile = resolveSliceFile(base, mid, sid, "UAT");
-            if (!uatFile)
-                return null;
-            const uatContent = await loadFile(uatFile);
-            if (!uatContent)
-                return null;
-            const uatResultFile = resolveSliceFile(base, mid, sid, "UAT-RESULT");
-            if (uatResultFile) {
-                const hasResult = !!(await loadFile(uatResultFile));
-                if (hasResult)
+            if (slices.length > 0) {
+                const completedSlices = slices.filter(s => s.status === "complete");
+                const incompleteSlices = slices.filter(s => s.status !== "complete");
+                if (completedSlices.length === 0)
+                    return null;
+                if (incompleteSlices.length === 0)
                     return null;
+                if (!prefs?.uat_dispatch)
+                    return null;
+                const lastCompleted = completedSlices[completedSlices.length - 1];
+                const sid = lastCompleted.id;
+                const uatFile = resolveSliceFile(base, mid, sid, "UAT");
+                if (!uatFile)
+                    return null;
+                const uatContent = await loadFile(uatFile);
+                if (!uatContent)
+                    return null;
+                const uatResultFile = resolveSliceFile(base, mid, sid, "UAT-RESULT");
+                if (uatResultFile) {
+                    const hasResult = !!(await loadFile(uatResultFile));
+                    if (hasResult)
+                        return null;
+                }
+                const uatType = extractUatType(uatContent) ?? "artifact-driven";
+                return { sliceId: sid, uatType };
             }
-            const uatType = extractUatType(uatContent) ?? "artifact-driven";
-            return { sliceId: sid, uatType };
         }
     }
     catch { /* fall through */ }
-    // DB unavailable — cannot determine UAT needs
-    return null;
+    // File-based fallback using roadmap checkboxes
+    if (!prefs?.uat_dispatch)
+        return null;
+    const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+    if (!roadmapPath)
+        return null;
+    const roadmapContent = await loadFile(roadmapPath);
+    if (!roadmapContent)
+        return null;
+    const parsed = parseRoadmap(roadmapContent);
+    const completedFileSlices = parsed.slices.filter(s => s.done);
+    const incompleteFileSlices = parsed.slices.filter(s => !s.done);
+    if (completedFileSlices.length === 0 || incompleteFileSlices.length === 0)
+        return null;
+    const lastCompletedFile = completedFileSlices[completedFileSlices.length - 1];
+    const uatSid = lastCompletedFile.id;
+    const uatFileFb = resolveSliceFile(base, mid, uatSid, "UAT");
+    if (!uatFileFb)
+        return null;
+    const uatContentFb = await loadFile(uatFileFb);
+    if (!uatContentFb)
+        return null;
+    const uatResultFb = resolveSliceFile(base, mid, uatSid, "UAT-RESULT");
+    if (uatResultFb) {
+        const hasResultFb = !!(await loadFile(uatResultFb));
+        if (hasResultFb)
+            return null;
+    }
+    const uatTypeFb = extractUatType(uatContentFb) ?? "artifact-driven";
+    return { sliceId: uatSid, uatType: uatTypeFb };
 }
 // ─── Prompt Builders ──────────────────────────────────────────────────────
 /**
@@ -1042,7 +1109,13 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
         }
     }
     catch { /* fall through */ }
-    // If DB didn't provide slice IDs, sliceIds stays empty — no summaries to inline
+    // File-based fallback: parse roadmap for slice IDs when DB has no data
+    if (sliceIds.length === 0 && roadmapPath) {
+        const roadmapContent = await loadFile(roadmapPath);
+        if (roadmapContent) {
+            sliceIds = parseRoadmap(roadmapContent).slices.map(s => s.id);
+        }
+    }
     const seenSlices = new Set();
     for (const sid of sliceIds) {
         if (seenSlices.has(sid))
@@ -1100,7 +1173,13 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
         }
     }
     catch { /* fall through */ }
-    // If DB didn't provide slice IDs, valSliceIds stays empty
+    // File-based fallback: parse roadmap for slice IDs when DB has no data
+    if (valSliceIds.length === 0 && roadmapPath) {
+        const roadmapContent = await loadFile(roadmapPath);
+        if (roadmapContent) {
+            valSliceIds = parseRoadmap(roadmapContent).slices.map(s => s.id);
+        }
+    }
     const seenValSlices = new Set();
     for (const sid of valSliceIds) {
         if (seenValSlices.has(sid))

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

@@ -402,6 +402,16 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 process.stderr.write(`gsd-db: failed to open existing database: ${err.message}\n`);
             }
         }
+        // Gate: abort bootstrap if the DB file exists but the provider is
+        // still unavailable after both open attempts above. Without this,
+        // auto-mode starts but every gsd_task_complete / gsd_slice_complete
+        // call returns "db_unavailable", triggering artifact-retry which
+        // re-dispatches the same task — producing an infinite loop (#2419).
+        if (existsSync(gsdDbPath) && !isDbAvailable()) {
+            ctx.ui.notify("SQLite database exists but failed to open. Auto-mode cannot proceed without a working database provider. " +
+                "Check for corrupt gsd.db or missing native SQLite bindings.", "error");
+            return releaseLockAndReturn();
+        }
         // Initialize metrics
         initMetrics(s.basePath);
         // Initialize routing history

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

@@ -869,7 +869,14 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
             .filter(s => s.status === "complete")
             .map(s => ({ id: s.id, title: s.title }));
     }
-    // When DB unavailable, completedSlices stays empty — commit message will omit slice details
+    // Fallback: parse roadmap content when DB is unavailable
+    if (completedSlices.length === 0 && roadmapContent) {
+        const sliceRe = /- \[x\] \*\*(\w+):\s*(.+?)\*\*/gi;
+        let m;
+        while ((m = sliceRe.exec(roadmapContent)) !== null) {
+            completedSlices.push({ id: m[1], title: m[2] });
+        }
+    }
     // 3. chdir to original base
     const previousCwd = process.cwd();
     process.chdir(originalBasePath_);
@@ -891,7 +898,14 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     }
     // 6. Build rich commit message
     const dbMilestone = getMilestone(milestoneId);
-    const milestoneTitle = (dbMilestone?.title ?? "").replace(/^M\d+:\s*/, "").trim() || milestoneId;
+    let milestoneTitle = (dbMilestone?.title ?? "").replace(/^M\d+:\s*/, "").trim();
+    // Fallback: parse title from roadmap content header (e.g. "# M020: Backend foundation")
+    if (!milestoneTitle && roadmapContent) {
+        const titleMatch = roadmapContent.match(new RegExp(`^#\\s+${milestoneId}:\\s*(.+)`, "m"));
+        if (titleMatch)
+            milestoneTitle = titleMatch[1].trim();
+    }
+    milestoneTitle = milestoneTitle || milestoneId;
     const subject = `feat(${milestoneId}): ${milestoneTitle}`;
     let body = "";
     if (completedSlices.length > 0) {

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

@@ -166,6 +166,11 @@ export async function handleWorkflowCommand(trimmed, ctx, pi) {
         return true;
     }
     if (trimmed === "quick" || trimmed.startsWith("quick ")) {
+        if (isAutoActive()) {
+            ctx.ui.notify("/gsd quick cannot run while auto-mode is active.\n" +
+                "Stop auto-mode first with /gsd stop, then run /gsd quick.", "error");
+            return true;
+        }
         await handleQuick(trimmed.replace(/^quick\s*/, "").trim(), ctx, pi);
         return true;
     }

package/dist/resources/extensions/gsd/dispatch-guard.js

@@ -2,6 +2,8 @@
 import { resolveMilestoneFile } from "./paths.js";
 import { findMilestoneIds } from "./guided-flow.js";
 import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
+import { parseRoadmap } from "./parsers-legacy.js";
+import { readFileSync } from "node:fs";
 const SLICE_DISPATCH_TYPES = new Set([
     "research-slice",
     "plan-slice",
@@ -27,16 +29,38 @@ export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unit
             continue;
         if (resolveMilestoneFile(base, mid, "SUMMARY"))
             continue;
-        if (!isDbAvailable())
-            continue;
-        const rows = getMilestoneSlices(mid);
-        if (rows.length === 0)
-            continue;
-        const slices = rows.map((r) => ({
-            id: r.id,
-            done: r.status === "complete",
-            depends: r.depends ?? [],
-        }));
+        let slices = null;
+        if (isDbAvailable()) {
+            const rows = getMilestoneSlices(mid);
+            if (rows.length > 0) {
+                slices = rows.map((r) => ({
+                    id: r.id,
+                    done: r.status === "complete",
+                    depends: r.depends ?? [],
+                }));
+            }
+        }
+        if (!slices) {
+            // File-based fallback: parse roadmap checkboxes
+            const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+            if (!roadmapPath)
+                continue;
+            let roadmapContent;
+            try {
+                roadmapContent = readFileSync(roadmapPath, "utf-8");
+            }
+            catch {
+                continue;
+            }
+            const parsed = parseRoadmap(roadmapContent);
+            if (parsed.slices.length === 0)
+                continue;
+            slices = parsed.slices.map((s) => ({
+                id: s.id,
+                done: s.done,
+                depends: s.depends ?? [],
+            }));
+        }
         if (mid !== targetMid) {
             const incomplete = slices.find((slice) => !slice.done);
             if (incomplete) {

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

@@ -733,11 +733,13 @@ export async function repairStaleRenders(basePath) {
     for (const entry of staleEntries) {
         if (repairedPaths.has(entry.path))
             continue;
+        // Normalize path separators for cross-platform regex matching
+        const normPath = entry.path.replace(/\\/g, "/");
         try {
             // Determine repair action from the reason
             if (entry.reason.includes("in roadmap")) {
                 // Roadmap checkbox mismatch — extract milestone ID from path
-                const milestoneMatch = entry.path.match(/milestones\/([^/]+)\//);
+                const milestoneMatch = normPath.match(/milestones\/([^/]+)\//);
                 if (milestoneMatch) {
                     const ok = await renderRoadmapCheckboxes(basePath, milestoneMatch[1]);
                     if (ok) {
@@ -748,7 +750,7 @@ export async function repairStaleRenders(basePath) {
             }
             else if (entry.reason.includes("in plan")) {
                 // Plan checkbox mismatch — extract milestone + slice IDs from path
-                const pathMatch = entry.path.match(/milestones\/([^/]+)\/slices\/([^/]+)\//);
+                const pathMatch = normPath.match(/milestones\/([^/]+)\/slices\/([^/]+)\//);
                 if (pathMatch) {
                     const ok = await renderPlanCheckboxes(basePath, pathMatch[1], pathMatch[2]);
                     if (ok) {
@@ -759,7 +761,7 @@ export async function repairStaleRenders(basePath) {
             }
             else if (entry.reason.includes("SUMMARY.md missing") && entry.reason.match(/^T\d+/)) {
                 // Missing task summary — extract IDs from path
-                const pathMatch = entry.path.match(/milestones\/([^/]+)\/slices\/([^/]+)\/tasks\//);
+                const pathMatch = normPath.match(/milestones\/([^/]+)\/slices\/([^/]+)\/tasks\//);
                 const taskMatch = entry.reason.match(/^(T\d+)/);
                 if (pathMatch && taskMatch) {
                     const ok = await renderTaskSummary(basePath, pathMatch[1], pathMatch[2], taskMatch[1]);
@@ -771,7 +773,7 @@ export async function repairStaleRenders(basePath) {
             }
             else if (entry.reason.includes("SUMMARY.md missing") && entry.reason.match(/^S\d+/)) {
                 // Missing slice summary — extract IDs from path
-                const pathMatch = entry.path.match(/milestones\/([^/]+)\/slices\/([^/]+)\//);
+                const pathMatch = normPath.match(/milestones\/([^/]+)\/slices\/([^/]+)\//);
                 if (pathMatch) {
                     const ok = await renderSliceSummary(basePath, pathMatch[1], pathMatch[2]);
                     if (ok) {
@@ -782,7 +784,7 @@ export async function repairStaleRenders(basePath) {
             }
             else if (entry.reason.includes("UAT.md missing")) {
                 // Missing slice UAT — renderSliceSummary handles both SUMMARY + UAT
-                const pathMatch = entry.path.match(/milestones\/([^/]+)\/slices\/([^/]+)\//);
+                const pathMatch = normPath.match(/milestones\/([^/]+)\/slices\/([^/]+)\//);
                 if (pathMatch) {
                     const ok = await renderSliceSummary(basePath, pathMatch[1], pathMatch[2]);
                     if (ok) {

package/dist/resources/extensions/gsd/reactive-graph.js

@@ -10,6 +10,7 @@
  */
 import { loadFile, parseTaskPlanIO } from "./files.js";
 import { isDbAvailable, getSliceTasks } from "./gsd-db.js";
+import { parsePlan } from "./parsers-legacy.js";
 import { resolveTasksDir, resolveTaskFiles } from "./paths.js";
 import { join } from "node:path";
 import { loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
@@ -165,8 +166,18 @@ export async function loadSliceTaskIO(basePath, mid, sid) {
     }
     catch { /* fall through */ }
     if (!taskEntries) {
-        // DB unavailable — cannot determine task graph
-        return [];
+        // File-based fallback: parse slice plan for task entries
+        const parsed = parsePlan(planContent);
+        if (parsed.tasks.length > 0) {
+            taskEntries = parsed.tasks.map(t => ({
+                id: t.id,
+                title: t.title,
+                done: t.done,
+            }));
+        }
+        else {
+            return [];
+        }
     }
     const tDir = resolveTasksDir(basePath, mid, sid);
     if (!tDir)