gsd-pi 2.43.0-next.8 → 2.44.0-dev.62b5d6c

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-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/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)

package/dist/resources/extensions/gsd/skill-health.js

@@ -209,7 +209,9 @@ The human review step is what makes this valuable.`;
  */
 export function computeStaleAvoidList(basePath, currentAvoidList, staleDays) {
     const ledger = loadLedgerFromDisk(basePath);
-    const units = (ledger?.units ?? []).filter(u => u.skills && u.skills.length > 0);
+    if (!ledger)
+        return [];
+    const units = ledger.units.filter(u => u.skills && u.skills.length > 0);
     const stale = detectStaleSkills(units, staleDays ?? DEFAULT_STALE_DAYS);
     const avoidSet = new Set(currentAvoidList);
     return stale.filter(s => !avoidSet.has(s));

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

@@ -1,5 +1,5 @@
 import { clearParseCache } from "../files.js";
-import { transaction, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, _getAdapter, } from "../gsd-db.js";
+import { transaction, insertMilestone, insertSlice, upsertMilestonePlanning, upsertSlicePlanning, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderRoadmapFromDb } from "../markdown-renderer.js";
 function isNonEmptyString(value) {
@@ -192,16 +192,7 @@ export async function handlePlanMilestone(rawParams, basePath) {
         roadmapPath = renderResult.roadmapPath;
     }
     catch (renderErr) {
-        process.stderr.write(`gsd-db: plan_milestone — render failed, rolling back DB rows: ${renderErr.message}\n`);
-        const rollbackAdapter = _getAdapter();
-        if (rollbackAdapter) {
-            for (const slice of params.slices) {
-                rollbackAdapter.prepare(`DELETE FROM slice_planning WHERE milestone_id = :mid AND slice_id = :sid`).run({ ":mid": params.milestoneId, ":sid": slice.sliceId });
-                rollbackAdapter.prepare(`DELETE FROM slices WHERE milestone_id = :mid AND id = :sid`).run({ ":mid": params.milestoneId, ":sid": slice.sliceId });
-            }
-            rollbackAdapter.prepare(`DELETE FROM milestone_planning WHERE milestone_id = :mid`).run({ ":mid": params.milestoneId });
-            rollbackAdapter.prepare(`DELETE FROM milestones WHERE id = :mid`).run({ ":mid": params.milestoneId });
-        }
+        process.stderr.write(`gsd-db: plan_milestone — render failed (DB rows preserved for debugging): ${renderErr.message}\n`);
         invalidateStateCache();
         return { error: `render failed: ${renderErr.message}` };
     }

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

@@ -1,5 +1,5 @@
 import { clearParseCache } from "../files.js";
-import { transaction, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, _getAdapter, } from "../gsd-db.js";
+import { transaction, getSlice, insertTask, upsertSlicePlanning, upsertTaskPlanning, } from "../gsd-db.js";
 import { invalidateStateCache } from "../state.js";
 import { renderPlanFromDb } from "../markdown-renderer.js";
 function isNonEmptyString(value) {
@@ -148,15 +148,7 @@ export async function handlePlanSlice(rawParams, basePath) {
         };
     }
     catch (renderErr) {
-        process.stderr.write(`gsd-db: plan_slice — render failed, rolling back DB rows: ${renderErr.message}\n`);
-        const rollbackAdapter = _getAdapter();
-        if (rollbackAdapter) {
-            for (const task of params.tasks) {
-                rollbackAdapter.prepare(`DELETE FROM task_planning WHERE milestone_id = :mid AND slice_id = :sid AND task_id = :tid`).run({ ":mid": params.milestoneId, ":sid": params.sliceId, ":tid": task.taskId });
-                rollbackAdapter.prepare(`DELETE FROM tasks WHERE milestone_id = :mid AND slice_id = :sid AND id = :tid`).run({ ":mid": params.milestoneId, ":sid": params.sliceId, ":tid": task.taskId });
-            }
-            rollbackAdapter.prepare(`DELETE FROM slice_planning WHERE milestone_id = :mid AND slice_id = :sid`).run({ ":mid": params.milestoneId, ":sid": params.sliceId });
-        }
+        process.stderr.write(`gsd-db: plan_slice — render failed (DB rows preserved for debugging): ${renderErr.message}\n`);
         invalidateStateCache();
         return { error: `render failed: ${renderErr.message}` };
     }