gsd-pi 2.78.1-dev.b0759e59b → 2.78.1-dev.e9d88a536

package/dist/resources/extensions/gsd/commands-scan.js

@@ -16,7 +16,7 @@
 import { existsSync, mkdirSync } from "node:fs";
 import { join, relative } from "node:path";
 import { loadPrompt } from "./prompt-loader.js";
-import { projectRoot } from "./commands/context.js";
+import { currentDirectoryRoot } from "./commands/context.js";
 // ─── Constants ────────────────────────────────────────────────────────────────
 export const DEFAULT_FOCUS = "tech+arch";
 export const VALID_FOCUS_AREAS = ["tech", "arch", "quality", "concerns", "tech+arch"];
@@ -67,7 +67,7 @@ export function checkExistingDocuments(paths) {
 }
 // ─── Command handler ──────────────────────────────────────────────────────────
 export async function handleScan(args, ctx, pi) {
-    const basePath = projectRoot();
+    const basePath = currentDirectoryRoot();
     const { focus } = parseScanArgs(args);
     const outputDir = join(basePath, ".gsd", "codebase");
     const outputPaths = buildScanOutputPaths(focus, basePath);

package/dist/resources/extensions/gsd/commands-ship.js

@@ -13,7 +13,7 @@ import { getLedger, getProjectTotals, aggregateByModel, formatCost, formatTokenC
 import { nativeGetCurrentBranch, nativeDetectMainBranch } from "./native-git-bridge.js";
 import { formatDuration } from "../shared/format-utils.js";
 import { parseEvalReviewFrontmatter } from "./eval-review-schema.js";
-import { projectRoot } from "./commands/context.js";
+import { currentDirectoryRoot } from "./commands/context.js";
 function git(basePath, args) {
     return execFileSync("git", args, { cwd: basePath, encoding: "utf-8" }).trim();
 }
@@ -176,7 +176,7 @@ function generatePRContent(basePath, milestoneId, milestoneTitle) {
     return { title, body: sections.join("\n") };
 }
 export async function handleShip(args, ctx, _pi) {
-    const basePath = projectRoot();
+    const basePath = currentDirectoryRoot();
     const dryRun = args.includes("--dry-run");
     const draft = args.includes("--draft");
     const force = args.includes("--force");

package/dist/resources/extensions/gsd/commands-workflow-templates.js

@@ -13,7 +13,7 @@ import { createGitService, runGit } from "./git-service.js";
 import { isAutoActive, isAutoPaused } from "./auto.js";
 import { getErrorMessage } from "./error-utils.js";
 import { resolvePlugin } from "./workflow-plugins.js";
-import { projectRoot } from "./commands/context.js";
+import { currentDirectoryRoot } from "./commands/context.js";
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 /**
  * Generate a URL-friendly slug from text.
@@ -143,7 +143,7 @@ export async function handleStart(args, ctx, pi) {
     // ─── Resume detection ───────────────────────────────────────────────────
     // /gsd start --resume or /gsd start resume → resume in-progress workflow
     if (trimmed === "--resume" || trimmed === "resume") {
-        const basePath = projectRoot();
+        const basePath = currentDirectoryRoot();
         const inProgress = findInProgressWorkflows(basePath);
         if (inProgress.length === 0) {
             ctx.ui.notify("No in-progress workflows found.", "info");
@@ -182,7 +182,7 @@ export async function handleStart(args, ctx, pi) {
     }
     // Show in-progress workflows when /gsd start is called with no args
     if (!trimmed) {
-        const basePath = projectRoot();
+        const basePath = currentDirectoryRoot();
         const inProgress = findInProgressWorkflows(basePath);
         if (inProgress.length > 0) {
             const wf = inProgress[0];
@@ -257,7 +257,7 @@ export async function handleStart(args, ctx, pi) {
     // ─── Resolved template ───────────────────────────────────────────────────
     const templateId = match.id;
     const template = match.template;
-    const basePath = projectRoot();
+    const basePath = currentDirectoryRoot();
     const date = new Date().toISOString().split("T")[0];
     // Load the workflow template content — prefer a project/global plugin
     // override if one exists (same name, .md format).
@@ -437,7 +437,7 @@ export function dispatchMarkdownPhasePlugin(plugin, description, ctx, pi) {
         return;
     }
     const templateId = plugin.name;
-    const basePath = projectRoot();
+    const basePath = currentDirectoryRoot();
     const date = new Date().toISOString().split("T")[0];
     let workflowContent;
     try {

package/dist/resources/extensions/gsd/db-writer.js

@@ -273,22 +273,6 @@ export async function saveRequirementToDb(fields, basePath) {
            ORDER BY id
            LIMIT 1`)
                 .get({ ':description': fields.description });
-            const previousRow = existingRow
-                ? {
-                    id: existingRow['id'],
-                    class: existingRow['class'],
-                    status: existingRow['status'],
-                    description: existingRow['description'],
-                    why: existingRow['why'],
-                    source: existingRow['source'],
-                    primary_owner: existingRow['primary_owner'],
-                    supporting_slices: existingRow['supporting_slices'],
-                    validation: existingRow['validation'],
-                    notes: existingRow['notes'],
-                    full_content: existingRow['full_content'],
-                    superseded_by: existingRow['superseded_by'] ?? null,
-                }
-                : null;
             const row = adapter
                 .prepare('SELECT MAX(CAST(SUBSTR(id, 2) AS INTEGER)) as max_num FROM requirements')
                 .get();
@@ -313,9 +297,9 @@ export async function saveRequirementToDb(fields, basePath) {
                 superseded_by: existingRow?.['superseded_by'] ?? null,
             };
             db.upsertRequirement(requirement);
-            return { id: nextId, isNew: !existingRow, previousRow };
+            return { id: nextId };
         });
-        const { id, isNew, previousRow } = txResult;
+        const { id } = txResult;
         // Fetch all requirements for full file regeneration
         const adapter = db._getAdapter();
         let allRequirements = [];
@@ -343,19 +327,7 @@ export async function saveRequirementToDb(fields, basePath) {
             await saveFile(filePath, md);
         }
         catch (diskErr) {
-            logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveRequirementToDb', error: String(diskErr.message) });
-            try {
-                if (isNew) {
-                    db.deleteRequirementById(id);
-                }
-                else if (previousRow) {
-                    db.upsertRequirement(previousRow);
-                }
-            }
-            catch (rollbackErr) {
-                logError('manifest', 'SPLIT BRAIN: disk write failed AND DB rollback failed — DB has orphaned row', { fn: 'saveRequirementToDb', id, error: String(rollbackErr.message) });
-            }
-            throw diskErr;
+            logWarning('projection', 'REQUIREMENTS.md projection write failed; DB requirement remains committed', { fn: 'saveRequirementToDb', id, error: String(diskErr.message) });
         }
         invalidateStateCache();
         clearPathCache();
@@ -463,14 +435,7 @@ export async function saveDecisionToDb(fields, basePath) {
             await saveFile(filePath, md);
         }
         catch (diskErr) {
-            logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveDecisionToDb', error: String(diskErr.message) });
-            try {
-                db.deleteDecisionById(id);
-            }
-            catch (rollbackErr) {
-                logError('manifest', 'SPLIT BRAIN: disk write failed AND DB rollback failed — DB has orphaned row', { fn: 'saveDecisionToDb', id, error: String(rollbackErr.message) });
-            }
-            throw diskErr;
+            logWarning('projection', 'DECISIONS.md projection write failed; DB decision remains committed', { fn: 'saveDecisionToDb', id, error: String(diskErr.message) });
         }
         // #2661: When a decision defers a slice, update the slice status in the DB
         // so the dispatcher skips it. Without this, STATE.md and DECISIONS.md are
@@ -584,34 +549,7 @@ export function extractDeferredSliceRef(fields) {
 export async function updateRequirementInDb(id, updates, basePath) {
     try {
         const db = await import('./gsd-db.js');
-        let existing = db.getRequirementById(id);
-        // If requirement doesn't exist in DB, seed the entire requirements table
-        // from REQUIREMENTS.md first (#3346). This handles the standard workflow
-        // where requirements are authored in markdown during discussion but never
-        // imported into the database — making gsd_requirement_update always fail
-        // with "not_found" at milestone completion.
-        if (!existing) {
-            const reqFilePath = resolveGsdRootFile(basePath, 'REQUIREMENTS');
-            try {
-                const content = readFileSync(reqFilePath, 'utf-8');
-                const { parseRequirementsSections } = await import('./md-importer.js');
-                const parsed = parseRequirementsSections(content);
-                if (parsed.length > 0) {
-                    logWarning('manifest', `Seeding ${parsed.length} requirements from REQUIREMENTS.md into DB (first update triggers import)`, { fn: 'updateRequirementInDb' });
-                    for (const req of parsed) {
-                        // Only seed if not already in DB (avoid overwriting concurrent inserts)
-                        if (!db.getRequirementById(req.id)) {
-                            db.upsertRequirement(req);
-                        }
-                    }
-                    // Re-check after seeding
-                    existing = db.getRequirementById(id);
-                }
-            }
-            catch {
-                // REQUIREMENTS.md missing or unparseable — fall through to skeleton
-            }
-        }
+        const existing = db.getRequirementById(id);
         const base = existing ?? {
             id,
             class: '',
@@ -662,11 +600,7 @@ export async function updateRequirementInDb(id, updates, basePath) {
             await saveFile(filePath, md);
         }
         catch (diskErr) {
-            logError('manifest', 'disk write failed, reverting DB row', { fn: 'updateRequirementInDb', error: String(diskErr.message) });
-            if (existing) {
-                db.upsertRequirement(existing);
-            }
-            throw diskErr;
+            logWarning('projection', 'REQUIREMENTS.md projection write failed; DB requirement update remains committed', { fn: 'updateRequirementInDb', id, error: String(diskErr.message) });
         }
         // Invalidate file-read caches so deriveState() sees the updated markdown.
         // Do NOT clear the artifacts table — we just wrote to it intentionally.
@@ -701,20 +635,19 @@ export async function saveArtifactToDb(opts, basePath) {
             }
             contentToPersist = generateRequirementsMd(activeRequirements);
         }
-        // Shrinkage guard: if the file already exists and the new content is
-        // significantly smaller (<50%), preserve the richer file on disk and
-        // store its content in the DB instead of the abbreviated version. Root
-        // canonical artifacts are exempt because their content is rendered from
-        // canonical DB state, and cleanup/consolidation is often intentionally much
-        // smaller than a malformed accumulated file.
-        let dbContent = contentToPersist;
+        // Shrinkage guard: if the projection file already exists and the new
+        // content is significantly smaller (<50%), preserve the richer file on
+        // disk, but keep the DB row authoritative with the caller-provided content.
+        // The disk file is a stale projection until the next explicit render.
+        // Root canonical artifacts are exempt because their content is rendered
+        // from canonical DB state, and cleanup/consolidation is often intentionally
+        // much smaller than a malformed accumulated file.
         let skipDiskWrite = false;
         if (!isRootCanonicalArtifact(opts) && existsSync(fullPath)) {
             const existingSize = statSync(fullPath).size;
             const newSize = Buffer.byteLength(contentToPersist, 'utf-8');
             if (existingSize > 0 && newSize < existingSize * 0.5) {
-                logWarning('manifest', `new content (${newSize}B) is <50% of existing file (${existingSize}B), preserving disk file`, { fn: 'saveArtifactToDb', path: opts.path });
-                dbContent = readFileSync(fullPath, 'utf-8');
+                logWarning('projection', `new content (${newSize}B) is <50% of existing projection (${existingSize}B), preserving disk file while DB remains authoritative`, { fn: 'saveArtifactToDb', path: opts.path });
                 skipDiskWrite = true;
             }
         }
@@ -724,7 +657,7 @@ export async function saveArtifactToDb(opts, basePath) {
             milestone_id: opts.milestone_id ?? null,
             slice_id: opts.slice_id ?? null,
             task_id: opts.task_id ?? null,
-            full_content: dbContent,
+            full_content: contentToPersist,
         });
         // Write the file to disk (only if we're not preserving a richer existing file)
         if (!skipDiskWrite) {
@@ -732,9 +665,7 @@ export async function saveArtifactToDb(opts, basePath) {
                 await saveFile(fullPath, contentToPersist);
             }
             catch (diskErr) {
-                logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveArtifactToDb', error: String(diskErr.message) });
-                db.deleteArtifactByPath(opts.path);
-                throw diskErr;
+                logWarning('projection', 'artifact projection write failed; DB artifact remains committed', { fn: 'saveArtifactToDb', path: opts.path, error: String(diskErr.message) });
             }
         }
         // Invalidate file-read caches so deriveState() sees the updated markdown.

package/dist/resources/extensions/gsd/dispatch-guard.js

@@ -45,25 +45,21 @@ export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unit
         // completion, which is wrong when the SUMMARY is a failure-path report
         // (verification FAILED, blocker placeholder, etc.). Resolve as follows:
         //   1. When DB is available and status is closed → skip (authoritative).
-        //   2. When SUMMARY exists but looks like a failure/blocker report →
-        //      do not short-circuit; fall through to the slice-level check so
-        //      the guard can still block dependents of an active milestone.
-        //   3. Otherwise (SUMMARY without failure markers) → skip. Preserves
-        //      the #1716 contract where a completed milestone with unchecked
-        //      remediation slices is still treated as done.
-        const summaryPath = resolveMilestoneFile(base, mid, "SUMMARY");
+        //   2. When DB is unavailable, legacy SUMMARY.md fallback may skip.
+        //      DB-backed projects must not treat SUMMARY.md as authoritative.
         if (isDbAvailable()) {
             const milestoneRow = getMilestone(mid);
             if (milestoneRow && isClosedStatus(milestoneRow.status))
                 continue;
         }
-        if (summaryPath) {
+        else {
+            const summaryPath = resolveMilestoneFile(base, mid, "SUMMARY");
             let summaryContent = null;
             try {
-                summaryContent = readFileSync(summaryPath, "utf-8");
+                summaryContent = summaryPath ? readFileSync(summaryPath, "utf-8") : null;
             }
             catch { /* ignore */ }
-            if (!summaryContent || classifyMilestoneSummaryContent(summaryContent) !== "failure") {
+            if (summaryContent && classifyMilestoneSummaryContent(summaryContent) !== "failure") {
                 continue;
             }
         }

package/dist/resources/extensions/gsd/doctor-engine-checks.js

@@ -1,12 +1,12 @@
 import { existsSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { isDbAvailable, _getAdapter } from "./gsd-db.js";
-import { resolveMilestoneFile } from "./paths.js";
+import { resolveGsdPathContract, resolveMilestoneFile } from "./paths.js";
 import { deriveState } from "./state.js";
 import { readEvents } from "./workflow-events.js";
 import { renderAllProjections } from "./workflow-projections.js";
 export async function checkEngineHealth(basePath, issues, fixesApplied) {
-    const dbPath = join(basePath, ".gsd", "gsd.db");
+    const dbPath = resolveGsdPathContract(basePath).projectDb;
     if (!isDbAvailable() && existsSync(dbPath)) {
         issues.push({
             severity: "warning",

package/dist/resources/extensions/gsd/gsd-db.js

@@ -136,7 +136,7 @@ function openRawDb(path) {
     const Database = providerModule;
     return new Database(path);
 }
-export const SCHEMA_VERSION = 22;
+export const SCHEMA_VERSION = 23;
 function indexExists(db, name) {
     return !!db.prepare("SELECT 1 as present FROM sqlite_master WHERE type = 'index' AND name = ?").get(name);
 }
@@ -299,7 +299,8 @@ function initSchema(db, fileBacked) {
         verification_uat TEXT NOT NULL DEFAULT '',
         definition_of_done TEXT NOT NULL DEFAULT '[]',
         requirement_coverage TEXT NOT NULL DEFAULT '',
-        boundary_map_markdown TEXT NOT NULL DEFAULT ''
+        boundary_map_markdown TEXT NOT NULL DEFAULT '',
+        sequence INTEGER DEFAULT 0
       )
     `);
         db.exec(`
@@ -1131,6 +1132,16 @@ function migrateSchema(db) {
                 ":applied_at": new Date().toISOString(),
             });
         }
+        if (currentVersion < 23) {
+            // v23: milestone queue ordering moves into the canonical DB. The
+            // historical QUEUE-ORDER.json file remains a projection, but runtime
+            // derivation must not read it as authoritative state.
+            ensureColumn(db, "milestones", "sequence", "ALTER TABLE milestones ADD COLUMN sequence INTEGER DEFAULT 0");
+            db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (:version, :applied_at)").run({
+                ":version": 23,
+                ":applied_at": new Date().toISOString(),
+            });
+        }
         db.exec("COMMIT");
     }
     catch (err) {
@@ -1518,6 +1529,31 @@ export function getActiveRequirements() {
         superseded_by: null,
     }));
 }
