gsd-pi 2.43.0-dev.5717b75 → 2.43.0-next.4

package/README.md

@@ -24,29 +24,6 @@ One command. Walk away. Come back to a built project with clean git history.
 
 ---
 
-## What's New in v2.42.0
-
-### New Features
-
-- **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)
-- **`/gsd fast`** — toggle service tier for supported models, enabling prioritized API routing for faster responses. (#1862)
-- **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
 
 ### New Features

package/dist/cli.js

@@ -14,14 +14,6 @@ import { parseCliArgs as parseWebCliArgs, runWebCliBranch, migrateLegacyFlatSess
 import { stopWebMode } from './web-mode.js';
 import { getProjectSessionsDir } from './project-sessions.js';
 import { markStartup, printStartupTimings } from './startup-timings.js';
-// ---------------------------------------------------------------------------
-// V8 compile cache — Node 22+ can cache compiled bytecode across runs,
-// eliminating repeated parse/compile overhead for unchanged modules.
-// Must be set early so dynamic imports (extensions, lazy subcommands) benefit.
-// ---------------------------------------------------------------------------
-if (parseInt(process.versions.node) >= 22) {
-    process.env.NODE_COMPILE_CACHE ??= join(agentDir, '.compile-cache');
-}
 function exitIfManagedResourcesAreNewer(currentAgentDir) {
     const currentVersion = process.env.GSD_VERSION || '0.0.0';
     const managedVersion = getNewerManagedResourceVersion(currentAgentDir, currentVersion);
@@ -469,14 +461,8 @@ const sessionManager = cliFlags._selectedSessionPath
 exitIfManagedResourcesAreNewer(agentDir);
 initResources(agentDir);
 markStartup('initResources');
-// Overlap resource loading with session manager setup — both are independent.
-// resourceLoader.reload() is the most expensive step (jiti compilation), so
-// starting it early shaves ~50-200ms off interactive startup.
 const resourceLoader = buildResourceLoader(agentDir);
-const resourceLoadPromise = resourceLoader.reload();
-// While resources load, let session manager finish any async I/O it needs.
-// Then await the resource promise before creating the agent session.
-await resourceLoadPromise;
+await resourceLoader.reload();
 markStartup('resourceLoader.reload');
 const { session, extensionsResult } = await createAgentSession({
     authStorage,
@@ -544,9 +530,8 @@ if (!process.stdin.isTTY) {
     process.stderr.write('[gsd]   gsd --mode text "message"      Text output mode\n');
     process.exit(1);
 }
-// Welcome screen — shown on every fresh interactive session before TUI takes over.
-// Skip when the first-run banner was already printed in loader.ts (prevents double banner).
-if (!process.env.GSD_FIRST_RUN_BANNER) {
+// Welcome screen — shown on every fresh interactive session before TUI takes over
+{
     const { printWelcomeScreen } = await import('./welcome-screen.js');
     printWelcomeScreen({
         version: process.env.GSD_VERSION || '0.0.0',

package/dist/loader.js

@@ -42,8 +42,7 @@ const pkgDir = resolve(dirname(fileURLToPath(import.meta.url)), '..', 'pkg');
 process.env.PI_PACKAGE_DIR = pkgDir;
 process.env.PI_SKIP_VERSION_CHECK = '1'; // GSD runs its own update check in cli.ts — suppress pi's
 process.title = 'gsd';
-// Print branded banner on first launch (before ~/.gsd/ exists).
-// Set GSD_FIRST_RUN_BANNER so cli.ts skips the duplicate welcome screen.
+// Print branded banner on first launch (before ~/.gsd/ exists)
 if (!existsSync(appRoot)) {
     const cyan = '\x1b[36m';
     const green = '\x1b[32m';
@@ -54,7 +53,6 @@ if (!existsSync(appRoot)) {
         '\n' +
         `  Get Shit Done ${dim}v${gsdVersion}${reset}\n` +
         `  ${green}Welcome.${reset} Setting up your environment...\n\n`);
-    process.env.GSD_FIRST_RUN_BANNER = '1';
 }
 // GSD_CODING_AGENT_DIR — tells pi's getAgentDir() to return ~/.gsd/agent/ instead of ~/.gsd/agent/
 process.env.GSD_CODING_AGENT_DIR = agentDir;

package/dist/resource-loader.js

@@ -48,25 +48,14 @@ function getBundledGsdVersion() {
     }
 }
 function writeManagedResourceManifest(agentDir) {
-    // Record root-level files and subdirectory extension names currently in the
-    // bundled extensions source so that future upgrades can detect and prune any
-    // that get removed or moved.
+    // Record root-level files currently in the bundled extensions source so that
+    // future upgrades can detect and prune any that get removed or moved.
     let installedExtensionRootFiles = [];
-    let installedExtensionDirs = [];
     try {
         if (existsSync(bundledExtensionsDir)) {
-            const entries = readdirSync(bundledExtensionsDir, { withFileTypes: true });
-            installedExtensionRootFiles = entries
+            installedExtensionRootFiles = readdirSync(bundledExtensionsDir, { withFileTypes: true })
                 .filter(e => e.isFile())
                 .map(e => e.name);
-            installedExtensionDirs = entries
-                .filter(e => e.isDirectory())
-                .filter(e => {
-                // Only track directories that are actual extensions (contain index.js or index.ts)
-                const dirPath = join(bundledExtensionsDir, e.name);
-                return existsSync(join(dirPath, 'index.js')) || existsSync(join(dirPath, 'index.ts'));
-            })
-                .map(e => e.name);
         }
     }
     catch { /* non-fatal */ }
@@ -75,7 +64,6 @@ function writeManagedResourceManifest(agentDir) {
         syncedAt: Date.now(),
         contentHash: computeResourceFingerprint(),
         installedExtensionRootFiles,
-        installedExtensionDirs,
     };
     writeFileSync(getManagedResourceManifestPath(agentDir), JSON.stringify(manifest));
 }
@@ -296,20 +284,16 @@ function pruneRemovedBundledExtensions(manifest, agentDir) {
         return;
     // Current bundled root-level files (what the new version provides)
     const currentSourceFiles = new Set();
-    // Current bundled subdirectory extensions
-    const currentSourceDirs = new Set();
     try {
         if (existsSync(bundledExtensionsDir)) {
             for (const e of readdirSync(bundledExtensionsDir, { withFileTypes: true })) {
                 if (e.isFile())
                     currentSourceFiles.add(e.name);
-                if (e.isDirectory())
-                    currentSourceDirs.add(e.name);
             }
         }
     }
     catch { /* non-fatal */ }
-    const removeFileIfStale = (fileName) => {
+    const removeIfStale = (fileName) => {
         if (currentSourceFiles.has(fileName))
             return; // still in bundle, not stale
         const stale = join(extensionsDir, fileName);
@@ -319,33 +303,17 @@ function pruneRemovedBundledExtensions(manifest, agentDir) {
         }
         catch { /* non-fatal */ }
     };
-    const removeDirIfStale = (dirName) => {
-        if (currentSourceDirs.has(dirName))
-            return; // still in bundle, not stale
-        const stale = join(extensionsDir, dirName);
-        try {
-            if (existsSync(stale))
-                rmSync(stale, { recursive: true, force: true });
-        }
-        catch { /* non-fatal */ }
-    };
     if (manifest?.installedExtensionRootFiles) {
         // Manifest-based: remove previously-installed root files that are no longer bundled
         for (const prevFile of manifest.installedExtensionRootFiles) {
-            removeFileIfStale(prevFile);
-        }
-    }
-    if (manifest?.installedExtensionDirs) {
-        // Manifest-based: remove previously-installed subdirectory extensions that are no longer bundled
-        for (const prevDir of manifest.installedExtensionDirs) {
-            removeDirIfStale(prevDir);
+            removeIfStale(prevFile);
         }
     }
     // Always remove known stale files regardless of manifest state.
     // These were installed by pre-manifest versions so they may not appear in
     // installedExtensionRootFiles even when a manifest exists.
     // env-utils.js was moved from extensions/ root → gsd/ in v2.39.x (#1634)
-    removeFileIfStale('env-utils.js');
+    removeIfStale('env-utils.js');
 }
 /**
  * Syncs all bundled resources to agentDir (~/.gsd/agent/) on every launch.
@@ -448,6 +416,5 @@ export function buildResourceLoader(agentDir) {
     return new DefaultResourceLoader({
         agentDir,
         additionalExtensionPaths: piExtensionPaths,
-        bundledExtensionNames: bundledKeys,
     });
 }

package/dist/resources/extensions/async-jobs/async-bash-tool.js

@@ -83,15 +83,6 @@ export function createAsyncBashTool(getManager, getCwd) {
  */
 function executeBashInBackground(command, cwd, signal, timeout) {
     return new Promise((resolve, reject) => {
-        let settled = false;
-        const safeResolve = (value) => { if (!settled) {
-            settled = true;
-            resolve(value);
-        } };
-        const safeReject = (err) => { if (!settled) {
-            settled = true;
-            reject(err);
-        } };
         const { shell, args } = getShellConfig();
         const resolvedCommand = sanitizeCommand(command);
         const child = spawn(shell, [...args, resolvedCommand], {
@@ -102,42 +93,11 @@ function executeBashInBackground(command, cwd, signal, timeout) {
         });
         let timedOut = false;
         let timeoutHandle;
-        let sigkillHandle;
-        let hardDeadlineHandle;
-        /** Grace period (ms) between SIGTERM and SIGKILL. */
-        const SIGKILL_GRACE_MS = 5_000;
-        /** Hard deadline (ms) after SIGKILL to force-resolve the promise. */
-        const HARD_DEADLINE_MS = 3_000;
         if (timeout !== undefined && timeout > 0) {
             timeoutHandle = setTimeout(() => {
                 timedOut = true;
                 if (child.pid)
                     killTree(child.pid);
-                // If the process ignores SIGTERM, escalate to SIGKILL
-                sigkillHandle = setTimeout(() => {
-                    if (child.pid) {
-                        try {
-                            process.kill(-child.pid, "SIGKILL");
-                        }
-                        catch { /* ignore */ }
-                        try {
-                            process.kill(child.pid, "SIGKILL");
-                        }
-                        catch { /* ignore */ }
-                    }
-                    // Hard deadline: if even SIGKILL doesn't trigger 'close',
-                    // force-resolve so the job doesn't hang forever (#2186).
-                    hardDeadlineHandle = setTimeout(() => {
-                        const output = Buffer.concat(chunks).toString("utf-8");
-                        safeResolve(output
-                            ? `${output}\n\nCommand timed out after ${timeout} seconds (force-killed)`
-                            : `Command timed out after ${timeout} seconds (force-killed)`);
-                    }, HARD_DEADLINE_MS);
-                    if (typeof hardDeadlineHandle === "object" && "unref" in hardDeadlineHandle)
-                        hardDeadlineHandle.unref();
-                }, SIGKILL_GRACE_MS);
-                if (typeof sigkillHandle === "object" && "unref" in sigkillHandle)
-                    sigkillHandle.unref();
             }, timeout * 1000);
         }
         const chunks = [];
@@ -179,31 +139,23 @@ function executeBashInBackground(command, cwd, signal, timeout) {
         child.on("error", (err) => {
             if (timeoutHandle)
                 clearTimeout(timeoutHandle);
-            if (sigkillHandle)
-                clearTimeout(sigkillHandle);
-            if (hardDeadlineHandle)
-                clearTimeout(hardDeadlineHandle);
             signal.removeEventListener("abort", onAbort);
-            safeReject(err);
+            reject(err);
         });
         child.on("close", (code) => {
             if (timeoutHandle)
                 clearTimeout(timeoutHandle);
-            if (sigkillHandle)
-                clearTimeout(sigkillHandle);
-            if (hardDeadlineHandle)
-                clearTimeout(hardDeadlineHandle);
             signal.removeEventListener("abort", onAbort);
             if (spillStream)
                 spillStream.end();
             if (signal.aborted) {
                 const output = Buffer.concat(chunks).toString("utf-8");
-                safeResolve(output ? `${output}\n\nCommand aborted` : "Command aborted");
+                resolve(output ? `${output}\n\nCommand aborted` : "Command aborted");
                 return;
             }
             if (timedOut) {
                 const output = Buffer.concat(chunks).toString("utf-8");
-                safeResolve(output ? `${output}\n\nCommand timed out after ${timeout} seconds` : `Command timed out after ${timeout} seconds`);
+                resolve(output ? `${output}\n\nCommand timed out after ${timeout} seconds` : `Command timed out after ${timeout} seconds`);
                 return;
             }
             const fullOutput = Buffer.concat(chunks).toString("utf-8");
@@ -224,7 +176,7 @@ function executeBashInBackground(command, cwd, signal, timeout) {
             if (code !== 0 && code !== null) {
                 text += `\n\nCommand exited with code ${code}`;
             }
-            safeResolve(text);
+            resolve(text);
         });
     });
 }

package/dist/resources/extensions/async-jobs/await-tool.js

@@ -54,11 +54,6 @@ export function createAwaitTool(getManager) {
                     };
                 }
             }
-            // Mark all watched jobs as awaited upfront so the onJobComplete
-            // callback (which fires synchronously in the promise .then()) knows
-            // to suppress the follow-up message.
-            for (const j of watched)
-                j.awaited = true;
             // If all watched jobs are already done, return immediately
             const running = watched.filter((j) => j.status === "running");
             if (running.length === 0) {

package/dist/resources/extensions/async-jobs/index.js

@@ -34,8 +34,6 @@ export default function AsyncJobs(pi) {
         latestCwd = ctx.cwd;
         manager = new AsyncJobManager({
             onJobComplete: (job) => {
-                if (job.awaited)
-                    return;
                 const statusEmoji = job.status === "completed" ? "done" : "error";
                 const elapsed = ((Date.now() - job.startTime) / 1000).toFixed(1);
                 const output = job.status === "completed"

package/dist/resources/extensions/github-sync/sync.js

@@ -9,7 +9,8 @@
  */
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
-import { loadFile, parseRoadmap, parsePlan, parseSummary } from "../gsd/files.js";
+import { loadFile, parseSummary } from "../gsd/files.js";
+import { parseRoadmap, parsePlan } from "../gsd/parsers-legacy.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveTaskFile, } from "../gsd/paths.js";
 import { debugLog } from "../gsd/debug-logger.js";
 import { loadEffectiveGSDPreferences } from "../gsd/preferences.js";

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

@@ -165,7 +165,9 @@ export async function runPreDispatch(ic, loopState) {
         midTitle = state.activeMilestone?.title;
         if (mid) {
             if (deps.getIsolationMode() !== "none") {
-                deps.captureIntegrationBranch(s.basePath, mid);
+                deps.captureIntegrationBranch(s.basePath, mid, {
+                    commitDocs: prefs?.git?.commit_docs,
+                });
             }
             deps.resolver.enterMilestone(mid, ctx.ui);
         }

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

@@ -8,8 +8,7 @@
 import { getCurrentBranch } from "./worktree.js";
 import { getActiveHook } from "./post-unit-hooks.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
-import { resolveMilestoneFile, resolveSliceFile, } from "./paths.js";
-import { parseRoadmap, parsePlan } from "./files.js";
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { truncateToWidth, visibleWidth } from "@gsd/pi-tui";
@@ -192,24 +191,26 @@ export function estimateTimeRemaining() {
 let cachedSliceProgress = null;
 export function updateSliceProgressCache(base, mid, activeSid) {
     try {
-        const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-        if (!roadmapFile)
-            return;
-        const content = readFileSync(roadmapFile, "utf-8");
-        const roadmap = parseRoadmap(content);
+        let normSlices;
+        if (isDbAvailable()) {
+            normSlices = getMilestoneSlices(mid).map(s => ({ id: s.id, done: s.status === "complete", title: s.title }));
+        }
+        else {
+            normSlices = [];
+        }
         let activeSliceTasks = null;
         let taskDetails = null;
         if (activeSid) {
             try {
-                const planFile = resolveSliceFile(base, mid, activeSid, "PLAN");
-                if (planFile && existsSync(planFile)) {
-                    const planContent = readFileSync(planFile, "utf-8");
-                    const plan = parsePlan(planContent);
-                    activeSliceTasks = {
-                        done: plan.tasks.filter(t => t.done).length,
-                        total: plan.tasks.length,
-                    };
-                    taskDetails = plan.tasks.map(t => ({ id: t.id, title: t.title, done: t.done }));
+                if (isDbAvailable()) {
+                    const dbTasks = getSliceTasks(mid, activeSid);
+                    if (dbTasks.length > 0) {
+                        activeSliceTasks = {
+                            done: dbTasks.filter(t => t.status === "complete" || t.status === "done").length,
+                            total: dbTasks.length,
+                        };
+                        taskDetails = dbTasks.map(t => ({ id: t.id, title: t.title, done: t.status === "complete" || t.status === "done" }));
+                    }
                 }
             }
             catch {
@@ -217,8 +218,8 @@ export function updateSliceProgressCache(base, mid, activeSid) {
             }
         }
         cachedSliceProgress = {
-            done: roadmap.slices.filter(s => s.done).length,
-            total: roadmap.slices.length,
+            done: normSlices.filter(s => s.done).length,
+            total: normSlices.length,
             milestoneId: mid,
             activeSliceTasks,
             taskDetails,

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

@@ -3,8 +3,9 @@
  * Resolves phase name → unit type + prompt, creates a session, and sends the message.
  */
 import { deriveState } from "./state.js";
-import { loadFile, parseRoadmap } from "./files.js";
-import { resolveMilestoneFile, resolveSliceFile, relSliceFile, } from "./paths.js";
+import { loadFile } from "./files.js";
+import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
+import { 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";
@@ -117,19 +118,20 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
         }
         case "reassess":
         case "reassess-roadmap": {
-            const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (!roadmapContent) {
-                ctx.ui.notify("Cannot dispatch reassess-roadmap: no roadmap found.", "warning");
+            // DB primary path — get completed slices
+            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;
             }
-            const roadmap = parseRoadmap(roadmapContent);
-            const completedSlices = roadmap.slices.filter(s => s.done);
-            if (completedSlices.length === 0) {
+            if (completedSliceIds.length === 0) {
                 ctx.ui.notify("Cannot dispatch reassess-roadmap: no completed slices.", "warning");
                 return;
             }
-            const completedSliceId = completedSlices[completedSlices.length - 1].id;
+            const completedSliceId = completedSliceIds[completedSliceIds.length - 1];
             unitType = "reassess-roadmap";
             unitId = `${mid}/${completedSliceId}`;
             prompt = await buildReassessRoadmapPrompt(mid, midTitle, completedSliceId, base);
@@ -141,19 +143,19 @@ export async function dispatchDirectPhase(ctx, pi, phase, base) {
             // incomplete) slice. After slice completion, state.activeSlice advances
             // to the next incomplete slice, so we find the last done slice from the
             // roadmap instead (#1693).
-            const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (!roadmapContent) {
-                ctx.ui.notify("Cannot dispatch run-uat: no roadmap found.", "warning");
+            let uatCompletedSliceIds = [];
+            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;
             }
-            const roadmap = parseRoadmap(roadmapContent);
-            const completedSlices = roadmap.slices.filter(s => s.done);
-            if (completedSlices.length === 0) {
+            if (uatCompletedSliceIds.length === 0) {
                 ctx.ui.notify("Cannot dispatch run-uat: no completed slices.", "warning");
                 return;
             }
-            const sid = completedSlices[completedSlices.length - 1].id;
+            const sid = uatCompletedSliceIds[uatCompletedSliceIds.length - 1];
             const uatFile = resolveSliceFile(base, mid, sid, "UAT");
             if (!uatFile) {
                 ctx.ui.notify("Cannot dispatch run-uat: no UAT file found.", "warning");

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

@@ -8,7 +8,8 @@
  * data structure that is inspectable, testable per-rule, and extensible
  * without modifying orchestration code.
  */
-import { loadFile, loadActiveOverrides, parseRoadmap } from "./files.js";
+import { loadFile, loadActiveOverrides } from "./files.js";
+import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
 import { resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } from "./paths.js";
 import { existsSync, mkdirSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
@@ -92,12 +93,18 @@ export const DISPATCH_RULES = [
             if (!prefs?.uat_dispatch)
                 return null;
             const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (!roadmapContent)
+            // DB-first: get completed slices from DB
+            let completedSliceIds;
+            if (isDbAvailable()) {
+                completedSliceIds = getMilestoneSlices(mid)
+                    .filter(s => s.status === "complete")
+                    .map(s => s.id);
+            }
+            else {
                 return null;
-            const roadmap = parseRoadmap(roadmapContent);
-            for (const slice of roadmap.slices.filter(s => s.done)) {
-                const resultFile = resolveSliceFile(basePath, mid, slice.id, "UAT-RESULT");
+            }
+            for (const sliceId of completedSliceIds) {
+                const resultFile = resolveSliceFile(basePath, mid, sliceId, "UAT-RESULT");
                 if (!resultFile)
                     continue;
                 const content = await loadFile(resultFile);
@@ -108,7 +115,7 @@ export const DISPATCH_RULES = [
                 if (verdict && verdict !== "pass" && verdict !== "passed") {
                     return {
                         action: "stop",
-                        reason: `UAT verdict for ${slice.id} is "${verdict}" — blocking progression until resolved.\nReview the UAT result and update the verdict to PASS, or re-run /gsd auto after fixing.`,
+                        reason: `UAT verdict for ${sliceId} is "${verdict}" — blocking progression until resolved.\nReview the UAT result and update the verdict to PASS, or re-run /gsd auto after fixing.`,
                         level: "warning",
                     };
                 }
@@ -376,15 +383,19 @@ export const DISPATCH_RULES = [
             // Safety guard (#1368): verify all roadmap slices have SUMMARY files before
             // allowing milestone validation. If any slice lacks a summary, the milestone
             // is not genuinely complete — something skipped earlier slices.
-            const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (roadmapContent) {
-                const roadmap = parseRoadmap(roadmapContent);
+            let sliceIds;
+            if (isDbAvailable()) {
+                sliceIds = getMilestoneSlices(mid).map(s => s.id);
+            }
+            else {
+                sliceIds = [];
+            }
+            if (sliceIds.length > 0) {
                 const missingSlices = [];
-                for (const slice of roadmap.slices) {
-                    const summaryPath = resolveSliceFile(basePath, mid, slice.id, "SUMMARY");
+                for (const sid of sliceIds) {
+                    const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
                     if (!summaryPath || !existsSync(summaryPath)) {
-                        missingSlices.push(slice.id);
+                        missingSlices.push(sid);
                     }
                 }
                 if (missingSlices.length > 0) {
@@ -430,15 +441,19 @@ export const DISPATCH_RULES = [
             if (state.phase !== "completing-milestone")
                 return null;
             // Safety guard (#1368): verify all roadmap slices have SUMMARY files.
-            const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
-            const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-            if (roadmapContent) {
-                const roadmap = parseRoadmap(roadmapContent);
+            let sliceIds;
+            if (isDbAvailable()) {
+                sliceIds = getMilestoneSlices(mid).map(s => s.id);
+            }
+            else {
+                sliceIds = [];
+            }
+            if (sliceIds.length > 0) {
                 const missingSlices = [];
-                for (const slice of roadmap.slices) {
-                    const summaryPath = resolveSliceFile(basePath, mid, slice.id, "SUMMARY");
+                for (const sid of sliceIds) {
+                    const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
                     if (!summaryPath || !existsSync(summaryPath)) {
-                        missingSlices.push(slice.id);
+                        missingSlices.push(sid);
                     }
                 }
                 if (missingSlices.length > 0) {