gsd-pi 2.74.0 → 2.75.0-dev.2203010a0

package/dist/resources/extensions/gsd/workflow-manifest.js

@@ -1,4 +1,4 @@
-import { _getAdapter, transaction, } from "./gsd-db.js";
+import { _getAdapter, readTransaction, restoreManifest, } from "./gsd-db.js";
 import { atomicWriteSync } from "./atomic-write.js";
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
 import { join } from "node:path";
@@ -41,8 +41,7 @@ export function snapshotState() {
     const db = requireDb();
     // Wrap all reads in a deferred transaction so the snapshot is consistent
     // (all SELECTs see the same DB state even if a concurrent write lands between them).
-    db.exec("BEGIN DEFERRED");
-    try {
+    return readTransaction(() => {
         const rawMilestones = db.prepare("SELECT * FROM milestones ORDER BY id").all();
         const milestones = rawMilestones.map((r) => ({
             id: r["id"],
@@ -83,6 +82,8 @@ export function snapshotState() {
             observability_impact: r["observability_impact"] ?? "",
             sequence: toNumeric(r["sequence"], 0),
             replan_triggered_at: r["replan_triggered_at"] ?? null,
+            is_sketch: toNumeric(r["is_sketch"], 0),
+            sketch_scope: r["sketch_scope"] ?? "",
         }));
         const rawTasks = db.prepare("SELECT * FROM tasks ORDER BY milestone_id, slice_id, sequence, id").all();
         const tasks = rawTasks.map((r) => ({
@@ -111,6 +112,11 @@ export function snapshotState() {
             observability_impact: r["observability_impact"] ?? "",
             full_plan_md: r["full_plan_md"] ?? "",
             sequence: toNumeric(r["sequence"], 0),
+            blocker_source: r["blocker_source"] ?? "",
+            escalation_pending: toNumeric(r["escalation_pending"], 0),
+            escalation_awaiting_review: toNumeric(r["escalation_awaiting_review"], 0),
+            escalation_artifact_path: r["escalation_artifact_path"] ?? null,
+            escalation_override_applied_at: r["escalation_override_applied_at"] ?? null,
         }));
         const rawDecisions = db.prepare("SELECT * FROM decisions ORDER BY seq").all();
         const decisions = rawDecisions.map((r) => ({
@@ -123,6 +129,7 @@ export function snapshotState() {
             rationale: r["rationale"] ?? "",
             revisable: r["revisable"] ?? "",
             made_by: r["made_by"] ?? "agent",
+            source: r["source"] ?? "discussion",
             superseded_by: r["superseded_by"] ?? null,
         }));
         const rawEvidence = db.prepare("SELECT * FROM verification_evidence ORDER BY id").all();
@@ -146,74 +153,14 @@ export function snapshotState() {
             decisions,
             verification_evidence,
         };
-        db.exec("COMMIT");
         return result;
-    }
-    catch (err) {
-        try {
-            db.exec("ROLLBACK");
-        }
-        catch { /* ignore rollback failure */ }
-        throw err;
-    }
-}
-// ─── restore ─────────────────────────────────────────────────────────────
-/**
- * Atomically replace all workflow state from a manifest.
- * Runs inside a transaction — if any insert fails, no tables are modified.
- * Only touches engine tables + decisions. Does NOT modify artifacts or memories.
- */
-function restore(manifest) {
-    const db = requireDb();
-    transaction(() => {
-        // Clear engine tables (order matters for foreign-key-like consistency)
-        db.exec("DELETE FROM verification_evidence");
-        db.exec("DELETE FROM tasks");
-        db.exec("DELETE FROM slices");
-        db.exec("DELETE FROM milestones");
-        db.exec("DELETE FROM decisions WHERE 1=1");
-        // Restore milestones
-        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 (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-        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);
-        }
-        // Restore slices
-        const slStmt = db.prepare(`INSERT INTO slices (milestone_id, id, title, status, risk, depends, demo,
-        created_at, completed_at, full_summary_md, full_uat_md,
-        goal, success_criteria, proof_level, integration_closure, observability_impact,
-        sequence, replan_triggered_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const s of manifest.slices) {
-            slStmt.run(s.milestone_id, s.id, s.title, s.status, s.risk, JSON.stringify(s.depends), s.demo, s.created_at, s.completed_at, s.full_summary_md, s.full_uat_md, s.goal, s.success_criteria, s.proof_level, s.integration_closure, s.observability_impact, s.sequence, s.replan_triggered_at);
-        }
-        // Restore tasks
-        const tkStmt = db.prepare(`INSERT INTO tasks (milestone_id, slice_id, id, title, status,
-        one_liner, narrative, verification_result, duration, completed_at,
-        blocker_discovered, deviations, known_issues, key_files, key_decisions,
-        full_summary_md, description, estimate, files, verify,
-        inputs, expected_output, observability_impact, sequence)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const t of manifest.tasks) {
-            tkStmt.run(t.milestone_id, t.slice_id, t.id, t.title, t.status, t.one_liner, t.narrative, t.verification_result, t.duration, t.completed_at, t.blocker_discovered ? 1 : 0, t.deviations, t.known_issues, JSON.stringify(t.key_files), JSON.stringify(t.key_decisions), t.full_summary_md, t.description, t.estimate, JSON.stringify(t.files), t.verify, JSON.stringify(t.inputs), JSON.stringify(t.expected_output), t.observability_impact, t.sequence);
-        }
-        // Restore decisions
-        const dcStmt = db.prepare(`INSERT INTO decisions (seq, id, when_context, scope, decision, choice, rationale, revisable, made_by, superseded_by)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const d of manifest.decisions) {
-            dcStmt.run(d.seq, d.id, d.when_context, d.scope, d.decision, d.choice, d.rationale, d.revisable, d.made_by, d.superseded_by);
-        }
-        // Restore verification evidence
-        const evStmt = db.prepare(`INSERT INTO verification_evidence (task_id, slice_id, milestone_id, command, exit_code, verdict, duration_ms, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?)`);
-        for (const e of manifest.verification_evidence) {
-            evStmt.run(e.task_id, e.slice_id, e.milestone_id, e.command, e.exit_code, e.verdict, e.duration_ms, e.created_at);
-        }
     });
 }
+// ─── restore ─────────────────────────────────────────────────────────────
+//
+// The actual restore() implementation lives in gsd-db.ts (single-writer
+// invariant). This module only orchestrates reading the manifest file
+// and handing it to the writer.
 // ─── writeManifest ───────────────────────────────────────────────────────
 /**
  * Write current DB state to .gsd/state-manifest.json via atomicWriteSync.
@@ -258,6 +205,6 @@ export function bootstrapFromManifest(basePath) {
     if (!manifest) {
         return false;
     }
-    restore(manifest);
+    restoreManifest(manifest);
     return true;
 }

package/dist/resources/extensions/gsd/workflow-mcp.js

@@ -12,6 +12,7 @@ const MCP_WORKFLOW_TOOL_SURFACE = new Set([
     "gsd_journal_query",
     "gsd_milestone_complete",
     "gsd_milestone_generate_id",
+    "gsd_checkpoint_db",
     "gsd_milestone_status",
     "gsd_milestone_validate",
     "gsd_plan_task",
@@ -290,12 +291,6 @@ export function usesWorkflowMcpTransport(authMode, baseUrl) {
 export function supportsStructuredQuestions(activeTools, options = {}) {
     if (!activeTools.includes("ask_user_questions"))
         return false;
-    // Workflow MCP currently exposes ask_user_questions via MCP form elicitation.
-    // Local external CLI transports such as Claude Code can invoke the tool, but
-    // do not reliably complete that elicitation round-trip yet, so guided discuss
-    // prompts must fall back to plain-text questioning.
-    if (usesWorkflowMcpTransport(options.authMode, options.baseUrl))
-        return false;
     return true;
 }
 export function getWorkflowTransportSupportError(provider, requiredTools, options = {}) {

package/dist/resources/extensions/gsd/workflow-migration.js

@@ -4,7 +4,7 @@
 // Populates data into the already-existing v10 schema tables.
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { join } from "node:path";
-import { _getAdapter, transaction } from "./gsd-db.js";
+import { _getAdapter, bulkInsertLegacyHierarchy } from "./gsd-db.js";
 import { parseRoadmap, parsePlan } from "./parsers-legacy.js";
 import { logWarning } from "./workflow-logger.js";
 // ─── needsAutoMigration ───────────────────────────────────────────────────
@@ -174,27 +174,26 @@ export function migrateFromMarkdown(basePath) {
         process.stderr.write("workflow-migration: no milestones collected, nothing to insert\n");
         return;
     }
-    const placeholders = migratedMilestoneIds.map(() => "?").join(",");
-    transaction(() => {
-        // Clear existing data to handle stale DB shape (DELETE ... IN (...))
-        db.prepare(`DELETE FROM tasks WHERE milestone_id IN (${placeholders})`).run(...migratedMilestoneIds);
-        db.prepare(`DELETE FROM slices WHERE milestone_id IN (${placeholders})`).run(...migratedMilestoneIds);
-        db.prepare(`DELETE FROM milestones WHERE id IN (${placeholders})`).run(...migratedMilestoneIds);
-        // Insert milestones
-        const insertMilestone = db.prepare("INSERT INTO milestones (id, title, status, created_at) VALUES (?, ?, ?, ?)");
-        for (const m of milestoneInserts) {
-            insertMilestone.run(m.id, m.title, m.status, now);
-        }
-        // Insert slices (using v10 column names: depends, sequence)
-        const insertSlice = db.prepare("INSERT INTO slices (id, milestone_id, title, status, risk, depends, sequence, created_at) VALUES (?, ?, ?, ?, ?, ?, ?, ?)");
-        for (const s of sliceInserts) {
-            insertSlice.run(s.id, s.milestoneId, s.title, s.status, s.risk, "[]", s.sequence, now);
-        }
-        // Insert tasks (using v10 column names: sequence, blocker_discovered, full_summary_md)
-        const insertTask = db.prepare("INSERT INTO tasks (id, slice_id, milestone_id, title, description, status, estimate, files, sequence) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)");
-        for (const t of taskInserts) {
-            insertTask.run(t.id, t.sliceId, t.milestoneId, t.title, "", t.status, "", "[]", t.sequence);
-        }
+    bulkInsertLegacyHierarchy({
+        milestones: milestoneInserts,
+        slices: sliceInserts.map(s => ({
+            id: s.id,
+            milestoneId: s.milestoneId,
+            title: s.title,
+            status: s.status,
+            risk: s.risk,
+            sequence: s.sequence,
+        })),
+        tasks: taskInserts.map(t => ({
+            id: t.id,
+            sliceId: t.sliceId,
+            milestoneId: t.milestoneId,
+            title: t.title,
+            status: t.status,
+            sequence: t.sequence,
+        })),
+        clearMilestoneIds: migratedMilestoneIds,
+        createdAt: now,
     });
 }
 // ─── validateMigration ────────────────────────────────────────────────────

package/dist/resources/extensions/gsd/workflow-plugins.js

@@ -0,0 +1,346 @@
+/**
+ * workflow-plugins.ts — Unified discovery for workflow plugins.
+ *
+ * Discovers workflow definitions from three tiers (project > global > bundled)
+ * in both YAML and markdown formats. Each plugin declares an execution mode
+ * that controls how `/gsd workflow <name>` dispatches it:
+ *
+ *   oneshot         — prompt-only, no state or scaffolding
+ *   yaml-step       — CustomWorkflowEngine run with GRAPH.yaml
+ *   markdown-phase  — STATE.json + phase gates (current md template behavior)
+ *   auto-milestone  — hooks into /gsd auto pipeline (full-project only)
+ *
+ * Precedence: project > global > bundled. Same-named file wins.
+ */
+import { readFileSync, readdirSync, existsSync, statSync, } from "node:fs";
+import { join, dirname, extname, basename } from "node:path";
+import { fileURLToPath } from "node:url";
+import { homedir } from "node:os";
+import { parse as parseYaml } from "yaml";
+import { loadRegistry } from "./workflow-templates.js";
+// ─── Path resolution ─────────────────────────────────────────────────────
+function resolveBundledDir() {
+    const moduleDir = dirname(fileURLToPath(import.meta.url));
+    const local = join(moduleDir, "workflow-templates");
+    if (existsSync(local))
+        return local;
+    const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+    const agentGsdDir = join(gsdHome, "agent", "extensions", "gsd", "workflow-templates");
+    if (existsSync(agentGsdDir))
+        return agentGsdDir;
+    return local;
+}
+function globalPluginsDir() {
+    const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+    return join(gsdHome, "workflows");
+}
+function projectPluginsDir(basePath) {
+    return join(basePath, ".gsd", "workflows");
+}
+function legacyDefsDir(basePath) {
+    return join(basePath, ".gsd", "workflow-defs");
+}
+// ─── Markdown frontmatter parsing ────────────────────────────────────────
+/**
+ * Parse the `<template_meta>` block from bundled/user markdown workflow files.
+ * Returns a loose key-value map (strings only).
+ */
+function parseTemplateMeta(content) {
+    const match = content.match(/<template_meta>([\s\S]*?)<\/template_meta>/);
+    if (!match)
+        return {};
+    const body = match[1];
+    const result = {};
+    for (const line of body.split(/\r?\n/)) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        const colon = trimmed.indexOf(":");
+        if (colon === -1)
+            continue;
+        const key = trimmed.slice(0, colon).trim();
+        const value = trimmed.slice(colon + 1).trim();
+        result[key] = value;
+    }
+    return result;
+}
+function parsePhasesFromMarkdown(content) {
+    const match = content.match(/<phases>([\s\S]*?)<\/phases>/);
+    if (!match)
+        return [];
+    const phases = [];
+    for (const line of match[1].split(/\r?\n/)) {
+        const m = line.match(/^\s*\d+\.\s*(\S+)/);
+        if (m)
+            phases.push(m[1]);
+    }
+    return phases;
+}
+function firstHeading(content) {
+    const match = content.match(/^#\s+(.+)$/m);
+    return match ? match[1].trim() : undefined;
+}
+function isValidMode(v) {
+    return v === "oneshot" || v === "yaml-step" || v === "markdown-phase" || v === "auto-milestone";
+}
+// ─── Single-file plugin loaders ──────────────────────────────────────────
+function loadMarkdownPlugin(filePath, source) {
+    const name = basenameNoExt(filePath);
+    let content;
+    try {
+        content = readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    const meta = parseTemplateMeta(content);
+    const phases = parsePhasesFromMarkdown(content);
+    const declaredMode = meta.mode;
+    const mode = isValidMode(declaredMode) ? declaredMode : "markdown-phase";
+    const triggers = meta.triggers
+        ? meta.triggers.split(",").map((s) => s.trim()).filter(Boolean)
+        : undefined;
+    const artifactDirValue = meta.artifact_dir === "null" || meta.artifact_dir === "" ? null : meta.artifact_dir;
+    return {
+        name,
+        path: filePath,
+        format: "md",
+        source,
+        meta: {
+            displayName: meta.name || firstHeading(content) || name,
+            description: meta.description,
+            mode,
+            phases: phases.length > 0 ? phases : undefined,
+            triggers,
+            complexity: meta.complexity,
+            artifactDir: artifactDirValue ?? undefined,
+            requiresProject: meta.requires_project === "true",
+        },
+    };
+}
+function loadYamlPlugin(filePath, source) {
+    const name = basenameNoExt(filePath);
+    let raw;
+    try {
+        raw = readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+    let parsed;
+    try {
+        parsed = parseYaml(raw);
+    }
+    catch (err) {
+        return {
+            name,
+            path: filePath,
+            format: "yaml",
+            source,
+            meta: { displayName: name, mode: "yaml-step" },
+            error: `YAML parse error: ${err instanceof Error ? err.message : String(err)}`,
+        };
+    }
+    if (parsed == null || typeof parsed !== "object") {
+        return {
+            name,
+            path: filePath,
+            format: "yaml",
+            source,
+            meta: { displayName: name, mode: "yaml-step" },
+            error: "Definition is not an object",
+        };
+    }
+    const def = parsed;
+    const declaredMode = def.mode;
+    const mode = isValidMode(declaredMode) ? declaredMode : "yaml-step";
+    const steps = Array.isArray(def.steps) ? def.steps : [];
+    const phases = steps.map((s) => String(s.id ?? "")).filter(Boolean);
+    return {
+        name,
+        path: filePath,
+        format: "yaml",
+        source,
+        meta: {
+            displayName: typeof def.name === "string" && def.name.trim() ? def.name : name,
+            description: typeof def.description === "string" ? def.description : undefined,
+            mode,
+            phases: phases.length > 0 ? phases : undefined,
+        },
+    };
+}
+function basenameNoExt(filePath) {
+    const ext = extname(filePath);
+    return basename(filePath, ext);
+}
+// ─── Directory walkers ───────────────────────────────────────────────────
+const PLUGIN_EXTENSIONS = new Set([".yaml", ".yml", ".md"]);
+function walkPluginDir(dir, source, out) {
+    if (!existsSync(dir))
+        return;
+    let entries;
+    try {
+        entries = readdirSync(dir);
+    }
+    catch {
+        return;
+    }
+    for (const entry of entries) {
+        const full = join(dir, entry);
+        let info;
+        try {
+            info = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (!info.isFile())
+            continue;
+        const ext = extname(entry).toLowerCase();
+        if (!PLUGIN_EXTENSIONS.has(ext))
+            continue;
+        const plugin = ext === ".md"
+            ? loadMarkdownPlugin(full, source)
+            : loadYamlPlugin(full, source);
+        if (!plugin)
+            continue;
+        out.set(plugin.name, plugin);
+    }
+}
+function loadBundledPlugins(out) {
+    const bundledDir = resolveBundledDir();
+    if (!existsSync(bundledDir))
+        return;
+    const registry = loadRegistry();
+    for (const [id, entry] of Object.entries(registry.templates)) {
+        const filePath = join(bundledDir, entry.file);
+        if (!existsSync(filePath))
+            continue;
+        const ext = extname(entry.file).toLowerCase();
+        const format = ext === ".md" ? "md" : "yaml";
+        const mode = isValidMode(entry.mode)
+            ? entry.mode
+            : (format === "yaml" ? "yaml-step" : "markdown-phase");
+        out.set(id, {
+            name: id,
+            path: filePath,
+            format,
+            source: "bundled",
+            meta: {
+                displayName: entry.name,
+                description: entry.description,
+                mode,
+                phases: Array.isArray(entry.phases) && entry.phases.length > 0 ? entry.phases : undefined,
+                triggers: Array.isArray(entry.triggers) ? entry.triggers : undefined,
+                complexity: entry.estimated_complexity,
+                artifactDir: entry.artifact_dir,
+                requiresProject: entry.requires_project,
+            },
+        });
+    }
+}
+// ─── Public API ──────────────────────────────────────────────────────────
+/**
+ * Discover all workflow plugins. Project overrides global overrides bundled.
+ *
+ * The legacy `.gsd/workflow-defs/*.yaml` directory is also scanned as a
+ * fallback YAML source so existing user definitions keep working.
+ */
+export function discoverPlugins(basePath) {
+    const out = new Map();
+    loadBundledPlugins(out);
+    walkPluginDir(globalPluginsDir(), "global", out);
+    walkPluginDir(legacyDefsDir(basePath), "project", out);
+    walkPluginDir(projectPluginsDir(basePath), "project", out);
+    return out;
+}
+/**
+ * Resolve a plugin by name using the precedence chain.
+ * Returns null if no plugin by that name exists anywhere.
+ */
+export function resolvePlugin(basePath, name) {
+    const plugins = discoverPlugins(basePath);
+    return plugins.get(name) ?? null;
+}
+/**
+ * Format all discovered plugins for display, grouped by mode.
+ */
+export function listPluginsFormatted(basePath) {
+    const plugins = discoverPlugins(basePath);
+    if (plugins.size === 0) {
+        return "No workflow plugins found.\n\nRun /gsd workflow new to author one.";
+    }
+    const groups = {
+        "oneshot": [],
+        "yaml-step": [],
+        "markdown-phase": [],
+        "auto-milestone": [],
+    };
+    for (const p of plugins.values()) {
+        groups[p.meta.mode].push(p);
+    }
+    const lines = ["Workflow Plugins\n"];
+    const order = ["markdown-phase", "yaml-step", "oneshot", "auto-milestone"];
+    for (const mode of order) {
+        const list = groups[mode].slice().sort((a, b) => a.name.localeCompare(b.name));
+        if (list.length === 0)
+            continue;
+        lines.push(`  [${mode}]`);
+        for (const p of list) {
+            const tag = `${p.source}/${p.format}`;
+            const desc = p.meta.description ? ` — ${p.meta.description}` : "";
+            lines.push(`    ${p.name.padEnd(22)} ${tag.padEnd(16)}${desc}`);
+        }
+        lines.push("");
+    }
+    lines.push("Usage:");
+    lines.push("  /gsd workflow <name>          Run a plugin directly");
+    lines.push("  /gsd workflow info <name>     Show plugin details");
+    lines.push("  /gsd workflow install <src>   Install a plugin from a URL");
+    return lines.join("\n");
+}
+/**
+ * Format a single plugin's metadata for `/gsd workflow info <name>`.
+ */
+export function formatPluginInfo(plugin) {
+    const lines = [
+        `Plugin: ${plugin.meta.displayName} (${plugin.name})`,
+        "",
+        `Source:   ${plugin.source}`,
+        `Format:   ${plugin.format}`,
+        `Mode:     ${plugin.meta.mode}`,
+        `Path:     ${plugin.path}`,
+    ];
+    if (plugin.meta.description) {
+        lines.push(`About:    ${plugin.meta.description}`);
+    }
+    if (plugin.meta.complexity) {
+        lines.push(`Complexity: ${plugin.meta.complexity}`);
+    }
+    if (plugin.meta.phases && plugin.meta.phases.length > 0) {
+        lines.push("", "Phases/Steps:");
+        plugin.meta.phases.forEach((p, i) => lines.push(`  ${i + 1}. ${p}`));
+    }
+    if (plugin.meta.triggers && plugin.meta.triggers.length > 0) {
+        lines.push("", `Triggers: ${plugin.meta.triggers.join(", ")}`);
+    }
+    if (plugin.meta.artifactDir) {
+        lines.push("", `Artifacts: ${plugin.meta.artifactDir}`);
+    }
+    if (plugin.error) {
+        lines.push("", `⚠ Error: ${plugin.error}`);
+    }
+    return lines.join("\n");
+}
+/**
+ * Get the plugin directory paths for the project/global/bundled tiers.
+ * Exposed for the install command and tests.
+ */
+export function getPluginDirs(basePath) {
+    return {
+        project: projectPluginsDir(basePath),
+        global: globalPluginsDir(),
+        bundled: resolveBundledDir(),
+        legacy: legacyDefsDir(basePath),
+    };
+}

package/dist/resources/extensions/gsd/workflow-projections.js

@@ -8,6 +8,7 @@ import { mkdirSync, existsSync } from "node:fs";
 import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
 import { deriveState } from "./state.js";
+import { renderRoadmapFromDb } from "./markdown-renderer.js";
 // ─── Helpers ─────────────────────────────────────────────────────────────
 /**
  * Strip a leading ID prefix (e.g. "M001: " or "S04: ") from a title
@@ -303,7 +304,10 @@ export async function renderStateProjection(basePath) {
         try {
             adapter.prepare("SELECT 1").get();
         }
-        catch {
+        catch (err) {
+            logWarning("projection", "renderStateProjection: DB handle probe failed, skipping render", {
+                error: err.message,
+            });
             return;
         }
         const state = await deriveState(basePath);
@@ -322,12 +326,14 @@ export async function renderStateProjection(basePath) {
  * All calls are wrapped in try/catch — projection failure is non-fatal per D-02.
  */
 export async function renderAllProjections(basePath, milestoneId) {
-    // Render ROADMAP.md for the milestone
+    // Delegate to the authoritative roadmap renderer — the reduced
+    // renderRoadmapProjection omits sections like ## Boundary Map and would
+    // clobber the output written by plan-milestone / reassess-roadmap.
     try {
-        renderRoadmapProjection(basePath, milestoneId);
+        await renderRoadmapFromDb(basePath, milestoneId);
     }
     catch (err) {
-        logWarning("projection", `renderRoadmapProjection failed for ${milestoneId}: ${err.message}`);
+        logWarning("projection", `renderRoadmapFromDb failed for ${milestoneId}: ${err.message}`);
     }
     // Query all slices for this milestone
     const sliceRows = getMilestoneSlices(milestoneId);
@@ -359,10 +365,11 @@ export async function renderAllProjections(basePath, milestoneId) {
 // ─── regenerateIfMissing ────────────────────────────────────────────────
 /**
  * Check if a projection file exists on disk. If missing, regenerate it from DB.
- * Returns true if the file was regenerated, false if it already existed.
+ * Returns true if the file was regenerated, false if it already existed or
+ * regeneration failed.
  * Satisfies PROJ-05 (corrupted/deleted projections regenerate on demand).
  */
-export function regenerateIfMissing(basePath, milestoneId, sliceId, fileType) {
+export async function regenerateIfMissing(basePath, milestoneId, sliceId, fileType) {
     let filePath;
     switch (fileType) {
         case "PLAN":
@@ -401,23 +408,21 @@ export function regenerateIfMissing(basePath, milestoneId, sliceId, fileType) {
     if (existsSync(filePath)) {
         return false;
     }
-    // Regenerate the missing file
+    // Regenerate the missing file. Each renderer may swallow its own errors
+    // (e.g. renderStateProjection), so confirm the file actually exists on
+    // disk before reporting success — true must mean "file is there now".
     try {
         switch (fileType) {
             case "PLAN":
                 renderPlanProjection(basePath, milestoneId, sliceId);
-                break;
+                return existsSync(filePath);
             case "ROADMAP":
-                renderRoadmapProjection(basePath, milestoneId);
-                break;
+                await renderRoadmapFromDb(basePath, milestoneId);
+                return existsSync(filePath);
             case "STATE":
-                // renderStateProjection is async — fire-and-forget.
-                // Return false since the file isn't written yet; it will appear
-                // on the next post-mutation hook cycle.
-                void renderStateProjection(basePath);
-                return false;
+                await renderStateProjection(basePath);
+                return existsSync(filePath);
         }
-        return true;
     }
     catch (err) {
         logWarning("projection", `regenerateIfMissing ${fileType} failed: ${err.message}`);