+export function getRequirementCounts() {
+    if (!currentDb) {
+        return { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 };
+    }
+    const rows = currentDb
+        .prepare("SELECT lower(status) as status, COUNT(*) as count FROM requirements GROUP BY lower(status)")
+        .all();
+    const counts = { active: 0, validated: 0, deferred: 0, outOfScope: 0, blocked: 0, total: 0 };
+    for (const row of rows) {
+        const status = String(row["status"] ?? "");
+        const count = Number(row["count"] ?? 0);
+        counts.total += count;
+        if (status === "active")
+            counts.active += count;
+        else if (status === "validated")
+            counts.validated += count;
+        else if (status === "deferred")
+            counts.deferred += count;
+        else if (status === "out-of-scope" || status === "out_of_scope")
+            counts.outOfScope += count;
+        else if (status === "blocked")
+            counts.blocked += count;
+    }
+    return counts;
+}
 export function getDbOwnerPid() {
     return currentPid;
 }
@@ -2164,6 +2200,7 @@ function rowToMilestone(row) {
         definition_of_done: JSON.parse(row["definition_of_done"] || "[]"),
         requirement_coverage: row["requirement_coverage"] ?? "",
         boundary_map_markdown: row["boundary_map_markdown"] ?? "",
+        sequence: Number(row["sequence"] ?? 0),
     };
 }
 function rowToArtifact(row) {
@@ -2180,7 +2217,7 @@ function rowToArtifact(row) {
 export function getAllMilestones() {
     if (!currentDb)
         return [];
-    const rows = currentDb.prepare("SELECT * FROM milestones ORDER BY id").all();
+    const rows = currentDb.prepare("SELECT * FROM milestones ORDER BY CASE WHEN sequence > 0 THEN 0 ELSE 1 END, sequence, id").all();
     return rows.map(rowToMilestone);
 }
 export function getMilestone(id) {
@@ -2191,6 +2228,23 @@ export function getMilestone(id) {
         return null;
     return rowToMilestone(row);
 }
+export function setMilestoneQueueOrder(order) {
+    if (!currentDb)
+        throw new GSDError(GSD_STALE_STATE, "gsd-db: No database open");
+    currentDb.exec("BEGIN IMMEDIATE");
+    try {
+        currentDb.prepare("UPDATE milestones SET sequence = 0").run();
+        const stmt = currentDb.prepare("UPDATE milestones SET sequence = :sequence WHERE id = :id");
+        order.forEach((id, index) => {
+            stmt.run({ ":id": id, ":sequence": index + 1 });
+        });
+        currentDb.exec("COMMIT");
+    }
+    catch (err) {
+        currentDb.exec("ROLLBACK");
+        throw err;
+    }
+}
 /**
  * Update a milestone's status in the database.
  * Used by park/unpark to keep the DB in sync with the filesystem marker.
@@ -2358,6 +2412,8 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             // fall through to the main DB's existing value (not a literal default)
             // so reconcile never silently clears state the main tree has recorded.
             const hasDecisionSource = wtInfo.some((col) => col["name"] === "source");
+            const wtMilestoneInfo = adapter.prepare("PRAGMA wt.table_info('milestones')").all();
+            const hasMilestoneSequence = wtMilestoneInfo.some((col) => col["name"] === "sequence");
             const wtSliceInfo = adapter.prepare("PRAGMA wt.table_info('slices')").all();
             const hasIsSketch = wtSliceInfo.some((col) => col["name"] === "is_sketch");
             const hasSketchScope = wtSliceInfo.some((col) => col["name"] === "sketch_scope");
@@ -2415,7 +2471,7 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             id, title, status, depends_on, created_at, completed_at,
             vision, success_criteria, key_risks, proof_strategy,
             verification_contract, verification_integration, verification_operational, verification_uat,
-            definition_of_done, requirement_coverage, boundary_map_markdown
+            definition_of_done, requirement_coverage, boundary_map_markdown, sequence
           )
           SELECT w.id, w.title,
                  CASE
@@ -2433,7 +2489,8 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
                  END,
                  w.vision, w.success_criteria, w.key_risks, w.proof_strategy,
                  w.verification_contract, w.verification_integration, w.verification_operational, w.verification_uat,
-                 w.definition_of_done, w.requirement_coverage, w.boundary_map_markdown
+                 w.definition_of_done, w.requirement_coverage, w.boundary_map_markdown,
+                 ${hasMilestoneSequence ? "COALESCE(w.sequence, 0)" : "COALESCE(m.sequence, 0)"}
           FROM wt.milestones w
           LEFT JOIN milestones m ON m.id = w.id
         `).run());
@@ -2659,6 +2716,15 @@ export function getAssessment(path) {
     const row = currentDb.prepare(`SELECT * FROM assessments WHERE path = :path`).get({ ":path": path });
     return row ?? null;
 }
+export function getLatestAssessmentByScope(milestoneId, scope) {
+    if (!currentDb)
+        return null;
+    const row = currentDb.prepare(`SELECT * FROM assessments
+      WHERE milestone_id = :mid AND scope = :scope
+      ORDER BY created_at DESC
+      LIMIT 1`).get({ ":mid": milestoneId, ":scope": scope });
+    return row ?? null;
+}
 // ─── Quality Gates ───────────────────────────────────────────────────────
 function rowToGate(row) {
     return {
@@ -3027,10 +3093,10 @@ export function restoreManifest(manifest) {
         const msStmt = db.prepare(`INSERT INTO milestones (id, title, status, depends_on, created_at, completed_at,
         vision, success_criteria, key_risks, proof_strategy,
         verification_contract, verification_integration, verification_operational, verification_uat,
-        definition_of_done, requirement_coverage, boundary_map_markdown)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
+        definition_of_done, requirement_coverage, boundary_map_markdown, sequence)
+       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
         for (const m of manifest.milestones) {
-            msStmt.run(m.id, m.title, m.status, JSON.stringify(m.depends_on), m.created_at, m.completed_at, m.vision, JSON.stringify(m.success_criteria), JSON.stringify(m.key_risks), JSON.stringify(m.proof_strategy), m.verification_contract, m.verification_integration, m.verification_operational, m.verification_uat, JSON.stringify(m.definition_of_done), m.requirement_coverage, m.boundary_map_markdown);
+            msStmt.run(m.id, m.title, m.status, JSON.stringify(m.depends_on), m.created_at, m.completed_at, m.vision, JSON.stringify(m.success_criteria), JSON.stringify(m.key_risks), JSON.stringify(m.proof_strategy), m.verification_contract, m.verification_integration, m.verification_operational, m.verification_uat, JSON.stringify(m.definition_of_done), m.requirement_coverage, m.boundary_map_markdown, m.sequence ?? 0);
         }
         // Restore slices (ADR-011 Phase 1: includes is_sketch + sketch_scope)
         const slStmt = db.prepare(`INSERT INTO slices (milestone_id, id, title, status, risk, depends, demo,

package/dist/resources/extensions/gsd/guided-flow.js

@@ -19,7 +19,7 @@ import { assessInterruptedSession, formatInterruptedSessionRunningMessage, forma
 import { listUnitRuntimeRecords, clearUnitRuntimeRecord } from "./unit-runtime.js";
 import { resolveExpectedArtifactPath } from "./auto.js";
 import { gsdHome } from "./gsd-home.js";
-import { gsdRoot, milestonesDir, resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveGsdRootFile, relGsdRootFile, relMilestoneFile, relSliceFile, } from "./paths.js";
+import { gsdRoot, milestonesDir, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveSlicePath, resolveGsdRootFile, relGsdRootFile, relMilestoneFile, relSliceFile, clearPathCache, } from "./paths.js";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, readdirSync, rmSync, unlinkSync } from "node:fs";
 import { readSessionLockData, isSessionLockProcessAlive } from "./session-lock.js";
@@ -486,12 +486,35 @@ export function maybeHandleReadyPhraseWithoutFiles(event) {
     const text = extractAssistantText(lastMsg);
     if (!READY_PHRASE_RE.test(text))
         return false;
+    // Bust paths.ts cached dir listings before checking for fresh writes. The
+    // LLM's Write tool calls do not invalidate paths.ts caches, so a stale
+    // listing taken before the milestone dir or its CONTEXT/ROADMAP files
+    // existed would falsely report the artifacts as missing and trigger the
+    // 3-strike "ready without files" abort even though the writes succeeded.
+    clearPathCache();
     // Gate: artifacts must still be missing — if they exist, the happy path
     // already fired and we have nothing to do.
     const contextFile = resolveMilestoneFile(basePath, milestoneId, "CONTEXT");
     const roadmapFile = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
     if (contextFile || roadmapFile)
         return false;
+    // Diagnostic: when the cached resolver reports both files missing, also probe
+    // the canonical paths with uncached existsSync so we can tell whether the
+    // recovery is firing on real-missing files or a path-resolution miss
+    // (basePath/symlink mismatch, stale cache despite agent-end-recovery flush,
+    // legacy descriptor dir not matching, etc.).
+    try {
+        const mDir = resolveMilestonePath(basePath, milestoneId);
+        const canonicalCtx = mDir ? join(mDir, `${milestoneId}-CONTEXT.md`) : null;
+        const canonicalRoadmap = mDir ? join(mDir, `${milestoneId}-ROADMAP.md`) : null;
+        logWarning("guided", `ready-phrase-reject diagnostic mid=${milestoneId} basePath=${basePath} ` +
+            `mDir=${mDir ?? "null"} ` +
+            `canonical-ctx=${canonicalCtx ?? "null"} ctx-exists=${canonicalCtx ? existsSync(canonicalCtx) : "n/a"} ` +
+            `canonical-roadmap=${canonicalRoadmap ?? "null"} roadmap-exists=${canonicalRoadmap ? existsSync(canonicalRoadmap) : "n/a"}`);
+    }
+    catch (e) {
+        logWarning("guided", `ready-phrase-reject diagnostic failed: ${e.message}`);
+    }
     entry.readyRejectCount = (entry.readyRejectCount ?? 0) + 1;
     if (entry.readyRejectCount > MAX_READY_REJECTS) {
         // Give up: clear state and tell the user to re-run /gsd. Avoids an
@@ -576,14 +599,14 @@ export function maybeHandleEmptyIntentTurn(event, isAuto) {
     // path, handled by maybeHandleReadyPhraseWithoutFiles.
     if (READY_PHRASE_RE.test(text))
         return false;
-    // Skip if the LLM is clearly handing back to the user. Last-line `?` is
-    // the strongest signal, but discuss flows often end with a freeform
-    // question followed by a closing remark ("…what should we build? I'll
-    // pick one if you don't care."). Treat ANY non-empty line ending in `?`
-    // as a question-asked signal — false negatives here auto-reply to the
+    // Skip if the LLM is clearly handing back to the user. Discuss flows
+    // often pose a question and follow it with a conditional intent on the
+    // same line ("Did I capture that correctly? If so, I'll write the
+    // requirements."). A line-trailing `?` check misses these because the
+    // line ends in `.`. Match any sentence-terminating `?` (followed by
+    // whitespace or end-of-text) — false negatives here auto-reply to the
     // user, which is a much worse failure mode than a missed nudge.
-    const lines = text.split(/\r?\n/).map((l) => l.trim()).filter(Boolean);
-    if (lines.some((l) => l.endsWith("?")))
+    if (/\?(?:\s|$)/.test(text))
         return false;
     // Must contain a commit-intent phrase — this is the stall we care about.
     if (!COMMIT_INTENT_RE.test(text))

package/dist/resources/extensions/gsd/markdown-renderer.js

@@ -1,9 +1,8 @@
 // GSD Markdown Renderer — DB → Markdown file generation
 //
 // Transforms DB state into correct markdown files on disk.
-// Each render function reads from DB (with disk fallback),
-// patches content to match DB status, writes atomically to disk,
-// stores updated content in the artifacts table, and invalidates caches.
+// Each render function reads from DB, writes a markdown projection to disk,
+// stores generated content in the artifacts table, and invalidates caches.
 //
 // Critical invariant: rendered markdown must round-trip through
 // parseRoadmap(), parsePlan(), parseSummary() in files.ts.
@@ -60,45 +59,16 @@ function taskSummaryForSlicePlan(description) {
     return firstBlock || beforeHeading;
 }
 /**
- * Load artifact content from DB first, falling back to reading from disk.
- * On disk fallback, stores the content in the artifacts table for future use.
- * Returns null if content is unavailable from both sources.
+ * Load artifact content from the DB. Markdown projections are not authoritative
+ * during runtime; when the artifact row is missing, callers regenerate from DB
+ * rows instead of patching disk fallback content and storing it back.
  */
-function loadArtifactContent(artifactPath, absPath, opts) {
-    // Try DB first
+function loadArtifactContent(artifactPath) {
     const artifact = getArtifact(artifactPath);
     if (artifact && artifact.full_content) {
         return artifact.full_content;
     }
-    // Fall back to disk
-    if (!absPath) {
-        process.stderr.write(`markdown-renderer: artifact not found in DB or on disk: ${artifactPath}\n`);
-        return null;
-    }
-    let content;
-    try {
-        content = readFileSync(absPath, "utf-8");
-    }
-    catch {
-        logWarning("renderer", `cannot read file from disk: ${absPath}`);
-        return null;
-    }
-    // Store in DB for future use (graceful degradation path)
-    try {
-        insertArtifact({
-            path: artifactPath,
-            artifact_type: opts.artifact_type,
-            milestone_id: opts.milestone_id,
-            slice_id: opts.slice_id ?? null,
-            task_id: opts.task_id ?? null,
-            full_content: content,
-        });
-    }
-    catch {
-        // Non-fatal: we have the content, DB storage is best-effort
-        logWarning("renderer", `failed to store disk fallback in DB: ${artifactPath}`);
-    }
-    return content;
+    return null;
 }
 /**
  * Write rendered content to disk and update the artifacts table.
@@ -401,17 +371,14 @@ export async function renderRoadmapCheckboxes(basePath, milestoneId) {
     }
     const absPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
     const artifactPath = absPath ? toArtifactPath(absPath, basePath) : null;
-    // Load content from DB (with disk fallback)
+    // Load content from DB; regenerate from DB rows when the artifact is absent.
     let content = null;
     if (artifactPath) {
-        content = loadArtifactContent(artifactPath, absPath, {
-            artifact_type: "ROADMAP",
-            milestone_id: milestoneId,
-        });
+        content = loadArtifactContent(artifactPath);
     }
     if (!content) {
-        process.stderr.write(`markdown-renderer: no roadmap content available for ${milestoneId}\n`);
-        return false;
+        await renderRoadmapFromDb(basePath, milestoneId);
+        return true;
     }
     // Apply checkbox patches for each slice
     let updated = content;
@@ -454,15 +421,11 @@ export async function renderPlanCheckboxes(basePath, milestoneId, sliceId) {
     const artifactPath = absPath ? toArtifactPath(absPath, basePath) : null;
     let content = null;
     if (artifactPath) {
-        content = loadArtifactContent(artifactPath, absPath, {
-            artifact_type: "PLAN",
-            milestone_id: milestoneId,
-            slice_id: sliceId,
-        });
+        content = loadArtifactContent(artifactPath);
     }
     if (!content) {
-        process.stderr.write(`markdown-renderer: no plan content available for ${milestoneId}/${sliceId}\n`);
-        return false;
+        await renderPlanFromDb(basePath, milestoneId, sliceId);
+        return true;
     }
     // Apply checkbox patches for each task
     let updated = content;