gsd-pi 2.33.0-dev.bafba33 → 2.33.1-dev.235d83a

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

@@ -0,0 +1,653 @@
+// GSD Extension — State Derivation
+// Reads roadmap + plan files to determine current position.
+// Pure TypeScript, zero Pi dependencies.
+import { parseRoadmap, parsePlan, parseSummary, loadFile, parseRequirementCounts, parseContextDependsOn, } from './files.js';
+import { resolveMilestoneFile, resolveSlicePath, resolveSliceFile, resolveTaskFile, resolveTasksDir, resolveGsdRootFile, gsdRoot, } from './paths.js';
+import { findMilestoneIds } from './guided-flow.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';
+// ─── Query Functions ───────────────────────────────────────────────────────
+/**
+ * Check if all tasks in a slice plan are done.
+ */
+export function isSliceComplete(plan) {
+    return plan.tasks.length > 0 && plan.tasks.every(t => t.done);
+}
+/**
+ * Check if all slices in a roadmap are done.
+ */
+export function isMilestoneComplete(roadmap) {
+    return roadmap.slices.length > 0 && roadmap.slices.every(s => s.done);
+}
+/**
+ * Check whether a VALIDATION file's verdict is terminal (pass or needs-attention).
+ * A non-terminal verdict (needs-remediation) means validation must re-run
+ * after remediation slices are executed.
+ */
+export function isValidationTerminal(validationContent) {
+    const match = validationContent.match(/^---\n([\s\S]*?)\n---/);
+    if (!match)
+        return false;
+    const verdict = match[1].match(/verdict:\s*(\S+)/);
+    if (!verdict)
+        return false;
+    // 'pass' and 'needs-attention' are always terminal.
+    // 'needs-remediation' is treated as terminal to prevent infinite loops
+    // when no remediation slices exist in the roadmap (#832). The validation
+    // report is preserved on disk for manual review.
+    return verdict[1] === 'pass' || verdict[1] === 'needs-attention' || verdict[1] === 'needs-remediation';
+}
+const CACHE_TTL_MS = 100;
+let _stateCache = null;
+/**
+ * Invalidate the deriveState() cache. Call this whenever planning files on disk
+ * may have changed (unit completion, merges, file writes).
+ */
+export function invalidateStateCache() {
+    _stateCache = null;
+}
+/**
+ * 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) {
+        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;
+    }
+    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
+            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.
+        }
+        const roadmap = parseRoadmap(content);
+        if (!isMilestoneComplete(roadmap))
+            return mid;
+    }
+    return null;
+}
+/**
+ * Reconstruct GSD state from files on disk.
+ * This is the source of truth — STATE.md is just a 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.
+ */
+export async function deriveState(basePath) {
+    // Return cached result if within the TTL window for the same basePath
+    if (_stateCache &&
+        _stateCache.basePath === basePath &&
+        Date.now() - _stateCache.timestamp < CACHE_TTL_MS) {
+        return _stateCache.result;
+    }
+    const stopTimer = debugTime("derive-state-impl");
+    const result = await _deriveStateImpl(basePath);
+    stopTimer({ phase: result.phase, milestone: result.activeMilestone?.id });
+    debugCount("deriveStateCalls");
+    _stateCache = { basePath, result, timestamp: Date.now() };
+    return result;
+}
+async function _deriveStateImpl(basePath) {
+    const milestoneIds = findMilestoneIds(basePath);
+    // ── Parallel worker isolation ──────────────────────────────────────────
+    // When GSD_MILESTONE_LOCK is set, this process is a parallel worker
+    // scoped to a single milestone. Filter the milestone list so this worker
+    // only sees its assigned milestone (all others are treated as if they
+    // don't exist). This gives each worker complete isolation without
+    // modifying any other state derivation logic.
+    const milestoneLock = process.env.GSD_MILESTONE_LOCK;
+    if (milestoneLock && milestoneIds.includes(milestoneLock)) {
+        milestoneIds.length = 0;
+        milestoneIds.push(milestoneLock);
+    }
+    // ── Batch-parse file cache ──────────────────────────────────────────────
+    // When the native Rust parser is available, read every .md file under .gsd/
+    // in one call and build an in-memory content map keyed by absolute path.
+    // 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.
+    const batchFiles = nativeBatchParseGsdFiles(gsdDir);
+    if (batchFiles) {
+        for (const f of batchFiles) {
+            const absPath = resolve(gsdDir, f.path);
+            fileContentCache.set(absPath, f.rawContent);
+        }
+    }
+    /**
+     * Load file content from batch cache first, falling back to disk read.
+     * Resolves the path to absolute before cache lookup.
+     */
+    async function cachedLoadFile(path) {
+        const abs = resolve(path);
+        const cached = fileContentCache.get(abs);
+        if (cached !== undefined)
+            return cached;
+        return loadFile(path);
+    }
+    const requirements = parseRequirementCounts(await cachedLoadFile(resolveGsdRootFile(basePath, "REQUIREMENTS")));
+    if (milestoneIds.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 },
+            },
+        };
+    }
+    // ── Single-pass milestone scan ──────────────────────────────────────────
+    // Parse each milestone's roadmap once, caching results. First pass determines
+    // completeness for dependency resolution; second pass builds the registry.
+    // With the batch cache, all file reads hit memory instead of disk.
+    // Phase 1: Build roadmap cache and completeness set
+    const roadmapCache = new Map();
+    const completeMilestoneIds = new Set();
+    // Track parked milestone IDs so Phase 2 can check without re-reading disk
+    const parkedMilestoneIds = new Set();
+    for (const mid of milestoneIds) {
+        // Skip parked milestones — they do NOT count as complete (don't satisfy depends_on)
+        // But still parse their roadmap for title extraction in Phase 2.
+        const parkedFile = resolveMilestoneFile(basePath, mid, "PARKED");
+        if (parkedFile) {
+            parkedMilestoneIds.add(mid);
+            // Cache roadmap for title extraction (but don't add to completeMilestoneIds)
+            const prf = resolveMilestoneFile(basePath, mid, "ROADMAP");
+            const prc = prf ? await cachedLoadFile(prf) : null;
+            if (prc)
+                roadmapCache.set(mid, parseRoadmap(prc));
+            continue;
+        }
+        const rf = resolveMilestoneFile(basePath, mid, "ROADMAP");
+        const rc = rf ? await cachedLoadFile(rf) : null;
+        if (!rc) {
+            const sf = resolveMilestoneFile(basePath, mid, "SUMMARY");
+            if (sf)
+                completeMilestoneIds.add(mid);
+            continue;
+        }
+        const rmap = parseRoadmap(rc);
+        roadmapCache.set(mid, rmap);
+        if (!isMilestoneComplete(rmap))
+            continue;
+        const sf = resolveMilestoneFile(basePath, mid, "SUMMARY");
+        if (sf)
+            completeMilestoneIds.add(mid);
+    }
+    // Phase 2: Build registry using cached roadmaps (no re-parsing or re-reading)
+    const registry = [];
+    let activeMilestone = null;
+    let activeRoadmap = null;
+    let activeMilestoneFound = false;
+    let activeMilestoneHasDraft = false;
+    for (const mid of milestoneIds) {
+        // Skip parked milestones — register them as 'parked' and move on
+        if (parkedMilestoneIds.has(mid)) {
+            const roadmap = roadmapCache.get(mid) ?? null;
+            const title = roadmap
+                ? roadmap.title.replace(/^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/, '')
+                : mid;
+            registry.push({ id: mid, title, status: 'parked' });
+            continue;
+        }
+        const roadmap = roadmapCache.get(mid) ?? null;
+        if (!roadmap) {
+            // No roadmap — check if a summary exists (completed milestone without roadmap)
+            const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
+            if (summaryFile) {
+                const summaryContent = await cachedLoadFile(summaryFile);
+                const summaryTitle = summaryContent
+                    ? (parseSummary(summaryContent).title || mid)
+                    : mid;
+                registry.push({ id: mid, title: summaryTitle, status: 'complete' });
+                completeMilestoneIds.add(mid);
+                continue;
+            }
+            // No roadmap and no summary — treat as incomplete/active
+            if (!activeMilestoneFound) {
+                // Check for CONTEXT-DRAFT.md to distinguish draft-seeded from blank milestones.
+                // A draft seed means the milestone has discussion material but no full context yet.
+                const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
+                if (!contextFile) {
+                    const draftFile = resolveMilestoneFile(basePath, mid, "CONTEXT-DRAFT");
+                    if (draftFile)
+                        activeMilestoneHasDraft = true;
+                }
+                // Check milestone-level dependencies before promoting to active.
+                // Without this, a queued milestone with depends_on in its CONTEXT
+                // frontmatter would be promoted to active even when its deps are unmet
+                // (the dep check only existed in the has-roadmap path previously).
+                const contextContent = contextFile ? await cachedLoadFile(contextFile) : null;
+                const deps = parseContextDependsOn(contextContent);
+                const depsUnmet = deps.some(dep => !completeMilestoneIds.has(dep));
+                if (depsUnmet) {
+                    registry.push({ id: mid, title: mid, status: 'pending', dependsOn: deps });
+                }
+                else {
+                    activeMilestone = { id: mid, title: mid };
+                    activeMilestoneFound = true;
+                    registry.push({ id: mid, title: mid, status: 'active', ...(deps.length > 0 ? { dependsOn: deps } : {}) });
+                }
+            }
+            else {
+                registry.push({ id: mid, title: mid, status: 'pending' });
+            }
+            continue;
+        }
+        const title = roadmap.title.replace(/^M\d+(?:-[a-z0-9]{6})?[^:]*:\s*/, '');
+        const complete = isMilestoneComplete(roadmap);
+        if (complete) {
+            // All slices done — check validation and summary state
+            const summaryFile = resolveMilestoneFile(basePath, mid, "SUMMARY");
+            const validationFile = resolveMilestoneFile(basePath, mid, "VALIDATION");
+            const validationContent = validationFile ? await cachedLoadFile(validationFile) : null;
+            const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
+            if (summaryFile) {
+                // Summary exists → milestone is complete regardless of validation state.
+                // The summary is the terminal artifact (#864).
+                registry.push({ id: mid, title, status: 'complete' });
+            }
+            else if (!validationTerminal && !activeMilestoneFound) {
+                // No summary and no terminal validation → validating-milestone
+                activeMilestone = { id: mid, title };
+                activeRoadmap = roadmap;
+                activeMilestoneFound = true;
+                registry.push({ id: mid, title, status: 'active' });
+            }
+            else if (!validationTerminal && activeMilestoneFound) {
+                // No summary and no terminal validation, but another milestone is already active
+                registry.push({ id: mid, title, status: 'pending' });
+            }
+            else if (!activeMilestoneFound) {
+                // Terminal validation but no summary → completing-milestone
+                activeMilestone = { id: mid, title };
+                activeRoadmap = roadmap;
+                activeMilestoneFound = true;
+                registry.push({ id: mid, title, status: 'active' });
+            }
+            else {
+                registry.push({ id: mid, title, status: 'complete' });
+            }
+        }
+        else if (!activeMilestoneFound) {
+            // Check milestone-level dependencies before promoting to active
+            const contextFile = resolveMilestoneFile(basePath, mid, "CONTEXT");
+            const contextContent = contextFile ? await cachedLoadFile(contextFile) : null;
+            const deps = parseContextDependsOn(contextContent);
+            const depsUnmet = deps.some(dep => !completeMilestoneIds.has(dep));
+            if (depsUnmet) {
+                registry.push({ id: mid, title, status: 'pending', dependsOn: deps });
+                // Do NOT set activeMilestoneFound — let the loop continue to the next milestone
+            }
+            else {
+                activeMilestone = { id: mid, title };
+                activeRoadmap = roadmap;
+                activeMilestoneFound = true;
+                registry.push({ id: mid, title, status: 'active', ...(deps.length > 0 ? { dependsOn: deps } : {}) });
+            }
+        }
+        else {
+            const contextFile2 = resolveMilestoneFile(basePath, mid, "CONTEXT");
+            const contextContent2 = contextFile2 ? await cachedLoadFile(contextFile2) : null;
+            const deps2 = parseContextDependsOn(contextContent2);
+            registry.push({ id: mid, title, status: 'pending', ...(deps2.length > 0 ? { dependsOn: deps2 } : {}) });
+        }
+    }
+    const milestoneProgress = {
+        done: registry.filter(entry => entry.status === 'complete').length,
+        total: registry.length,
+    };
+    if (!activeMilestone) {
+        // Check whether any milestones are pending (dep-blocked) or parked
+        const pendingEntries = registry.filter(entry => entry.status === 'pending');
+        const parkedEntries = registry.filter(entry => entry.status === 'parked');
+        if (pendingEntries.length > 0) {
+            // All incomplete milestones are dep-blocked — no progress possible
+            const blockerDetails = pendingEntries
+                .filter(entry => entry.dependsOn && entry.dependsOn.length > 0)
+                .map(entry => `${entry.id} is waiting on unmet deps: ${entry.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) {
+            // All non-complete milestones are parked — nothing active, but not "all complete"
+            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,
+                },
+            };
+        }
+        // All milestones complete
+        const lastEntry = registry[registry.length - 1];
+        return {
+            activeMilestone: lastEntry ? { id: lastEntry.id, title: lastEntry.title } : null,
+            activeSlice: null,
+            activeTask: null,
+            phase: 'complete',
+            recentDecisions: [],
+            blockers: [],
+            nextAction: 'All milestones complete.',
+            registry,
+            requirements,
+            progress: {
+                milestones: milestoneProgress,
+            },
+        };
+    }
+    if (!activeRoadmap) {
+        // Active milestone exists but has no roadmap yet.
+        // If a CONTEXT-DRAFT.md seed exists, it needs discussion before planning.
+        // Otherwise, it's a blank milestone ready for initial planning.
+        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,
+            },
+        };
+    }
+    // Check if active milestone needs validation or completion (all slices done)
+    if (isMilestoneComplete(activeRoadmap)) {
+        const validationFile = resolveMilestoneFile(basePath, activeMilestone.id, "VALIDATION");
+        const validationContent = validationFile ? await cachedLoadFile(validationFile) : null;
+        const validationTerminal = validationContent ? isValidationTerminal(validationContent) : false;
+        const sliceProgress = {
+            done: activeRoadmap.slices.length,
+            total: activeRoadmap.slices.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,
+            },
+        };
+    }
+    const sliceProgress = {
+        done: activeRoadmap.slices.filter(s => s.done).length,
+        total: activeRoadmap.slices.length,
+    };
+    // Find the active slice (first incomplete with deps satisfied)
+    const doneSliceIds = new Set(activeRoadmap.slices.filter(s => s.done).map(s => s.id));
+    let activeSlice = null;
+    for (const s of activeRoadmap.slices) {
+        if (s.done)
+            continue;
+        if (s.depends.every(dep => doneSliceIds.has(dep))) {
+            activeSlice = { id: s.id, title: s.title };
+            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 if the slice has a plan
+    const planFile = resolveSliceFile(basePath, activeMilestone.id, activeSlice.id, "PLAN");
+    const slicePlanContent = planFile ? await cachedLoadFile(planFile) : null;
+    if (!slicePlanContent) {
+        return {
+            activeMilestone,
+            activeSlice,
+            activeTask: null,
+            phase: 'planning',
+            recentDecisions: [],
+            blockers: [],
+            nextAction: `Plan slice ${activeSlice.id} (${activeSlice.title}).`,
+            registry,
+            requirements,
+            progress: {
+                milestones: milestoneProgress,
+                slices: sliceProgress,
+            },
+        };
+    }
+    const slicePlan = parsePlan(slicePlanContent);
+    const taskProgress = {
+        done: slicePlan.tasks.filter(t => t.done).length,
+        total: slicePlan.tasks.length,
+    };
+    const activeTaskEntry = slicePlan.tasks.find(t => !t.done);
+    if (!activeTaskEntry && slicePlan.tasks.length > 0) {
+        // All tasks done but slice not marked complete
+        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, stay in planning phase
+    if (!activeTaskEntry) {
+        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: activeTaskEntry.id,
+        title: activeTaskEntry.title,
+    };
+    // ── Task plan file check (#909) ──────────────────────────────────────
+    // The slice plan may reference tasks but per-task plan files may be
+    // missing — e.g. when the slice plan was pre-created during roadmapping.
+    // If the tasks dir exists but has literally zero files (empty dir from
+    // mkdir), fall back to planning so plan-slice generates task plans.
+    const tasksDir = resolveTasksDir(basePath, activeMilestone.id, activeSlice.id);
+    if (tasksDir && existsSync(tasksDir) && slicePlan.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: scan completed task summaries ──────────────────
+    // If any completed task has blocker_discovered: true and no REPLAN.md
+    // exists yet, transition to replanning-slice instead of executing.
+    const completedTasks = slicePlan.tasks.filter(t => t.done);
+    let blockerTaskId = null;
+    for (const ct of completedTasks) {
+        const summaryFile = resolveTaskFile(basePath, activeMilestone.id, activeSlice.id, ct.id, "SUMMARY");
+        if (!summaryFile)
+            continue;
+        const summaryContent = await cachedLoadFile(summaryFile);
+        if (!summaryContent)
+            continue;
+        const summary = parseSummary(summaryContent);
+        if (summary.frontmatter.blocker_discovered) {
+            blockerTaskId = ct.id;
+            break;
+        }
+    }
+    if (blockerTaskId) {
+        // Loop protection: if REPLAN.md already exists, a replan was already
+        // performed for this slice — skip further replanning and continue executing.
+        const replanFile = resolveSliceFile(basePath, activeMilestone.id, activeSlice.id, "REPLAN");
+        if (!replanFile) {
+            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.md exists — loop protection: fall through to normal executing
+    }
+    // Check for interrupted work
+    const sDir = resolveSlicePath(basePath, activeMilestone.id, activeSlice.id);
+    const continueFile = sDir ? resolveSliceFile(basePath, activeMilestone.id, activeSlice.id, "CONTINUE") : null;
+    // Also check legacy continue.md
+    const hasInterrupted = !!(continueFile && await cachedLoadFile(continueFile)) ||
+        !!(sDir && await cachedLoadFile(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,
+        },
+    };
+}