gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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

@@ -0,0 +1,146 @@
+import { clearParseCache } from "../files.js";
+import { transaction, getSlice, getSliceTasks, insertTask, upsertTaskPlanning, insertReplanHistory, deleteTask, } from "../gsd-db.js";
+import { invalidateStateCache } from "../state.js";
+import { renderPlanFromDb, renderReplanFromDb } from "../markdown-renderer.js";
+function isNonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0;
+}
+function validateParams(params) {
+    if (!isNonEmptyString(params?.milestoneId))
+        throw new Error("milestoneId is required");
+    if (!isNonEmptyString(params?.sliceId))
+        throw new Error("sliceId is required");
+    if (!isNonEmptyString(params?.blockerTaskId))
+        throw new Error("blockerTaskId is required");
+    if (!isNonEmptyString(params?.blockerDescription))
+        throw new Error("blockerDescription is required");
+    if (!isNonEmptyString(params?.whatChanged))
+        throw new Error("whatChanged is required");
+    if (!Array.isArray(params.updatedTasks)) {
+        throw new Error("updatedTasks must be an array");
+    }
+    if (!Array.isArray(params.removedTaskIds)) {
+        throw new Error("removedTaskIds must be an array");
+    }
+    // Validate each updated task
+    for (let i = 0; i < params.updatedTasks.length; i++) {
+        const t = params.updatedTasks[i];
+        if (!t || typeof t !== "object")
+            throw new Error(`updatedTasks[${i}] must be an object`);
+        if (!isNonEmptyString(t.taskId))
+            throw new Error(`updatedTasks[${i}].taskId is required`);
+        if (!isNonEmptyString(t.title))
+            throw new Error(`updatedTasks[${i}].title is required`);
+    }
+    return params;
+}
+export async function handleReplanSlice(rawParams, basePath) {
+    // ── Validate ──────────────────────────────────────────────────────
+    let params;
+    try {
+        params = validateParams(rawParams);
+    }
+    catch (err) {
+        return { error: `validation failed: ${err.message}` };
+    }
+    // ── Verify parent slice exists ────────────────────────────────────
+    const parentSlice = getSlice(params.milestoneId, params.sliceId);
+    if (!parentSlice) {
+        return { error: `missing parent slice: ${params.milestoneId}/${params.sliceId}` };
+    }
+    // ── Structural enforcement ────────────────────────────────────────
+    const existingTasks = getSliceTasks(params.milestoneId, params.sliceId);
+    const completedTaskIds = new Set();
+    for (const task of existingTasks) {
+        if (task.status === "complete" || task.status === "done") {
+            completedTaskIds.add(task.id);
+        }
+    }
+    // Reject updates to completed tasks
+    for (const updatedTask of params.updatedTasks) {
+        if (completedTaskIds.has(updatedTask.taskId)) {
+            return { error: `cannot modify completed task ${updatedTask.taskId}` };
+        }
+    }
+    // Reject removal of completed tasks
+    for (const removedId of params.removedTaskIds) {
+        if (completedTaskIds.has(removedId)) {
+            return { error: `cannot remove completed task ${removedId}` };
+        }
+    }
+    // ── Transaction: DB mutations ─────────────────────────────────────
+    const existingTaskIds = new Set(existingTasks.map((t) => t.id));
+    try {
+        transaction(() => {
+            // Record replan history
+            insertReplanHistory({
+                milestoneId: params.milestoneId,
+                sliceId: params.sliceId,
+                taskId: params.blockerTaskId,
+                summary: params.whatChanged,
+            });
+            // Apply task updates (upsert existing, insert new)
+            for (const updatedTask of params.updatedTasks) {
+                if (existingTaskIds.has(updatedTask.taskId)) {
+                    // Update existing task's planning fields
+                    upsertTaskPlanning(params.milestoneId, params.sliceId, updatedTask.taskId, {
+                        title: updatedTask.title,
+                        description: updatedTask.description || "",
+                        estimate: updatedTask.estimate || "",
+                        files: updatedTask.files || [],
+                        verify: updatedTask.verify || "",
+                        inputs: updatedTask.inputs || [],
+                        expectedOutput: updatedTask.expectedOutput || [],
+                    });
+                }
+                else {
+                    // Insert new task then set planning fields
+                    insertTask({
+                        id: updatedTask.taskId,
+                        sliceId: params.sliceId,
+                        milestoneId: params.milestoneId,
+                        title: updatedTask.title,
+                        status: "pending",
+                    });
+                    upsertTaskPlanning(params.milestoneId, params.sliceId, updatedTask.taskId, {
+                        title: updatedTask.title,
+                        description: updatedTask.description || "",
+                        estimate: updatedTask.estimate || "",
+                        files: updatedTask.files || [],
+                        verify: updatedTask.verify || "",
+                        inputs: updatedTask.inputs || [],
+                        expectedOutput: updatedTask.expectedOutput || [],
+                    });
+                }
+            }
+            // Delete removed tasks
+            for (const removedId of params.removedTaskIds) {
+                deleteTask(params.milestoneId, params.sliceId, removedId);
+            }
+        });
+    }
+    catch (err) {
+        return { error: `db write failed: ${err.message}` };
+    }
+    // ── Render artifacts ──────────────────────────────────────────────
+    try {
+        const renderResult = await renderPlanFromDb(basePath, params.milestoneId, params.sliceId);
+        const replanResult = await renderReplanFromDb(basePath, params.milestoneId, params.sliceId, {
+            blockerTaskId: params.blockerTaskId,
+            blockerDescription: params.blockerDescription,
+            whatChanged: params.whatChanged,
+        });
+        // ── Invalidate caches ─────────────────────────────────────────
+        invalidateStateCache();
+        clearParseCache();
+        return {
+            milestoneId: params.milestoneId,
+            sliceId: params.sliceId,
+            replanPath: replanResult.replanPath,
+            planPath: renderResult.planPath,
+        };
+    }
+    catch (err) {
+        return { error: `render failed: ${err.message}` };
+    }
+}

