gsd-pi 2.43.0 → 2.44.0-dev.0b97ffd

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -22,16 +22,121 @@ import { writeUnitRuntimeRecord, clearUnitRuntimeRecord } from "./unit-runtime.j
 import { runGSDDoctor, rebuildState, summarizeDoctorIssues } from "./doctor.js";
 import { recordHealthSnapshot, checkHealEscalation } from "./doctor-proactive.js";
 import { syncStateToProjectRoot } from "./auto-worktree-sync.js";
-import { isDbAvailable } from "./gsd-db.js";
+import { isDbAvailable, getTask, getSlice, getMilestone, updateTaskStatus, _getAdapter } from "./gsd-db.js";
+import { renderPlanCheckboxes } from "./markdown-renderer.js";
 import { consumeSignal } from "./session-status-io.js";
 import { checkPostUnitHooks, isRetryPending, consumeRetryTrigger, persistHookState, resolveHookArtifactPath, } from "./post-unit-hooks.js";
 import { hasPendingCaptures, loadPendingCaptures } from "./captures.js";
 import { debugLog } from "./debug-logger.js";
 import { existsSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import { uncheckTaskInPlan } from "./undo.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { _resetHasChangesCache } from "./native-git-bridge.js";
+/**
+ * Detect summary files written directly to disk without the LLM calling
+ * the completion tool. A "rogue" file is one that exists on disk but has
+ * no corresponding DB row with status "complete".
+ *
+ * This is a safety-net diagnostic (D003). The existing migrateFromMarkdown()
+ * in postUnitPostVerification() eventually ingests rogue files, but explicit
+ * detection provides immediate diagnostics so operators know the prompt failed.
+ */
+export function detectRogueFileWrites(unitType, unitId, basePath) {
+    if (!isDbAvailable())
+        return [];
+    const parts = unitId.split("/");
+    const rogues = [];
+    if (unitType === "execute-task") {
+        const [mid, sid, tid] = parts;
+        if (!mid || !sid || !tid)
+            return [];
+        const summaryPath = resolveTaskFile(basePath, mid, sid, tid, "SUMMARY");
+        if (!summaryPath || !existsSync(summaryPath))
+            return [];
+        const dbRow = getTask(mid, sid, tid);
+        if (!dbRow || dbRow.status !== "complete") {
+            rogues.push({ path: summaryPath, unitType, unitId });
+        }
+    }
+    else if (unitType === "complete-slice") {
+        const [mid, sid] = parts;
+        if (!mid || !sid)
+            return [];
+        const summaryPath = resolveSliceFile(basePath, mid, sid, "SUMMARY");
+        if (!summaryPath || !existsSync(summaryPath))
+            return [];
+        const dbRow = getSlice(mid, sid);
+        if (!dbRow || dbRow.status !== "complete") {
+            rogues.push({ path: summaryPath, unitType, unitId });
+        }
+    }
+    else if (unitType === "plan-milestone") {
+        const [mid] = parts;
+        if (!mid)
+            return [];
+        const roadmapPath = resolveMilestoneFile(basePath, mid, "ROADMAP");
+        if (!roadmapPath || !existsSync(roadmapPath))
+            return [];
+        const dbRow = getMilestone(mid);
+        const hasPlanningState = !!dbRow && (String(dbRow.title || "").trim().length > 0 ||
+            String(dbRow.vision || "").trim().length > 0 ||
+            String(dbRow.requirement_coverage || "").trim().length > 0 ||
+            String(dbRow.boundary_map_markdown || "").trim().length > 0);
+        if (!hasPlanningState) {
+            rogues.push({ path: roadmapPath, unitType, unitId });
+        }
+    }
+    else if (unitType === "plan-slice" || unitType === "replan-slice") {
+        const [mid, sid] = parts;
+        if (!mid || !sid)
+            return [];
+        const planPath = resolveSliceFile(basePath, mid, sid, "PLAN");
+        if (!planPath || !existsSync(planPath))
+            return [];
+        const dbRow = getSlice(mid, sid);
+        const hasPlanningState = !!dbRow && (String(dbRow.title || "").trim().length > 0 ||
+            String(dbRow.demo || "").trim().length > 0 ||
+            String(dbRow.risk || "").trim().length > 0 ||
+            String(dbRow.depends || "").trim().length > 0);
+        if (!hasPlanningState) {
+            rogues.push({ path: planPath, unitType, unitId });
+        }
+        // Also check for rogue REPLAN.md
+        const replanPath = resolveSliceFile(basePath, mid, sid, "REPLAN");
+        if (replanPath && existsSync(replanPath) && !hasPlanningState) {
+            rogues.push({ path: replanPath, unitType, unitId });
+        }
+    }
+    else if (unitType === "reassess-roadmap") {
+        const [mid, sid] = parts;
+        if (!mid || !sid)
+            return [];
+        const assessPath = resolveSliceFile(basePath, mid, sid, "ASSESSMENT");
+        if (!assessPath || !existsSync(assessPath))
+            return [];
+        // Assessment file exists on disk — check if DB knows about it via the artifacts table
+        const adapter = _getAdapter();
+        if (adapter) {
+            const row = adapter.prepare(`SELECT 1 FROM artifacts WHERE path LIKE :pattern AND artifact_type = 'ASSESSMENT' LIMIT 1`).get({ ":pattern": `%${sid}-ASSESSMENT.md` });
+            if (!row) {
+                rogues.push({ path: assessPath, unitType, unitId });
+            }
+        }
+    }
+    else if (unitType === "plan-task") {
+        const [mid, sid, tid] = parts;
+        if (!mid || !sid || !tid)
+            return [];
+        const taskPlanPath = resolveTaskFile(basePath, mid, sid, tid, "PLAN");
+        if (!taskPlanPath || !existsSync(taskPlanPath))
+            return [];
+        const dbRow = getTask(mid, sid, tid);
+        if (!dbRow) {
+            rogues.push({ path: taskPlanPath, unitType, unitId });
+        }
+    }
+    return rogues;
+}
 /** Throttle STATE.md rebuilds — at most once per 30 seconds */
 const STATE_REBUILD_MIN_INTERVAL_MS = 30_000;
 /**
@@ -283,6 +388,17 @@ export async function postUnitPreVerification(pctx, opts) {
                 process.stderr.write(`gsd-triage: resolution execution failed: ${err.message}\n`);
             }
         }
+        // Rogue file detection — safety net for LLM bypassing completion tools (D003)
+        try {
+            const rogueFiles = detectRogueFileWrites(s.currentUnit.type, s.currentUnit.id, s.basePath);
+            for (const rogue of rogueFiles) {
+                process.stderr.write(`gsd-rogue: detected rogue file write: ${rogue.path} (unit: ${rogue.unitId})\n`);
+                ctx.ui.notify(`Rogue file write detected: ${rogue.path}`, "warning");
+            }
+        }
+        catch (e) {
+            debugLog("postUnit", { phase: "rogue-detection", error: String(e) });
+        }
         // Artifact verification
         let triggerArtifactVerified = false;
         if (!s.currentUnit.type.startsWith("hook/")) {
@@ -346,16 +462,6 @@ export async function postUnitPreVerification(pctx, opts) {
  */
 export async function postUnitPostVerification(pctx) {
     const { s, ctx, pi, buildSnapshotOpts, lockBase, stopAuto, pauseAuto, updateProgressWidget } = pctx;
-    // ── DB dual-write ──
-    if (isDbAvailable()) {
-        try {
-            const { migrateFromMarkdown } = await import("./md-importer.js");
-            migrateFromMarkdown(s.basePath);
-        }
-        catch (err) {
-            process.stderr.write(`gsd-db: re-import failed: ${err.message}\n`);
-        }
-    }
     // ── Post-unit hooks ──
     if (s.currentUnit && !s.stepMode) {
         const hookUnit = checkPostUnitHooks(s.currentUnit.type, s.currentUnit.id, s.basePath);
@@ -389,9 +495,17 @@ export async function postUnitPostVerification(pctx) {
                 try {
                     const parts = trigger.unitId.split("/");
                     const [mid, sid, tid] = parts;
-                    // 1. Uncheck [x] → [ ] in PLAN.md
+                    // 1. Reset task status in DB and re-render plan checkboxes
                     if (mid && sid && tid) {
-                        uncheckTaskInPlan(s.basePath, mid, sid, tid);
+                        try {
+                            updateTaskStatus(mid, sid, tid, "pending");
+                            await renderPlanCheckboxes(s.basePath, mid, sid);
+                        }
+                        catch (dbErr) {
+                            // DB unavailable — fail explicitly rather than silently reverting to markdown mutation.
+                            // Use 'gsd recover' to rebuild DB state from disk if needed.
+                            process.stderr.write(`gsd: retry state-reset failed (DB unavailable): ${dbErr.message}. Run 'gsd recover' to reconcile.\n`);
+                        }
                     }
                     // 2. Delete SUMMARY.md for the task
                     if (mid && sid && tid) {

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

@@ -5,10 +5,11 @@
  * state, no globals — every dependency is passed as a parameter or imported as a
  * utility.
  */
-import { loadFile, parseContinue, parsePlan, parseRoadmap, parseSummary, extractUatType, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
+import { loadFile, parseContinue, parseSummary, extractUatType, loadActiveOverrides, formatOverridesSection, parseTaskPlanFile } from "./files.js";
 import { loadPrompt, inlineTemplate } from "./prompt-loader.js";
 import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, resolveTaskFiles, resolveTaskFile, relMilestoneFile, relSliceFile, relSlicePath, relMilestonePath, resolveGsdRootFile, relGsdRootFile, resolveRuntimeFile, } from "./paths.js";
 import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences, resolveAllSkillReferences } from "./preferences.js";
+import { parseRoadmap } from "./parsers-legacy.js";
 import { getLoadedSkills } from "@gsd/pi-coding-agent";
 import { join, basename } from "node:path";
 import { existsSync } from "node:fs";
@@ -139,17 +140,41 @@ export async function inlineFileSmart(absPath, relPath, label, query, threshold
  * Load and inline dependency slice summaries (full content, not just paths).
  */
 export async function inlineDependencySummaries(mid, sid, base, budgetChars) {
-    const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-    const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-    if (!roadmapContent)
-        return "- (no dependencies)";
-    const roadmap = parseRoadmap(roadmapContent);
-    const sliceEntry = roadmap.slices.find(s => s.id === sid);
-    if (!sliceEntry || sliceEntry.depends.length === 0)
-        return "- (no dependencies)";
+    // DB primary path — get slice depends directly
+    let depends = null;
+    try {
+        const { isDbAvailable, getSlice } = await import("./gsd-db.js");
+        if (isDbAvailable()) {
+            const slice = getSlice(mid, sid);
+            if (slice) {
+                if (slice.depends.length === 0)
+                    return "- (no dependencies)";
+                depends = slice.depends;
+            }
+            // If slice not found in DB, fall through to file-based parsing
+        }
+    }
+    catch { /* fall through */ }
+    // If DB didn't provide depends, fall back to roadmap parsing
+    if (!depends) {
+        const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+        if (roadmapPath) {
+            const roadmapContent = await loadFile(roadmapPath);
+            if (roadmapContent) {
+                const parsed = parseRoadmap(roadmapContent);
+                const slice = parsed.slices.find(s => s.id === sid);
+                if (slice && slice.depends.length > 0) {
+                    depends = slice.depends;
+                }
+            }
+        }
+        if (!depends) {
+            return "- (no dependencies)";
+        }
+    }
     const sections = [];
     const seen = new Set();
-    for (const dep of sliceEntry.depends) {
+    for (const dep of depends) {
         if (seen.has(dep))
             continue;
         seen.add(dep);
@@ -557,28 +582,52 @@ export async function getDependencyTaskSummaryPaths(mid, sid, currentTid, depend
  * - All slices are complete (milestone done — no point reassessing)
  */
 export async function checkNeedsReassessment(base, mid, state) {
-    const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-    const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
+    // DB primary path — fall through to file-based when DB has no data for this milestone
+    try {
+        const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
+        if (isDbAvailable()) {
+            const slices = getMilestoneSlices(mid);
+            if (slices.length > 0) {
+                const completedSliceIds = slices.filter(s => s.status === "complete").map(s => s.id);
+                const hasIncomplete = slices.some(s => s.status !== "complete");
+                if (completedSliceIds.length === 0 || !hasIncomplete)
+                    return null;
+                const lastCompleted = completedSliceIds[completedSliceIds.length - 1];
+                const assessmentFile = resolveSliceFile(base, mid, lastCompleted, "ASSESSMENT");
+                const hasAssessment = !!(assessmentFile && await loadFile(assessmentFile));
+                if (hasAssessment)
+                    return null;
+                const summaryFile = resolveSliceFile(base, mid, lastCompleted, "SUMMARY");
+                const hasSummary = !!(summaryFile && await loadFile(summaryFile));
+                if (!hasSummary)
+                    return null;
+                return { sliceId: lastCompleted };
+            }
+        }
+    }
+    catch { /* fall through */ }
+    // File-based fallback using roadmap checkboxes
+    const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+    if (!roadmapPath)
+        return null;
+    const roadmapContent = await loadFile(roadmapPath);
     if (!roadmapContent)
         return null;
-    const roadmap = parseRoadmap(roadmapContent);
-    const completedSlices = roadmap.slices.filter(s => s.done);
-    const incompleteSlices = roadmap.slices.filter(s => !s.done);
-    // No completed slices or all slices done — skip
-    if (completedSlices.length === 0 || incompleteSlices.length === 0)
+    const parsed = parseRoadmap(roadmapContent);
+    const fileCompletedIds = parsed.slices.filter(s => s.done).map(s => s.id);
+    const fileHasIncomplete = parsed.slices.some(s => !s.done);
+    if (fileCompletedIds.length === 0 || !fileHasIncomplete)
         return null;
-    // Check the last completed slice
-    const lastCompleted = completedSlices[completedSlices.length - 1];
-    const assessmentFile = resolveSliceFile(base, mid, lastCompleted.id, "ASSESSMENT");
-    const hasAssessment = !!(assessmentFile && await loadFile(assessmentFile));
-    if (hasAssessment)
+    const lastDone = fileCompletedIds[fileCompletedIds.length - 1];
+    const assessFile = resolveSliceFile(base, mid, lastDone, "ASSESSMENT");
+    const hasAssess = !!(assessFile && await loadFile(assessFile));
+    if (hasAssess)
         return null;
-    // Also need a summary to reassess against
-    const summaryFile = resolveSliceFile(base, mid, lastCompleted.id, "SUMMARY");
-    const hasSummary = !!(summaryFile && await loadFile(summaryFile));
-    if (!hasSummary)
+    const summFile = resolveSliceFile(base, mid, lastDone, "SUMMARY");
+    const hasSumm = !!(summFile && await loadFile(summFile));
+    if (!hasSumm)
         return null;
-    return { sliceId: lastCompleted.id };
+    return { sliceId: lastDone };
 }
 /**
  * Check if the most recently completed slice needs a UAT run.
@@ -592,42 +641,70 @@ export async function checkNeedsReassessment(base, mid, state) {
  * - UAT result file already exists (idempotent — already ran)
  */
 export async function checkNeedsRunUat(base, mid, state, prefs) {
-    const roadmapFile = resolveMilestoneFile(base, mid, "ROADMAP");
-    const roadmapContent = roadmapFile ? await loadFile(roadmapFile) : null;
-    if (!roadmapContent)
+    // DB primary path — fall through to file-based when DB has no data for this milestone
+    try {
+        const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
+        if (isDbAvailable()) {
+            const slices = getMilestoneSlices(mid);
+            if (slices.length > 0) {
+                const completedSlices = slices.filter(s => s.status === "complete");
+                const incompleteSlices = slices.filter(s => s.status !== "complete");
+                if (completedSlices.length === 0)
+                    return null;
+                if (incompleteSlices.length === 0)
+                    return null;
+                if (!prefs?.uat_dispatch)
+                    return null;
+                const lastCompleted = completedSlices[completedSlices.length - 1];
+                const sid = lastCompleted.id;
+                const uatFile = resolveSliceFile(base, mid, sid, "UAT");
+                if (!uatFile)
+                    return null;
+                const uatContent = await loadFile(uatFile);
+                if (!uatContent)
+                    return null;
+                const uatResultFile = resolveSliceFile(base, mid, sid, "UAT-RESULT");
+                if (uatResultFile) {
+                    const hasResult = !!(await loadFile(uatResultFile));
+                    if (hasResult)
+                        return null;
+                }
+                const uatType = extractUatType(uatContent) ?? "artifact-driven";
+                return { sliceId: sid, uatType };
+            }
+        }
+    }
+    catch { /* fall through */ }
+    // File-based fallback using roadmap checkboxes
+    if (!prefs?.uat_dispatch)
         return null;
-    const roadmap = parseRoadmap(roadmapContent);
-    const completedSlices = roadmap.slices.filter(s => s.done);
-    const incompleteSlices = roadmap.slices.filter(s => !s.done);
-    // No completed slices — nothing to UAT yet
-    if (completedSlices.length === 0)
+    const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
+    if (!roadmapPath)
         return null;
-    // All slices done — milestone complete path, skip (reassessment handles)
-    if (incompleteSlices.length === 0)
+    const roadmapContent = await loadFile(roadmapPath);
+    if (!roadmapContent)
         return null;
-    // uat_dispatch must be opted in
-    if (!prefs?.uat_dispatch)
+    const parsed = parseRoadmap(roadmapContent);
+    const completedFileSlices = parsed.slices.filter(s => s.done);
+    const incompleteFileSlices = parsed.slices.filter(s => !s.done);
+    if (completedFileSlices.length === 0 || incompleteFileSlices.length === 0)
         return null;
-    // Take the last completed slice
-    const lastCompleted = completedSlices[completedSlices.length - 1];
-    const sid = lastCompleted.id;
-    // UAT file must exist
-    const uatFile = resolveSliceFile(base, mid, sid, "UAT");
-    if (!uatFile)
+    const lastCompletedFile = completedFileSlices[completedFileSlices.length - 1];
+    const uatSid = lastCompletedFile.id;
+    const uatFileFb = resolveSliceFile(base, mid, uatSid, "UAT");
+    if (!uatFileFb)
         return null;
-    const uatContent = await loadFile(uatFile);
-    if (!uatContent)
+    const uatContentFb = await loadFile(uatFileFb);
+    if (!uatContentFb)
         return null;
-    // If UAT result already exists, skip (idempotent)
-    const uatResultFile = resolveSliceFile(base, mid, sid, "UAT-RESULT");
-    if (uatResultFile) {
-        const hasResult = !!(await loadFile(uatResultFile));
-        if (hasResult)
+    const uatResultFb = resolveSliceFile(base, mid, uatSid, "UAT-RESULT");
+    if (uatResultFb) {
+        const hasResultFb = !!(await loadFile(uatResultFb));
+        if (hasResultFb)
             return null;
     }
-    // Classify UAT type; default to artifact-driven (LLM-executed UATs are always artifact-driven)
-    const uatType = extractUatType(uatContent) ?? "artifact-driven";
-    return { sliceId: sid, uatType };
+    const uatTypeFb = extractUatType(uatContentFb) ?? "artifact-driven";
+    return { sliceId: uatSid, uatType: uatTypeFb };
 }
 // ─── Prompt Builders ──────────────────────────────────────────────────────
 /**
@@ -1024,19 +1101,30 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
     const inlined = [];
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
     // Inline all slice summaries (deduplicated by slice ID)
-    const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
-    if (roadmapContent) {
-        const roadmap = parseRoadmap(roadmapContent);
-        const seenSlices = new Set();
-        for (const slice of roadmap.slices) {
-            if (seenSlices.has(slice.id))
-                continue;
-            seenSlices.add(slice.id);
-            const summaryPath = resolveSliceFile(base, mid, slice.id, "SUMMARY");
-            const summaryRel = relSliceFile(base, mid, slice.id, "SUMMARY");
-            inlined.push(await inlineFile(summaryPath, summaryRel, `${slice.id} Summary`));
+    let sliceIds = [];
+    try {
+        const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
+        if (isDbAvailable()) {
+            sliceIds = getMilestoneSlices(mid).map(s => s.id);
         }
     }
+    catch { /* fall through */ }
+    // File-based fallback: parse roadmap for slice IDs when DB has no data
+    if (sliceIds.length === 0 && roadmapPath) {
+        const roadmapContent = await loadFile(roadmapPath);
+        if (roadmapContent) {
+            sliceIds = parseRoadmap(roadmapContent).slices.map(s => s.id);
+        }
+    }
+    const seenSlices = new Set();
+    for (const sid of sliceIds) {
+        if (seenSlices.has(sid))
+            continue;
+        seenSlices.add(sid);
+        const summaryPath = resolveSliceFile(base, mid, sid, "SUMMARY");
+        const summaryRel = relSliceFile(base, mid, sid, "SUMMARY");
+        inlined.push(await inlineFile(summaryPath, summaryRel, `${sid} Summary`));
+    }
     // Inline root GSD files (skip for minimal — completion can read these if needed)
     if (inlineLevel !== "minimal") {
         const requirementsInline = await inlineRequirementsFromDb(base, undefined, inlineLevel);
@@ -1077,24 +1165,35 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
     const inlined = [];
     inlined.push(await inlineFile(roadmapPath, roadmapRel, "Milestone Roadmap"));
     // Inline all slice summaries and UAT results
-    const roadmapContent = roadmapPath ? await loadFile(roadmapPath) : null;
-    if (roadmapContent) {
-        const roadmap = parseRoadmap(roadmapContent);
-        const seenSlices = new Set();
-        for (const slice of roadmap.slices) {
-            if (seenSlices.has(slice.id))
-                continue;
-            seenSlices.add(slice.id);
-            const summaryPath = resolveSliceFile(base, mid, slice.id, "SUMMARY");
-            const summaryRel = relSliceFile(base, mid, slice.id, "SUMMARY");
-            inlined.push(await inlineFile(summaryPath, summaryRel, `${slice.id} Summary`));
-            const uatPath = resolveSliceFile(base, mid, slice.id, "UAT-RESULT");
-            const uatRel = relSliceFile(base, mid, slice.id, "UAT-RESULT");
-            const uatInline = await inlineFileOptional(uatPath, uatRel, `${slice.id} UAT Result`);
-            if (uatInline)
-                inlined.push(uatInline);
+    let valSliceIds = [];
+    try {
+        const { isDbAvailable, getMilestoneSlices } = await import("./gsd-db.js");
+        if (isDbAvailable()) {
+            valSliceIds = getMilestoneSlices(mid).map(s => s.id);
+        }
+    }
+    catch { /* fall through */ }
+    // File-based fallback: parse roadmap for slice IDs when DB has no data
+    if (valSliceIds.length === 0 && roadmapPath) {
+        const roadmapContent = await loadFile(roadmapPath);
+        if (roadmapContent) {
+            valSliceIds = parseRoadmap(roadmapContent).slices.map(s => s.id);
         }
     }
+    const seenValSlices = new Set();
+    for (const sid of valSliceIds) {
+        if (seenValSlices.has(sid))
+            continue;
+        seenValSlices.add(sid);
+        const summaryPath = resolveSliceFile(base, mid, sid, "SUMMARY");
+        const summaryRel = relSliceFile(base, mid, sid, "SUMMARY");
+        inlined.push(await inlineFile(summaryPath, summaryRel, `${sid} Summary`));
+        const uatPath = resolveSliceFile(base, mid, sid, "UAT-RESULT");
+        const uatRel = relSliceFile(base, mid, sid, "UAT-RESULT");
+        const uatInline = await inlineFileOptional(uatPath, uatRel, `${sid} UAT Result`);
+        if (uatInline)
+            inlined.push(uatInline);
+    }
     // Inline existing VALIDATION file if this is a re-validation round
     const validationPath = resolveMilestoneFile(base, mid, "VALIDATION");
     const validationRel = relMilestoneFile(base, mid, "VALIDATION");
@@ -1354,16 +1453,27 @@ export async function buildRewriteDocsPrompt(mid, midTitle, activeSlice, base, o
             docList.push(`- Slice plan: \`${slicePlanRel}\``);
             const tDir = resolveTasksDir(base, mid, sid);
             if (tDir) {
-                const planContent = await loadFile(slicePlanPath);
-                if (planContent) {
-                    const plan = parsePlan(planContent);
-                    for (const task of plan.tasks) {
-                        if (!task.done) {
-                            const taskPlanPath = resolveTaskFile(base, mid, sid, task.id, "PLAN");
-                            if (taskPlanPath) {
-                                const taskRelPath = `${relSlicePath(base, mid, sid)}/tasks/${task.id}-PLAN.md`;
-                                docList.push(`- Task plan: \`${taskRelPath}\``);
-                            }
+                // DB primary path — get incomplete tasks
+                let incompleteTasks = null;
+                try {
+                    const { isDbAvailable, getSliceTasks } = await import("./gsd-db.js");
+                    if (isDbAvailable()) {
+                        incompleteTasks = getSliceTasks(mid, sid)
+                            .filter(t => t.status !== "complete" && t.status !== "done")
+                            .map(t => ({ id: t.id }));
+                    }
+                }
+                catch { /* fall through */ }
+                if (!incompleteTasks) {
+                    // DB unavailable — no task data to inline
+                    incompleteTasks = [];
+                }
+                if (incompleteTasks) {
+                    for (const task of incompleteTasks) {
+                        const taskPlanPath = resolveTaskFile(base, mid, sid, task.id, "PLAN");
+                        if (taskPlanPath) {
+                            const taskRelPath = `${relSlicePath(base, mid, sid)}/tasks/${task.id}-PLAN.md`;
+                            docList.push(`- Task plan: \`${taskRelPath}\``);
                         }
                     }
                 }