gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

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

@@ -1,13 +1,15 @@
 // GSD Extension — State Derivation
-// Reads roadmap + plan files to determine current position.
+// DB-primary state derivation with filesystem fallback for unmigrated projects.
 // Pure TypeScript, zero Pi dependencies.
-import { parseRoadmap, parsePlan, parseSummary, loadFile, parseRequirementCounts, parseContextDependsOn, } from './files.js';
+import { parseRoadmap, parsePlan, } from './parsers-legacy.js';
+import { parseSummary, loadFile, parseRequirementCounts, parseContextDependsOn, } from './files.js';
 import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveGsdRootFile, gsdRoot, } from './paths.js';
 import { findMilestoneIds } from './milestone-ids.js';
 import { nativeBatchParseGsdFiles } from './native-parser-bridge.js';
 import { join, resolve } from 'path';
 import { existsSync, readdirSync } from 'node:fs';
 import { debugCount, debugTime } from './debug-logger.js';
+import { isDbAvailable, getAllMilestones, getMilestoneSlices, getSliceTasks, getReplanHistory, getSlice, } from './gsd-db.js';
 /**
  * A "ghost" milestone directory contains only META.json (and no substantive
  * files like CONTEXT, CONTEXT-DRAFT, ROADMAP, or SUMMARY).  These appear when
@@ -66,40 +68,48 @@ export function invalidateStateCache() {
  * Returns the ID of the first incomplete milestone, or null if all are complete.
  */
 export async function getActiveMilestoneId(basePath) {
-    const milestoneIds = findMilestoneIds(basePath);
     // Parallel worker isolation
     const milestoneLock = process.env.GSD_MILESTONE_LOCK;
     if (milestoneLock) {
+        const milestoneIds = findMilestoneIds(basePath);
         if (!milestoneIds.includes(milestoneLock))
             return null;
-        // Locked milestone that is parked should not be active
         const lockedParked = resolveMilestoneFile(basePath, milestoneLock, "PARKED");
         if (lockedParked)
             return null;
         return milestoneLock;
     }
+    // DB-first: query milestones table for the first non-complete, non-parked milestone
+    if (isDbAvailable()) {
+        const allMilestones = getAllMilestones();
+        if (allMilestones.length > 0) {
+            const sorted = [...allMilestones].sort((a, b) => a.id.localeCompare(b.id));
+            for (const m of sorted) {
+                if (m.status === "complete" || m.status === "done" || m.status === "parked")
+                    continue;
+                return m.id;
+            }
+            return null;
+        }
+    }
+    // Filesystem fallback for unmigrated projects or empty DB
+    const milestoneIds = findMilestoneIds(basePath);
     for (const mid of milestoneIds) {
-        // Skip parked milestones — they are not eligible for active status
         const parkedFile = resolveMilestoneFile(basePath, mid, "PARKED");
         if (parkedFile)
             continue;
         const roadmapFile = resolveMilestoneFile(basePath, mid, "ROADMAP");
         const content = roadmapFile ? await loadFile(roadmapFile) : null;
         if (!content) {
-            // No roadmap — but if a summary exists, the milestone is already complete
             const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
             if (summaryFile)
-                continue; // completed milestone, skip
+                continue;
             if (isGhostMilestone(basePath, mid))
-                continue; // ghost dir — skip
-            return mid; // No roadmap and no summary — milestone is incomplete
-            // Note: draft-awareness (CONTEXT-DRAFT.md) is handled in deriveState(), not here.
-            // A draft milestone is still "active" — this function only determines which milestone is current.
+                continue;
+            return mid;
         }
         const roadmap = parseRoadmap(content);
         if (!isMilestoneComplete(roadmap)) {
-            // Summary is the terminal artifact — if it exists, the milestone is
-            // complete even when roadmap checkboxes weren't ticked (#864).
             const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
             if (!summaryFile)
                 return mid;
@@ -108,13 +118,12 @@ export async function getActiveMilestoneId(basePath) {
     return null;
 }
 /**
- * Reconstruct GSD state from files on disk.
- * This is the source of truth — STATE.md is just a cache of this output.
+ * Reconstruct GSD state from DB (primary) or filesystem (fallback).
+ * STATE.md is a rendered cache of this output.
  *
- * Uses native batch parsing when available: a single Rust call reads and parses
- * every .md file under .gsd/, populating an in-memory cache that replaces all
- * individual loadFile() calls during milestone/slice/task traversal.
- * Falls back to sequential JS file reads when the native module is absent.
+ * When DB is available, queries milestone/slice/task tables directly.
+ * Falls back to filesystem parsing for unmigrated projects or when DB
+ * has zero milestones (e.g. first run before migration).
  */
 export async function deriveState(basePath) {
     // Return cached result if within the TTL window for the same basePath
@@ -124,7 +133,23 @@ export async function deriveState(basePath) {
         return _stateCache.result;
     }
     const stopTimer = debugTime("derive-state-impl");
-    const result = await _deriveStateImpl(basePath);
+    let result;
+    // Dual-path: try DB-backed derivation first when hierarchy tables are populated
+    if (isDbAvailable()) {
+        const dbMilestones = getAllMilestones();
+        if (dbMilestones.length > 0) {
+            const stopDbTimer = debugTime("derive-state-db");
+            result = await deriveStateFromDb(basePath);
+            stopDbTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
+        }
+        else {
+            // DB open but empty hierarchy tables — pre-migration project, use filesystem
+            result = await _deriveStateImpl(basePath);
+        }
+    }
+    else {
+        result = await _deriveStateImpl(basePath);
+    }
     stopTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
     debugCount("deriveStateCalls");
     _stateCache = { basePath, result, timestamp: Date.now() };
@@ -134,6 +159,13 @@ export async function deriveState(basePath) {
  * Extract milestone title from CONTEXT.md or CONTEXT-DRAFT.md heading.
  * Falls back to the provided fallback (usually the milestone ID).
  */
+/**
+ * Strip the "M001: " prefix from a milestone title to get the human-readable name.
+ * Used by both DB and filesystem paths for consistency.
+ */
+function stripMilestonePrefix(title) {
+    return title.replace(/^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/, '') || title;
+}
 function extractContextTitle(content, fallback) {
     if (!content)
         return fallback;
@@ -141,9 +173,434 @@ function extractContextTitle(content, fallback) {
     if (!h1)
         return fallback;
     // Extract title from "# M005: Platform Foundation & Separation" format
-    return h1.slice(2).trim().replace(/^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/, '') || fallback;
+    return stripMilestonePrefix(h1.slice(2).trim()) || fallback;
+}
+// ─── DB-backed State Derivation ────────────────────────────────────────────
+/**
+ * Helper: check if a DB status counts as "done" (handles K002 ambiguity).
+ */
+function isStatusDone(status) {
+    return status === 'complete' || status === 'done';
+}
+/**
+ * Derive GSD state from the milestones/slices/tasks DB tables.
+ * Flag files (PARKED, VALIDATION, CONTINUE, REPLAN, REPLAN-TRIGGER, CONTEXT-DRAFT)
+ * are still checked on the filesystem since they aren't in DB tables.
+ * Requirements also stay file-based via parseRequirementCounts().
+ *
+ * Must produce field-identical GSDState to _deriveStateImpl() for the same project.
+ */
+export async function deriveStateFromDb(basePath) {
+    const requirements = parseRequirementCounts(await loadFile(resolveGsdRootFile(basePath, "REQUIREMENTS")));
+    const allMilestones = getAllMilestones();
+    // Parallel worker isolation: when locked, filter to just the locked milestone
+    const milestoneLock = process.env.GSD_MILESTONE_LOCK;
+    const milestones = milestoneLock
+        ? allMilestones.filter(m => m.id === milestoneLock)
+        : allMilestones;
+    if (milestones.length === 0) {
+        return {
+            activeMilestone: null,
+            activeSlice: null,
+            activeTask: null,
+            phase: 'pre-planning',
+            recentDecisions: [],
+            blockers: [],
+            nextAction: 'No milestones found. Run /gsd to create one.',
+            registry: [],
+            requirements,
+            progress: { milestones: { done: 0, total: 0 } },
+        };
+    }
+    // Phase 1: Build completeness set (which milestones count as "done" for dep resolution)
+    const completeMilestoneIds = new Set();
+    const parkedMilestoneIds = new Set();
+    for (const m of milestones) {
+        // Check disk for PARKED flag (not stored in DB status reliably — disk is truth for flag files)
+        const parkedFile = resolveMilestoneFile(basePath, m.id, "PARKED");
+        if (parkedFile || m.status === 'parked') {
+            parkedMilestoneIds.add(m.id);
+            continue;
+        }
+        if (isStatusDone(m.status)) {
+            completeMilestoneIds.add(m.id);
+            continue;
+        }
+        // Check if milestone has a summary on disk (terminal artifact per #864)
+        const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
+        if (summaryFile) {
+            completeMilestoneIds.add(m.id);
+            continue;
+        }
+        // Check roadmap: all slices done means milestone is complete
+        const slices = getMilestoneSlices(m.id);
+        if (slices.length > 0 && slices.every(s => isStatusDone(s.status))) {
+            // All slices done but no summary — still counts as complete for dep resolution
+            // if a summary file exists
+            // Note: without summary file, the milestone is in validating/completing state, not complete
+        }
+    }
+    // Phase 2: Build registry and find active milestone
+    const registry = [];
+    let activeMilestone = null;
+    let activeMilestoneSlices = [];
+    let activeMilestoneFound = false;
+    let activeMilestoneHasDraft = false;
+    for (const m of milestones) {
+        if (parkedMilestoneIds.has(m.id)) {
+            registry.push({ id: m.id, title: stripMilestonePrefix(m.title) || m.id, status: 'parked' });
+            continue;
+        }
+        // Ghost milestone check: no slices in DB AND no substantive files on disk
+        const slices = getMilestoneSlices(m.id);
+        if (slices.length === 0 && !isStatusDone(m.status)) {
+            // Check disk for ghost detection
+            if (isGhostMilestone(basePath, m.id))
+                continue;
+        }
+        const summaryFile = resolveMilestoneFile(basePath, m.id, "SUMMARY");
+        // Determine if this milestone is complete
+        if (completeMilestoneIds.has(m.id) || (summaryFile !== null)) {
+            // Get title from DB or summary
+            let title = stripMilestonePrefix(m.title) || m.id;
+            if (summaryFile && !m.title) {
+                const summaryContent = await loadFile(summaryFile);
+                if (summaryContent) {
+                    title = parseSummary(summaryContent).title || m.id;
+                }
+            }
+            registry.push({ id: m.id, title, status: 'complete' });
+            completeMilestoneIds.add(m.id); // ensure it's in the set
+            continue;
+        }
+        // Not complete — determine if it should be active
+        const allSlicesDone = slices.length > 0 && slices.every(s => isStatusDone(s.status));
+        // Get title — prefer DB, fall back to context file extraction
+        let title = stripMilestonePrefix(m.title) || m.id;
+        if (title === m.id) {
+            const contextFile = resolveMilestoneFile(basePath, m.id, "CONTEXT");
+            const draftFile = resolveMilestoneFile(basePath, m.id, "CONTEXT-DRAFT");
+            const contextContent = contextFile ? await loadFile(contextFile) : null;
+            const draftContent = draftFile && !contextContent ? await loadFile(draftFile) : null;
+            title = extractContextTitle(contextContent || draftContent, m.id);
+        }
+        if (!activeMilestoneFound) {
+            // Check milestone-level dependencies
+            const deps = m.depends_on;
+            const depsUnmet = deps.some(dep => !completeMilestoneIds.has(dep));
+            if (depsUnmet) {
+                registry.push({ id: m.id, title, status: 'pending', dependsOn: deps });
+                continue;
+            }
+            // Handle all-slices-done case (validating/completing)
+            if (allSlicesDone) {
+                const validationFile = resolveMilestoneFile(basePath, m.id, "VALIDATION");
+                const validationContent = validationFile ? await loadFile(validationFile) : null;
+                const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
+                if (!validationTerminal || (validationTerminal && !summaryFile)) {
+                    // Validating or completing — still active
+                    activeMilestone = { id: m.id, title };
+                    activeMilestoneSlices = slices;
+                    activeMilestoneFound = true;
+                    registry.push({ id: m.id, title, status: 'active', ...(deps.length > 0 ? { dependsOn: deps } : {}) });
+                    continue;
+                }
+            }
+            // Check for context draft (needs-discussion phase)
+            const contextFile = resolveMilestoneFile(basePath, m.id, "CONTEXT");
+            const draftFile = resolveMilestoneFile(basePath, m.id, "CONTEXT-DRAFT");
+            if (!contextFile && draftFile)
+                activeMilestoneHasDraft = true;
+            activeMilestone = { id: m.id, title };
+            activeMilestoneSlices = slices;
+            activeMilestoneFound = true;
+            registry.push({ id: m.id, title, status: 'active', ...(deps.length > 0 ? { dependsOn: deps } : {}) });
+        }
+        else {
+            // After active milestone found — rest are pending
+            const deps = m.depends_on;
+            registry.push({ id: m.id, title, status: 'pending', ...(deps.length > 0 ? { dependsOn: deps } : {}) });
+        }
+    }
+    const milestoneProgress = {
+        done: registry.filter(e => e.status === 'complete').length,
+        total: registry.length,
+    };
+    // ── No active milestone ──────────────────────────────────────────────
+    if (!activeMilestone) {
+        const pendingEntries = registry.filter(e => e.status === 'pending');
+        const parkedEntries = registry.filter(e => e.status === 'parked');
+        if (pendingEntries.length > 0) {
+            const blockerDetails = pendingEntries
+                .filter(e => e.dependsOn && e.dependsOn.length > 0)
+                .map(e => `${e.id} is waiting on unmet deps: ${e.dependsOn.join(', ')}`);
+            return {
+                activeMilestone: null, activeSlice: null, activeTask: null,
+                phase: 'blocked',
+                recentDecisions: [], blockers: blockerDetails.length > 0
+                    ? blockerDetails
+                    : ['All remaining milestones are dep-blocked but no deps listed — check CONTEXT.md files'],
+                nextAction: 'Resolve milestone dependencies before proceeding.',
+                registry, requirements,
+                progress: { milestones: milestoneProgress },
+            };
+        }
+        if (parkedEntries.length > 0) {
+            const parkedIds = parkedEntries.map(e => e.id).join(', ');
+            return {
+                activeMilestone: null, activeSlice: null, activeTask: null,
+                phase: 'pre-planning',
+                recentDecisions: [], blockers: [],
+                nextAction: `All remaining milestones are parked (${parkedIds}). Run /gsd unpark <id> or create a new milestone.`,
+                registry, requirements,
+                progress: { milestones: milestoneProgress },
+            };
+        }
+        if (registry.length === 0) {
+            return {
+                activeMilestone: null, activeSlice: null, activeTask: null,
+                phase: 'pre-planning',
+                recentDecisions: [], blockers: [],
+                nextAction: 'No milestones found. Run /gsd to create one.',
+                registry: [], requirements,
+                progress: { milestones: { done: 0, total: 0 } },
+            };
+        }
+        // All milestones complete
+        const lastEntry = registry[registry.length - 1];
+        const activeReqs = requirements.active ?? 0;
+        const completionNote = activeReqs > 0
+            ? `All milestones complete. ${activeReqs} active requirement${activeReqs === 1 ? '' : 's'} in REQUIREMENTS.md ${activeReqs === 1 ? 'has' : 'have'} not been mapped to a milestone.`
+            : 'All milestones complete.';
+        return {
+            activeMilestone: lastEntry ? { id: lastEntry.id, title: lastEntry.title } : null,
+            activeSlice: null, activeTask: null,
+            phase: 'complete',
+            recentDecisions: [], blockers: [],
+            nextAction: completionNote,
+            registry, requirements,
+            progress: { milestones: milestoneProgress },
+        };
+    }
+    // ── Active milestone has no slices or no roadmap ────────────────────
+    const hasRoadmap = resolveMilestoneFile(basePath, activeMilestone.id, "ROADMAP") !== null;
+    if (activeMilestoneSlices.length === 0) {
+        if (!hasRoadmap) {
+            const phase = activeMilestoneHasDraft ? 'needs-discussion' : 'pre-planning';
+            const nextAction = activeMilestoneHasDraft
+                ? `Discuss draft context for milestone ${activeMilestone.id}.`
+                : `Plan milestone ${activeMilestone.id}.`;
+            return {
+                activeMilestone, activeSlice: null, activeTask: null,
+                phase, recentDecisions: [], blockers: [],
+                nextAction, registry, requirements,
+                progress: { milestones: milestoneProgress },
+            };
+        }
+        // Has roadmap file but zero slices in DB — pre-planning (zero-slice roadmap guard)
+        return {
+            activeMilestone, activeSlice: null, activeTask: null,
+            phase: 'pre-planning',
+            recentDecisions: [], blockers: [],
+            nextAction: `Milestone ${activeMilestone.id} has a roadmap but no slices defined. Add slices to the roadmap.`,
+            registry, requirements,
+            progress: {
+                milestones: milestoneProgress,
+                slices: { done: 0, total: 0 },
+            },
+        };
+    }
+    // ── All slices done → validating/completing ─────────────────────────
+    const allSlicesDone = activeMilestoneSlices.every(s => isStatusDone(s.status));
+    if (allSlicesDone) {
+        const validationFile = resolveMilestoneFile(basePath, activeMilestone.id, "VALIDATION");
+        const validationContent = validationFile ? await loadFile(validationFile) : null;
+        const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
+        const sliceProgress = {
+            done: activeMilestoneSlices.length,
+            total: activeMilestoneSlices.length,
+        };
+        if (!validationTerminal) {
+            return {
+                activeMilestone, activeSlice: null, activeTask: null,
+                phase: 'validating-milestone',
+                recentDecisions: [], blockers: [],
+                nextAction: `Validate milestone ${activeMilestone.id} before completion.`,
+                registry, requirements,
+                progress: { milestones: milestoneProgress, slices: sliceProgress },
+            };
+        }
+        return {
+            activeMilestone, activeSlice: null, activeTask: null,
+            phase: 'completing-milestone',
+            recentDecisions: [], blockers: [],
+            nextAction: `All slices complete in ${activeMilestone.id}. Write milestone summary.`,
+            registry, requirements,
+            progress: { milestones: milestoneProgress, slices: sliceProgress },
+        };
+    }
+    // ── Find active slice (first incomplete with deps satisfied) ─────────
+    const sliceProgress = {
+        done: activeMilestoneSlices.filter(s => isStatusDone(s.status)).length,
+        total: activeMilestoneSlices.length,
+    };
+    const doneSliceIds = new Set(activeMilestoneSlices.filter(s => isStatusDone(s.status)).map(s => s.id));
+    let activeSlice = null;
+    let activeSliceRow = null;
+    for (const s of activeMilestoneSlices) {
+        if (isStatusDone(s.status))
+            continue;
+        if (s.depends.every(dep => doneSliceIds.has(dep))) {
+            activeSlice = { id: s.id, title: s.title };
+            activeSliceRow = s;
+            break;
+        }
+    }
+    if (!activeSlice) {
+        return {
+            activeMilestone, activeSlice: null, activeTask: null,
+            phase: 'blocked',
+            recentDecisions: [], blockers: ['No slice eligible — check dependency ordering'],
+            nextAction: 'Resolve dependency blockers or plan next slice.',
+            registry, requirements,
+            progress: { milestones: milestoneProgress, slices: sliceProgress },
+        };
+    }
+    // ── Check for slice plan file on disk ────────────────────────────────
+    const planFile = resolveSliceFile(basePath, activeMilestone.id, activeSlice.id, "PLAN");
+    if (!planFile) {
+        return {
+            activeMilestone, activeSlice, activeTask: null,
+            phase: 'planning',
+            recentDecisions: [], blockers: [],
+            nextAction: `Plan slice ${activeSlice.id} (${activeSlice.title}).`,
+            registry, requirements,
+            progress: { milestones: milestoneProgress, slices: sliceProgress },
+        };
+    }
+    // ── Get tasks from DB ────────────────────────────────────────────────
+    const tasks = getSliceTasks(activeMilestone.id, activeSlice.id);
+    const taskProgress = {
+        done: tasks.filter(t => isStatusDone(t.status)).length,
+        total: tasks.length,
+    };
+    const activeTaskRow = tasks.find(t => !isStatusDone(t.status));
+    if (!activeTaskRow && tasks.length > 0) {
+        // All tasks done but slice not marked complete → summarizing
+        return {
+            activeMilestone, activeSlice, activeTask: null,
+            phase: 'summarizing',
+            recentDecisions: [], blockers: [],
+            nextAction: `All tasks done in ${activeSlice.id}. Write slice summary and complete slice.`,
+            registry, requirements,
+            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
+        };
+    }
+    // Empty plan — no tasks defined yet
+    if (!activeTaskRow) {
+        return {
+            activeMilestone, activeSlice, activeTask: null,
+            phase: 'planning',
+            recentDecisions: [], blockers: [],
+            nextAction: `Slice ${activeSlice.id} has a plan file but no tasks. Add tasks to the plan.`,
+            registry, requirements,
+            progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
+        };
+    }
+    const activeTask = { id: activeTaskRow.id, title: activeTaskRow.title };
+    // ── Task plan file check (#909) ─────────────────────────────────────
+    const tasksDir = resolveTasksDir(basePath, activeMilestone.id, activeSlice.id);
+    if (tasksDir && existsSync(tasksDir) && tasks.length > 0) {
+        const allFiles = readdirSync(tasksDir).filter(f => f.endsWith(".md"));
+        if (allFiles.length === 0) {
+            return {
+                activeMilestone, activeSlice, activeTask: null,
+                phase: 'planning',
+                recentDecisions: [], blockers: [],
+                nextAction: `Task plan files missing for ${activeSlice.id}. Run plan-slice to generate task plans.`,
+                registry, requirements,
+                progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
+            };
+        }
+    }
+    // ── Blocker detection: check completed tasks for blocker_discovered ──
+    const completedTasks = tasks.filter(t => isStatusDone(t.status));
+    let blockerTaskId = null;
+    for (const ct of completedTasks) {
+        if (ct.blocker_discovered) {
+            blockerTaskId = ct.id;
+            break;
+        }
+        // Also check disk summary in case DB doesn't have the flag
+        const summaryFile = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, ct.id, "SUMMARY");
+        if (!summaryFile)
+            continue;
+        const summaryContent = await loadFile(summaryFile);
+        if (!summaryContent)
+            continue;
+        const summary = parseSummary(summaryContent);
+        if (summary.frontmatter.blocker_discovered) {
+            blockerTaskId = ct.id;
+            break;
+        }
+    }
+    if (blockerTaskId) {
+        // Loop protection: if replan_history has entries for this slice, a replan
+        // was already performed — don't re-enter replanning phase.
+        const replanHistory = getReplanHistory(activeMilestone.id, activeSlice.id);
+        if (replanHistory.length === 0) {
+            return {
+                activeMilestone, activeSlice, activeTask,
+                phase: 'replanning-slice',
+                recentDecisions: [],
+                blockers: [`Task ${blockerTaskId} discovered a blocker requiring slice replan`],
+                nextAction: `Task ${blockerTaskId} reported blocker_discovered. Replan slice ${activeSlice.id} before continuing.`,
+                activeWorkspace: undefined,
+                registry, requirements,
+                progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
+            };
+        }
+    }
+    // ── REPLAN-TRIGGER detection ─────────────────────────────────────────
+    if (!blockerTaskId) {
+        const sliceRow = getSlice(activeMilestone.id, activeSlice.id);
+        if (sliceRow?.replan_triggered_at) {
+            // Loop protection: if replan_history has entries, replan was already done
+            const replanHistory = getReplanHistory(activeMilestone.id, activeSlice.id);
+            if (replanHistory.length === 0) {
+                return {
+                    activeMilestone, activeSlice, activeTask,
+                    phase: 'replanning-slice',
+                    recentDecisions: [],
+                    blockers: ['Triage replan trigger detected — slice replan required'],
+                    nextAction: `Triage replan triggered for slice ${activeSlice.id}. Replan before continuing.`,
+                    activeWorkspace: undefined,
+                    registry, requirements,
+                    progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
+                };
+            }
+        }
+    }
+    // ── Check for interrupted work ───────────────────────────────────────
+    const sDir = resolveSlicePath(basePath, activeMilestone.id, activeSlice.id);
+    const continueFile = sDir ? resolveSliceFile(basePath, activeMilestone.id, activeSlice.id, "CONTINUE") : null;
+    const hasInterrupted = !!(continueFile && await loadFile(continueFile)) ||
+        !!(sDir && await loadFile(join(sDir, "continue.md")));
+    return {
+        activeMilestone, activeSlice, activeTask,
+        phase: 'executing',
+        recentDecisions: [], blockers: [],
+        nextAction: hasInterrupted
+            ? `Resume interrupted work on ${activeTask.id}: ${activeTask.title} in slice ${activeSlice.id}. Read continue.md first.`
+            : `Execute ${activeTask.id}: ${activeTask.title} in slice ${activeSlice.id}.`,
+        registry, requirements,
+        progress: { milestones: milestoneProgress, slices: sliceProgress, tasks: taskProgress },
+    };
 }
-async function _deriveStateImpl(basePath) {
+// LEGACY: Filesystem-based state derivation for unmigrated projects.
+// DB-backed projects use deriveStateFromDb() above. Target: extract to
+// state-legacy.ts when all projects are DB-backed.
+export async function _deriveStateImpl(basePath) {
     const milestoneIds = findMilestoneIds(basePath);
     // ── Parallel worker isolation ──────────────────────────────────────────
     // When GSD_MILESTONE_LOCK is set, this process is a parallel worker
@@ -162,12 +619,9 @@ async function _deriveStateImpl(basePath) {
     // This eliminates O(N) individual fs.readFile calls during traversal.
     const fileContentCache = new Map();
     const gsdDir = gsdRoot(basePath);
-    // NOTE: We intentionally do NOT load from the SQLite DB here (#759).
-    // The DB's artifacts table is populated once during migrateFromMarkdown
-    // and is never updated when files change on disk (e.g. roadmap [x] updates,
-    // plan checkbox changes). Using stale DB content causes deriveState to
-    // return incorrect phase/slice state, leading to infinite skip loops.
-    // The native Rust batch parser is fast enough for state derivation.
+    // Filesystem fallback: used when deriveStateFromDb() is not available
+    // (pre-migration projects). The DB-backed path is preferred when available
+    // — see deriveStateFromDb() above.
     const batchFiles = nativeBatchParseGsdFiles(gsdDir);
     if (batchFiles) {
         for (const f of batchFiles) {
@@ -258,7 +712,7 @@ async function _deriveStateImpl(basePath) {
         if (parkedMilestoneIds.has(mid)) {
             const roadmap = roadmapCache.get(mid) ?? null;
             const title = roadmap
-                ? roadmap.title.replace(/^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/, '')
+                ? stripMilestonePrefix(roadmap.title)
                 : mid;
             registry.push({ id: mid, title, status: 'parked' });
             continue;
@@ -317,7 +771,7 @@ async function _deriveStateImpl(basePath) {
             }
             continue;
         }
-        const title = roadmap.title.replace(/^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/, '');
+        const title = stripMilestonePrefix(roadmap.title);
         const complete = isMilestoneComplete(roadmap);
         if (complete) {
             // All slices done — check validation and summary state