package/dist/resources/extensions/gsd/triage-resolution.js

@@ -11,6 +11,7 @@
  */
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
+import { createRequire } from "node:module";
 import { gsdRoot, milestonesDir } from "./paths.js";
 import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { loadAllCaptures, loadActionableCaptures, markCaptureExecuted, } from "./captures.js";
@@ -65,18 +66,33 @@ export function executeInject(basePath, mid, sid, capture) {
 export function executeReplan(basePath, mid, sid, capture) {
     try {
         const triggerPath = join(basePath, ".gsd", "milestones", mid, "slices", sid, `${sid}-REPLAN-TRIGGER.md`);
+        const ts = new Date().toISOString();
         const content = [
             `# Replan Trigger`,
             ``,
             `**Source:** Capture ${capture.id}`,
             `**Capture:** ${capture.text}`,
             `**Rationale:** ${capture.rationale ?? "User-initiated replan via capture triage"}`,
-            `**Triggered:** ${new Date().toISOString()}`,
+            `**Triggered:** ${ts}`,
             ``,
             `This file was created by the triage pipeline. The next dispatch cycle`,
             `will detect it and enter the replanning-slice phase.`,
         ].join("\n");
         writeFileSync(triggerPath, content, "utf-8");
+        // Also write replan_triggered_at column for DB-backed detection
+        try {
+            const req = createRequire(import.meta.url);
+            const { isDbAvailable, _getAdapter } = req("./gsd-db.js");
+            if (isDbAvailable()) {
+                const adapter = _getAdapter();
+                if (adapter) {
+                    adapter.prepare("UPDATE slices SET replan_triggered_at = :ts WHERE milestone_id = :mid AND id = :sid").run({ ":ts": ts, ":mid": mid, ":sid": sid });
+                }
+            }
+        }
+        catch {
+            // DB write is best-effort — disk file is the primary trigger for fallback path
+        }
         return true;
     }
     catch {

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

@@ -1,12 +1,16 @@
-// GSD Extension — Undo Last Unit
-// Rollback the most recent completed unit: revert git, remove state, uncheck plans.
+// GSD Extension — Undo Last Unit + Targeted State Reset
+// handleUndo: Rollback the most recent completed unit (revert git, remove state, uncheck plans).
+// handleUndoTask: Reset a single task's DB status to "pending" and re-render markdown.
+// handleResetSlice: Reset a slice and all its tasks, re-rendering plan + roadmap.
 import { existsSync, readFileSync, writeFileSync, unlinkSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { nativeRevertCommit, nativeRevertAbort } from "./native-git-bridge.js";
 import { deriveState } from "./state.js";
 import { invalidateAllCaches } from "./cache.js";
-import { gsdRoot, resolveTasksDir, resolveSlicePath, buildTaskFileName } from "./paths.js";
+import { gsdRoot, resolveTasksDir, resolveSlicePath, resolveTaskFile, buildTaskFileName, buildSliceFileName } from "./paths.js";
 import { sendDesktopNotification } from "./notifications.js";
+import { getTask, getSlice, getSliceTasks, updateTaskStatus, updateSliceStatus } from "./gsd-db.js";
+import { renderPlanCheckboxes, renderRoadmapCheckboxes } from "./markdown-renderer.js";
 /**
  * Undo the last completed unit: revert git commits,
  * delete summary artifacts, and uncheck the task in PLAN.
@@ -121,6 +125,196 @@ export async function handleUndo(args, ctx, _pi, basePath) {
     ctx.ui.notify(results.join("\n"), "success");
     sendDesktopNotification("GSD", `Undone: ${unitType} (${unitId})`, "info", "complete");
 }
+// ─── Targeted State Reset ────────────────────────────────────────────────────
+/**
+ * Parse a task identifier from args. Accepts:
+ *   T01, S01/T01, M001/S01/T01
+ * Resolves missing parts from current state via deriveState().
+ */
+async function parseTaskId(raw, basePath) {
+    const parts = raw.split("/");
+    if (parts.length === 3) {
+        return { mid: parts[0], sid: parts[1], tid: parts[2] };
+    }
+    // Need to resolve from state
+    const state = await deriveState(basePath);
+    if (parts.length === 2) {
+        // S01/T01 — resolve milestone
+        const mid = state.activeMilestone?.id;
+        if (!mid)
+            return "Cannot resolve milestone — no active milestone in state.";
+        return { mid, sid: parts[0], tid: parts[1] };
+    }
+    if (parts.length === 1) {
+        // T01 — resolve milestone + slice
+        const mid = state.activeMilestone?.id;
+        const sid = state.activeSlice?.id;
+        if (!mid)
+            return "Cannot resolve milestone — no active milestone in state.";
+        if (!sid)
+            return "Cannot resolve slice — no active slice in state.";
+        return { mid, sid, tid: parts[0] };
+    }
+    return "Invalid task ID format. Use T01, S01/T01, or M001/S01/T01.";
+}
+/**
+ * Parse a slice identifier from args. Accepts:
+ *   S01, M001/S01
+ * Resolves missing milestone from current state.
+ */
+async function parseSliceId(raw, basePath) {
+    const parts = raw.split("/");
+    if (parts.length === 2) {
+        return { mid: parts[0], sid: parts[1] };
+    }
+    if (parts.length === 1) {
+        const state = await deriveState(basePath);
+        const mid = state.activeMilestone?.id;
+        if (!mid)
+            return "Cannot resolve milestone — no active milestone in state.";
+        return { mid, sid: parts[0] };
+    }
+    return "Invalid slice ID format. Use S01 or M001/S01.";
+}
+/**
+ * Reset a single task's completion state:
+ * - Set DB status to "pending"
+ * - Delete the task summary file
+ * - Re-render plan checkboxes
+ */
+export async function handleUndoTask(args, ctx, _pi, basePath) {
+    const force = args.includes("--force");
+    const rawId = args.replace("--force", "").trim();
+    if (!rawId) {
+        ctx.ui.notify("Usage: /gsd undo-task <taskId> [--force]\n\n" +
+            "Accepts: T01, S01/T01, or M001/S01/T01\n" +
+            "Resets the task's DB status to pending and re-renders plan checkboxes.", "warning");
+        return;
+    }
+    const parsed = await parseTaskId(rawId, basePath);
+    if (typeof parsed === "string") {
+        ctx.ui.notify(parsed, "error");
+        return;
+    }
+    const { mid, sid, tid } = parsed;
+    // Validate task exists in DB
+    const task = getTask(mid, sid, tid);
+    if (!task) {
+        ctx.ui.notify(`Task ${mid}/${sid}/${tid} not found in database.`, "error");
+        return;
+    }
+    if (!force) {
+        ctx.ui.notify(`Will reset: task ${mid}/${sid}/${tid}\n` +
+            `  Current status: ${task.status}\n` +
+            `This will:\n` +
+            `  - Set task status to "pending" in DB\n` +
+            `  - Delete task summary file (if exists)\n` +
+            `  - Re-render plan checkboxes\n\n` +
+            `Run /gsd undo-task ${rawId} --force to confirm.`, "warning");
+        return;
+    }
+    // Reset DB status
+    updateTaskStatus(mid, sid, tid, "pending");
+    // Delete summary file
+    let summaryDeleted = false;
+    const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+    if (summaryPath && existsSync(summaryPath)) {
+        unlinkSync(summaryPath);
+        summaryDeleted = true;
+    }
+    // Re-render plan checkboxes
+    await renderPlanCheckboxes(basePath, mid, sid);
+    // Invalidate caches
+    invalidateAllCaches();
+    const results = [`Reset task ${mid}/${sid}/${tid} to "pending".`];
+    if (summaryDeleted)
+        results.push("  - Deleted task summary file");
+    results.push("  - Plan checkboxes re-rendered");
+    ctx.ui.notify(results.join("\n"), "success");
+}
+/**
+ * Reset a slice and all its tasks:
+ * - Set all task DB statuses to "pending"
+ * - Set slice DB status to "active"
+ * - Delete task summary files, slice summary, and UAT files
+ * - Re-render plan + roadmap checkboxes
+ */
+export async function handleResetSlice(args, ctx, _pi, basePath) {
+    const force = args.includes("--force");
+    const rawId = args.replace("--force", "").trim();
+    if (!rawId) {
+        ctx.ui.notify("Usage: /gsd reset-slice <sliceId> [--force]\n\n" +
+            "Accepts: S01 or M001/S01\n" +
+            "Resets the slice and all its tasks, re-renders plan + roadmap checkboxes.", "warning");
+        return;
+    }
+    const parsed = await parseSliceId(rawId, basePath);
+    if (typeof parsed === "string") {
+        ctx.ui.notify(parsed, "error");
+        return;
+    }
+    const { mid, sid } = parsed;
+    // Validate slice exists in DB
+    const slice = getSlice(mid, sid);
+    if (!slice) {
+        ctx.ui.notify(`Slice ${mid}/${sid} not found in database.`, "error");
+        return;
+    }
+    const tasks = getSliceTasks(mid, sid);
+    if (!force) {
+        ctx.ui.notify(`Will reset: slice ${mid}/${sid}\n` +
+            `  Current status: ${slice.status}\n` +
+            `  Tasks to reset: ${tasks.length}\n` +
+            `This will:\n` +
+            `  - Set all task statuses to "pending" in DB\n` +
+            `  - Set slice status to "active" in DB\n` +
+            `  - Delete task summary files, slice summary, and UAT files\n` +
+            `  - Re-render plan + roadmap checkboxes\n\n` +
+            `Run /gsd reset-slice ${rawId} --force to confirm.`, "warning");
+        return;
+    }
+    // Reset all tasks
+    let tasksReset = 0;
+    let summariesDeleted = 0;
+    for (const t of tasks) {
+        updateTaskStatus(mid, sid, t.id, "pending");
+        tasksReset++;
+        const summaryPath = resolveTaskFile(basePath, mid, sid, t.id, "SUMMARY");
+        if (summaryPath && existsSync(summaryPath)) {
+            unlinkSync(summaryPath);
+            summariesDeleted++;
+        }
+    }
+    // Reset slice status
+    updateSliceStatus(mid, sid, "active");
+    // Delete slice summary and UAT files
+    let sliceFilesDeleted = 0;
+    const slicePath = resolveSlicePath(basePath, mid, sid);
+    if (slicePath) {
+        for (const suffix of ["SUMMARY", "UAT"]) {
+            const filePath = join(slicePath, buildSliceFileName(sid, suffix));
+            if (existsSync(filePath)) {
+                unlinkSync(filePath);
+                sliceFilesDeleted++;
+            }
+        }
+    }
+    // Re-render plan + roadmap checkboxes
+    await renderPlanCheckboxes(basePath, mid, sid);
+    await renderRoadmapCheckboxes(basePath, mid);
+    // Invalidate caches
+    invalidateAllCaches();
+    const results = [
+        `Reset slice ${mid}/${sid} to "active".`,
+        `  - ${tasksReset} task(s) reset to "pending"`,
+    ];
+    if (summariesDeleted > 0)
+        results.push(`  - ${summariesDeleted} task summary file(s) deleted`);
+    if (sliceFilesDeleted > 0)
+        results.push(`  - ${sliceFilesDeleted} slice file(s) deleted (summary/UAT)`);
+    results.push("  - Plan + roadmap checkboxes re-rendered");
+    ctx.ui.notify(results.join("\n"), "success");
+}
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 export function uncheckTaskInPlan(basePath, mid, sid, tid) {
     const slicePath = resolveSlicePath(basePath, mid, sid);

package/dist/resources/extensions/gsd/visualizer-data.js

@@ -2,7 +2,9 @@
 import { existsSync, readFileSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { deriveState } from './state.js';
-import { parseRoadmap, parsePlan, parseSummary, loadFile } from './files.js';
+import { parseSummary, loadFile } from './files.js';
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from './gsd-db.js';
+import { parseRoadmap, parsePlan } from './parsers-legacy.js';
 import { findMilestoneIds } from './milestone-ids.js';
 import { resolveMilestoneFile, resolveSliceFile, resolveGsdRootFile, gsdRoot } from './paths.js';
 import { getLedger, getProjectTotals, aggregateByPhase, aggregateBySlice, aggregateByModel, aggregateByTier, formatTierSavings, loadLedgerFromDisk, } from './metrics.js';
@@ -532,25 +534,60 @@ export async function loadVisualizerData(basePath) {
         const slices = [];
         const roadmapFile = resolveMilestoneFile(basePath, mid, 'ROADMAP');
         const roadmapContent = roadmapFile ? readFileCached(roadmapFile) : null;
-        if (roadmapContent) {
-            const roadmap = parseRoadmap(roadmapContent);
-            for (const s of roadmap.slices) {
+        if (roadmapContent || isDbAvailable()) {
+            let normSlices = null;
+            if (isDbAvailable()) {
+                const dbSlices = getMilestoneSlices(mid);
+                if (dbSlices.length > 0) {
+                    normSlices = dbSlices.map(s => ({ id: s.id, done: s.status === 'complete', title: s.title, risk: s.risk || 'medium', depends: s.depends, demo: s.demo }));
+                }
+            }
+            if (!normSlices && roadmapContent) {
+                // File-based fallback: parse roadmap for slice entries
+                const parsed = parseRoadmap(roadmapContent);
+                normSlices = parsed.slices.map(s => ({ id: s.id, done: s.done, title: s.title, risk: s.risk || 'medium', depends: s.depends, demo: '' }));
+            }
+            if (!normSlices)
+                normSlices = [];
+            for (const s of normSlices) {
                 const isActiveSlice = state.activeMilestone?.id === mid &&
                     state.activeSlice?.id === s.id;
                 const tasks = [];
                 if (isActiveSlice) {
-                    const planFile = resolveSliceFile(basePath, mid, s.id, 'PLAN');
-                    const planContent = planFile ? readFileCached(planFile) : null;
-                    if (planContent) {
-                        const plan = parsePlan(planContent);
-                        for (const t of plan.tasks) {
-                            tasks.push({
-                                id: t.id,
-                                title: t.title,
-                                done: t.done,
-                                active: state.activeTask?.id === t.id,
-                                estimate: t.estimate || undefined,
-                            });
+                    // Normalize tasks from DB, fall back to file parsing when DB has no data
+                    let usedDbTasks = false;
+                    if (isDbAvailable()) {
+                        const dbTasks = getSliceTasks(mid, s.id);
+                        if (dbTasks.length > 0) {
+                            usedDbTasks = true;
+                            for (const t of dbTasks) {
+                                tasks.push({
+                                    id: t.id,
+                                    title: t.title,
+                                    done: t.status === 'complete' || t.status === 'done',
+                                    active: state.activeTask?.id === t.id,
+                                    estimate: t.estimate || undefined,
+                                });
+                            }
+                        }
+                    }
+                    if (!usedDbTasks) {
+                        // File-based fallback: parse slice plan for task entries
+                        const slicePlanFile = resolveSliceFile(basePath, mid, s.id, 'PLAN');
+                        if (slicePlanFile) {
+                            const planContent = readFileCached(slicePlanFile);
+                            if (planContent) {
+                                const parsed = parsePlan(planContent);
+                                for (const t of parsed.tasks) {
+                                    tasks.push({
+                                        id: t.id,
+                                        title: t.title,
+                                        done: t.done,
+                                        active: state.activeTask?.id === t.id,
+                                        estimate: t.estimate || undefined,
+                                    });
+                                }
+                            }
                         }
                     }
                 }

package/dist/resources/extensions/gsd/workspace-index.js

@@ -1,12 +1,16 @@
-import { loadFile, parsePlan, parseRoadmap } from "./files.js";
+import { loadFile } from "./files.js";
+import { isDbAvailable, getMilestoneSlices, getSliceTasks } from "./gsd-db.js";
+import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveTaskFile, resolveTasksDir, } from "./paths.js";
 import { deriveState } from "./state.js";
 import { findMilestoneIds } from "./guided-flow.js";
-import { validateCompleteBoundary, validatePlanBoundary } from "./observability-validator.js";
 import { getSliceBranchName, detectWorktreeName } from "./worktree.js";
+// Extract milestone title from roadmap header without using parsers.
+// Falls back to the milestone ID if no title line found.
 function titleFromRoadmapHeader(content, fallbackId) {
-    const roadmap = parseRoadmap(content);
-    return roadmap.title.replace(/^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/, "") || fallbackId;
+    // Parse the "# M001: Title" header directly
+    const match = content.match(/^#\s+M\d+(?:-[a-z0-9]{6})?[^:]*:\s*(.+)/m);
+    return match?.[1]?.trim() || fallbackId;
 }
 async function indexSlice(basePath, milestoneId, sliceId, fallbackTitle, done, roadmapMeta) {
     const planPath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN") ?? undefined;
@@ -15,12 +19,30 @@ async function indexSlice(basePath, milestoneId, sliceId, fallbackTitle, done, r
     const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId) ?? undefined;
     const tasks = [];
     let title = fallbackTitle;
-    if (planPath) {
-        const content = await loadFile(planPath);
-        if (content) {
-            const plan = parsePlan(content);
-            title = plan.title || fallbackTitle;
-            for (const task of plan.tasks) {
+    // Prefer DB for task data, fall back to file parsing when DB has no data
+    let usedDb = false;
+    if (isDbAvailable()) {
+        const dbTasks = getSliceTasks(milestoneId, sliceId);
+        if (dbTasks.length > 0) {
+            usedDb = true;
+            for (const task of dbTasks) {
+                title = fallbackTitle; // title comes from slice-level data, not plan
+                tasks.push({
+                    id: task.id,
+                    title: task.title,
+                    done: task.status === "complete" || task.status === "done",
+                    planPath: resolveTaskFile(basePath, milestoneId, sliceId, task.id, "PLAN") ?? undefined,
+                    summaryPath: resolveTaskFile(basePath, milestoneId, sliceId, task.id, "SUMMARY") ?? undefined,
+                });
+            }
+        }
+    }
+    if (!usedDb && planPath) {
+        // File-based fallback: parse slice plan for task entries
+        const planContent = await loadFile(planPath);
+        if (planContent) {
+            const parsed = parsePlan(planContent);
+            for (const task of parsed.tasks) {
                 tasks.push({
                     id: task.id,
                     title: task.title,
@@ -49,36 +71,41 @@ async function indexSlice(basePath, milestoneId, sliceId, fallbackTitle, done, r
 export async function indexWorkspace(basePath, opts = {}) {
     const milestoneIds = findMilestoneIds(basePath);
     const milestones = [];
-    const validationIssues = [];
-    const runValidation = opts.validate === true;
     for (const milestoneId of milestoneIds) {
         const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP") ?? undefined;
         let title = milestoneId;
         const slices = [];
-        if (roadmapPath) {
-            const roadmapContent = await loadFile(roadmapPath);
-            if (roadmapContent) {
-                const roadmap = parseRoadmap(roadmapContent);
-                title = titleFromRoadmapHeader(roadmapContent, milestoneId);
-                // Parallelise all per-slice I/O: indexSlice + (optional) validation calls run concurrently.
-                // Order is preserved via Promise.all on an array built from roadmap.slices.
-                const sliceResults = await Promise.all(roadmap.slices.map(async (slice) => {
-                    if (runValidation) {
-                        const [indexedSlice, planIssues, completeIssues] = await Promise.all([
-                            indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done, { risk: slice.risk, depends: slice.depends, demo: slice.demo }),
-                            validatePlanBoundary(basePath, milestoneId, slice.id),
-                            validateCompleteBoundary(basePath, milestoneId, slice.id),
-                        ]);
-                        return { indexedSlice, issues: [...planIssues, ...completeIssues] };
-                    }
-                    const indexedSlice = await indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done, { risk: slice.risk, depends: slice.depends, demo: slice.demo });
-                    return { indexedSlice, issues: [] };
-                }));
-                for (const { indexedSlice, issues } of sliceResults) {
-                    slices.push(indexedSlice);
-                    validationIssues.push(...issues);
+        if (roadmapPath || isDbAvailable()) {
+            let normSlices = null;
+            if (isDbAvailable()) {
+                const dbSlices = getMilestoneSlices(milestoneId);
+                if (dbSlices.length > 0) {
+                    normSlices = dbSlices.map(s => ({ id: s.id, done: s.status === "complete", title: s.title, risk: s.risk || "medium", depends: s.depends, demo: s.demo }));
+                }
+                // Get title from roadmap header
+                if (roadmapPath) {
+                    const roadmapContent = await loadFile(roadmapPath);
+                    if (roadmapContent)
+                        title = titleFromRoadmapHeader(roadmapContent, milestoneId);
+                }
+            }
+            if (!normSlices && roadmapPath) {
+                // File-based fallback: parse roadmap for slice entries
+                const roadmapContent = await loadFile(roadmapPath);
+                if (roadmapContent) {
+                    title = titleFromRoadmapHeader(roadmapContent, milestoneId);
+                    const parsed = parseRoadmap(roadmapContent);
+                    normSlices = parsed.slices.map(s => ({ id: s.id, done: s.done, title: s.title, risk: s.risk || "medium", depends: s.depends, demo: s.demo || "" }));
                 }
             }
+            if (!normSlices)
+                normSlices = [];
+            if (normSlices.length > 0) {
+                const sliceResults = await Promise.all(normSlices.map(async (slice) => {
+                    return indexSlice(basePath, milestoneId, slice.id, slice.title, slice.done, { risk: slice.risk, depends: slice.depends, demo: slice.demo });
+                }));
+                slices.push(...sliceResults);
+            }
         }
         milestones.push({ id: milestoneId, title, roadmapPath, slices });
     }
@@ -103,7 +130,7 @@ export async function indexWorkspace(basePath, opts = {}) {
             }
         }
     }
-    return { milestones, active, scopes, validationIssues };
+    return { milestones, active, scopes, validationIssues: [] };
 }
 export async function listDoctorScopeSuggestions(basePath) {
     const index = await indexWorkspace(basePath);
@@ -121,8 +148,7 @@ export async function listDoctorScopeSuggestions(basePath) {
     return ordered.map(scope => ({ value: scope.scope, label: scope.label }));
 }
 export async function getSuggestedNextCommands(basePath) {
-    // Run validation here since we surface a /gsd doctor audit hint when issues exist.
-    const index = await indexWorkspace(basePath, { validate: true });
+    const index = await indexWorkspace(basePath);
     const scope = index.active.milestoneId && index.active.sliceId
         ? `${index.active.milestoneId}/${index.active.sliceId}`
         : index.active.milestoneId;
@@ -135,8 +161,6 @@ export async function getSuggestedNextCommands(basePath) {
         commands.add(`/gsd doctor ${scope}`);
     if (scope)
         commands.add(`/gsd doctor fix ${scope}`);
-    if (index.validationIssues.length > 0 && scope)
-        commands.add(`/gsd doctor audit ${scope}`);
     commands.add("/gsd status");
     return [...commands];
 }

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-VvclDCW6TAWjEyLU-EYL1
+alS4hoANx0TK4UVZY27da