gsd-pi 2.44.0-dev.d25d507 → 2.45.0-dev.1afbdaa

package/dist/resources/extensions/gsd/commands/handlers/ops.js

@@ -188,10 +188,20 @@ Examples:
         await handleFast(trimmed.replace(/^fast\s*/, "").trim(), ctx);
         return true;
     }
+    if (trimmed === "mcp" || trimmed.startsWith("mcp ")) {
+        const { handleMcpStatus } = await import("../../commands-mcp-status.js");
+        await handleMcpStatus(trimmed.replace(/^mcp\s*/, "").trim(), ctx);
+        return true;
+    }
     if (trimmed === "extensions" || trimmed.startsWith("extensions ")) {
         const { handleExtensions } = await import("../../commands-extensions.js");
         await handleExtensions(trimmed.replace(/^extensions\s*/, "").trim(), ctx);
         return true;
     }
+    if (trimmed === "rethink") {
+        const { handleRethink } = await import("../../rethink.js");
+        await handleRethink(trimmed, ctx, pi);
+        return true;
+    }
     return false;
 }

package/dist/resources/extensions/gsd/commands/handlers/parallel.js

@@ -44,7 +44,7 @@ export async function handleParallelCommand(trimmed, _ctx, pi) {
         }
         const lines = ["# Parallel Workers\n"];
         for (const worker of workers) {
-            lines.push(`- **${worker.milestoneId}** (${worker.title}) — ${worker.state} — ${worker.completedUnits} units — $${worker.cost.toFixed(2)}`);
+            lines.push(`- **${worker.milestoneId}** (${worker.title}) — ${worker.state} — $${worker.cost.toFixed(2)}`);
         }
         const state = getOrchestratorState();
         if (state) {

package/dist/resources/extensions/gsd/commands-mcp-status.js

@@ -0,0 +1,187 @@
+/**
+ * MCP Status — `/gsd mcp` command handler.
+ *
+ * Shows configured MCP servers, their connection status, and available tools.
+ *
+ * Subcommands:
+ *   /gsd mcp             — Overview of all servers (alias: /gsd mcp status)
+ *   /gsd mcp status      — Same as bare /gsd mcp
+ *   /gsd mcp check <srv> — Detailed status for a specific server
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+function readMcpConfigs() {
+    const servers = [];
+    const seen = new Set();
+    const configPaths = [
+        join(process.cwd(), ".mcp.json"),
+        join(process.cwd(), ".gsd", "mcp.json"),
+    ];
+    for (const configPath of configPaths) {
+        try {
+            if (!existsSync(configPath))
+                continue;
+            const raw = readFileSync(configPath, "utf-8");
+            const data = JSON.parse(raw);
+            const mcpServers = (data.mcpServers ?? data.servers);
+            if (!mcpServers || typeof mcpServers !== "object")
+                continue;
+            for (const [name, config] of Object.entries(mcpServers)) {
+                if (seen.has(name))
+                    continue;
+                seen.add(name);
+                const hasCommand = typeof config.command === "string";
+                const hasUrl = typeof config.url === "string";
+                const transport = hasCommand
+                    ? "stdio"
+                    : hasUrl
+                        ? "http"
+                        : "unknown";
+                servers.push({
+                    name,
+                    transport,
+                    ...(hasCommand && {
+                        command: config.command,
+                        args: Array.isArray(config.args) ? config.args : undefined,
+                    }),
+                    ...(hasUrl && { url: config.url }),
+                });
+            }
+        }
+        catch {
+            // Non-fatal — config file may not exist or be malformed
+        }
+    }
+    return servers;
+}
+// ─── Formatters (exported for testing) ──────────────────────────────────────
+export function formatMcpStatusReport(servers) {
+    if (servers.length === 0) {
+        return [
+            "No MCP servers configured.",
+            "",
+            "Add servers to .mcp.json or .gsd/mcp.json to enable MCP integrations.",
+            "See: https://modelcontextprotocol.io/quickstart",
+        ].join("\n");
+    }
+    const lines = [`MCP Server Status — ${servers.length} server(s)\n`];
+    for (const s of servers) {
+        const icon = s.error ? "✗" : s.connected ? "✓" : "○";
+        const status = s.error
+            ? `error: ${s.error}`
+            : s.connected
+                ? `connected — ${s.toolCount} tools`
+                : "disconnected";
+        lines.push(`  ${icon} ${s.name} (${s.transport}) — ${status}`);
+    }
+    lines.push("");
+    lines.push("Use /gsd mcp check <server> for details on a specific server.");
+    lines.push("Use mcp_discover to connect and list tools for a server.");
+    return lines.join("\n");
+}
+export function formatMcpServerDetail(server) {
+    const lines = [`MCP Server: ${server.name}\n`];
+    lines.push(`  Transport: ${server.transport}`);
+    if (server.error) {
+        lines.push(`  Status:    error`);
+        lines.push(`  Error:     ${server.error}`);
+    }
+    else if (server.connected) {
+        lines.push(`  Status:    connected`);
+        lines.push(`  Tools:     ${server.toolCount}`);
+        if (server.tools.length > 0) {
+            lines.push("");
+            lines.push("  Available tools:");
+            for (const tool of server.tools) {
+                lines.push(`    - ${tool}`);
+            }
+        }
+    }
+    else {
+        lines.push(`  Status:    disconnected`);
+        lines.push("");
+        lines.push(`  Run mcp_discover("${server.name}") to connect and list tools.`);
+    }
+    return lines.join("\n");
+}
+// ─── Command handler ────────────────────────────────────────────────────────
+/**
+ * Handle `/gsd mcp [status|check <server>]`.
+ */
+export async function handleMcpStatus(args, ctx) {
+    const trimmed = args.trim().toLowerCase();
+    const configs = readMcpConfigs();
+    // /gsd mcp check <server>
+    if (trimmed.startsWith("check ")) {
+        const serverName = args.trim().slice("check ".length).trim();
+        const config = configs.find((c) => c.name === serverName);
+        if (!config) {
+            const available = configs.map((c) => c.name).join(", ") || "(none)";
+            ctx.ui.notify(`Unknown MCP server: "${serverName}"\n\nAvailable: ${available}`, "warning");
+            return;
+        }
+        // Try to get connection/tool info from the mcp-client module if available
+        let connected = false;
+        let toolNames = [];
+        let error;
+        try {
+            const mcpClient = await import("../mcp-client/index.js");
+            // Access the module's connection state if exported; fall back gracefully
+            const mod = mcpClient;
+            if (typeof mod.getConnectionStatus === "function") {
+                const status = mod.getConnectionStatus(serverName);
+                connected = status.connected;
+                toolNames = status.tools;
+                error = status.error;
+            }
+        }
+        catch {
+            // mcp-client may not expose status helpers — that's fine
+        }
+        ctx.ui.notify(formatMcpServerDetail({
+            name: config.name,
+            transport: config.transport,
+            connected,
+            toolCount: toolNames.length,
+            tools: toolNames,
+            error,
+        }), "info");
+        return;
+    }
+    // /gsd mcp or /gsd mcp status
+    if (!trimmed || trimmed === "status") {
+        // Build status for each server
+        const statuses = [];
+        for (const config of configs) {
+            let connected = false;
+            let toolCount = 0;
+            let error;
+            try {
+                const mcpClient = await import("../mcp-client/index.js");
+                const mod = mcpClient;
+                if (typeof mod.getConnectionStatus === "function") {
+                    const status = mod.getConnectionStatus(config.name);
+                    connected = status.connected;
+                    toolCount = status.tools.length;
+                    error = status.error;
+                }
+            }
+            catch {
+                // Fall back to unknown state
+            }
+            statuses.push({
+                name: config.name,
+                transport: config.transport,
+                connected,
+                toolCount,
+                error,
+            });
+        }
+        ctx.ui.notify(formatMcpStatusReport(statuses), "info");
+        return;
+    }
+    // Unknown subcommand
+    ctx.ui.notify("Usage: /gsd mcp [status|check <server>]\n\n" +
+        "  status           Show all MCP server statuses (default)\n" +
+        "  check <server>   Detailed status for a specific server", "warning");
+}

package/dist/resources/extensions/gsd/crash-recovery.js

@@ -18,7 +18,7 @@ function lockPath(basePath) {
     return join(gsdRoot(basePath), LOCK_FILE);
 }
 /** Write or update the lock file with current auto-mode state. */
-export function writeLock(basePath, unitType, unitId, completedUnits, sessionFile) {
+export function writeLock(basePath, unitType, unitId, sessionFile) {
     try {
         const data = {
             pid: process.pid,
@@ -26,7 +26,6 @@ export function writeLock(basePath, unitType, unitId, completedUnits, sessionFil
             unitType,
             unitId,
             unitStartedAt: new Date().toISOString(),
-            completedUnits,
             sessionFile,
         };
         const lp = lockPath(basePath);
@@ -90,11 +89,10 @@ export function formatCrashInfo(lock) {
         `Previous auto-mode session was interrupted.`,
         `  Was executing: ${lock.unitType} (${lock.unitId})`,
         `  Started at: ${lock.unitStartedAt}`,
-        `  Units completed before crash: ${lock.completedUnits}`,
         `  PID: ${lock.pid}`,
     ];
     // Add recovery guidance based on what was happening when it crashed
-    if (lock.unitType === "starting" && lock.unitId === "bootstrap" && lock.completedUnits === 0) {
+    if (lock.unitType === "starting" && lock.unitId === "bootstrap") {
         lines.push(`No work was lost. Run /gsd auto to restart.`);
     }
     else if (lock.unitType.includes("research") || lock.unitType.includes("plan")) {

package/dist/resources/extensions/gsd/dashboard-overlay.js

@@ -81,18 +81,11 @@ export class GSDDashboardOverlay {
         const currentUnit = dashData.currentUnit
             ? `${dashData.currentUnit.type}:${dashData.currentUnit.id}:${dashData.currentUnit.startedAt}`
             : "-";
-        const lastCompleted = dashData.completedUnits.length > 0
-            ? dashData.completedUnits[dashData.completedUnits.length - 1]
-            : null;
-        const completedKey = lastCompleted
-            ? `${dashData.completedUnits.length}:${lastCompleted.type}:${lastCompleted.id}:${lastCompleted.finishedAt}`
-            : "0";
         return [
             base,
             dashData.active ? "1" : "0",
             dashData.paused ? "1" : "0",
             currentUnit,
-            completedKey,
         ].join("|");
     }
     async refreshDashboard(initial = false) {
@@ -393,43 +386,6 @@ export class GSDDashboardOverlay {
         else {
             lines.push(centered(th.fg("dim", "No active milestone.")));
         }
-        if (this.dashData.completedUnits.length > 0) {
-            lines.push(blank());
-            lines.push(hr());
-            lines.push(row(th.fg("text", th.bold("Completed"))));
-            lines.push(blank());
-            // Build ledger lookup for budget indicators (last entry wins for retries)
-            const ledgerLookup = new Map();
-            const currentLedger = getLedger();
-            if (currentLedger) {
-                for (const lu of currentLedger.units) {
-                    ledgerLookup.set(`${lu.type}:${lu.id}`, lu);
-                }
-            }
-            const recent = [...this.dashData.completedUnits].reverse().slice(0, 10);
-            for (const u of recent) {
-                // Budget indicators from ledger — use warning glyph for pressured units
-                const ledgerEntry = ledgerLookup.get(`${u.type}:${u.id}`);
-                const hadPressure = ledgerEntry?.continueHereFired === true;
-                const hadTruncation = (ledgerEntry?.truncationSections ?? 0) > 0;
-                const unitGlyph = hadPressure
-                    ? th.fg(STATUS_COLOR.warning, STATUS_GLYPH.warning)
-                    : th.fg(STATUS_COLOR.done, STATUS_GLYPH.done);
-                const left = `  ${unitGlyph} ${th.fg("muted", unitLabel(u.type))} ${th.fg("muted", u.id)}`;
-                let budgetMarkers = "";
-                if (hadTruncation) {
-                    budgetMarkers += th.fg("warning", ` ▼${ledgerEntry.truncationSections}`);
-                }
-                if (hadPressure) {
-                    budgetMarkers += th.fg("error", " → wrap-up");
-                }
-                const right = th.fg("dim", formatDuration(u.finishedAt - u.startedAt));
-                lines.push(row(joinColumns(`${left}${budgetMarkers}`, right, contentWidth)));
-            }
-            if (this.dashData.completedUnits.length > 10) {
-                lines.push(row(th.fg("dim", `  ...and ${this.dashData.completedUnits.length - 10} more`)));
-            }
-        }
         const ledger = getLedger();
         if (ledger && ledger.units.length > 0) {
             const totals = getProjectTotals(ledger.units);

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

@@ -8,10 +8,11 @@
 // Critical invariant: generated markdown must round-trip through
 // parseDecisionsTable() and parseRequirementsSections() with field fidelity.
 import { resolve } from 'node:path';
-import { readFileSync, existsSync } from 'node:fs';
+import { readFileSync, existsSync, statSync } from 'node:fs';
 import { resolveGsdRootFile } from './paths.js';
 import { saveFile } from './files.js';
 import { GSDError, GSD_STALE_STATE, GSD_IO_ERROR } from './errors.js';
+import { logWarning, logError } from './workflow-logger.js';
 import { invalidateStateCache } from './state.js';
 import { clearPathCache } from './paths.js';
 import { clearParseCache } from './files.js';
@@ -200,7 +201,7 @@ export async function nextDecisionId() {
         return `D${String(next).padStart(3, '0')}`;
     }
     catch (err) {
-        process.stderr.write(`gsd-db: nextDecisionId failed: ${err.message}\n`);
+        logError('manifest', 'nextDecisionId failed', { fn: 'nextDecisionId', error: String(err.message) });
         return 'D001';
     }
 }
@@ -269,7 +270,7 @@ export async function saveDecisionToDb(fields, basePath) {
             await saveFile(filePath, md);
         }
         catch (diskErr) {
-            process.stderr.write(`gsd-db: saveDecisionToDb — disk write failed, rolling back DB row: ${diskErr.message}\n`);
+            logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveDecisionToDb', error: String(diskErr.message) });
             adapter?.prepare('DELETE FROM decisions WHERE id = :id').run({ ':id': id });
             throw diskErr;
         }
@@ -281,7 +282,7 @@ export async function saveDecisionToDb(fields, basePath) {
         return { id };
     }
     catch (err) {
-        process.stderr.write(`gsd-db: saveDecisionToDb failed: ${err.message}\n`);
+        logError('manifest', 'saveDecisionToDb failed', { fn: 'saveDecisionToDb', error: String(err.message) });
         throw err;
     }
 }
@@ -333,7 +334,7 @@ export async function updateRequirementInDb(id, updates, basePath) {
             await saveFile(filePath, md);
         }
         catch (diskErr) {
-            process.stderr.write(`gsd-db: updateRequirementInDb — disk write failed, reverting DB row: ${diskErr.message}\n`);
+            logError('manifest', 'disk write failed, reverting DB row', { fn: 'updateRequirementInDb', error: String(diskErr.message) });
             db.upsertRequirement(existing);
             throw diskErr;
         }
@@ -344,7 +345,7 @@ export async function updateRequirementInDb(id, updates, basePath) {
         clearParseCache();
     }
     catch (err) {
-        process.stderr.write(`gsd-db: updateRequirementInDb failed: ${err.message}\n`);
+        logError('manifest', 'updateRequirementInDb failed', { fn: 'updateRequirementInDb', error: String(err.message) });
         throw err;
     }
 }
@@ -356,28 +357,45 @@ export async function updateRequirementInDb(id, updates, basePath) {
 export async function saveArtifactToDb(opts, basePath) {
     try {
         const db = await import('./gsd-db.js');
+        // Guard against path traversal before any reads/writes
+        const gsdDir = resolve(basePath, '.gsd');
+        const fullPath = resolve(basePath, '.gsd', opts.path);
+        if (!fullPath.startsWith(gsdDir)) {
+            throw new GSDError(GSD_IO_ERROR, `saveArtifactToDb: path escapes .gsd/ directory: ${opts.path}`);
+        }
+        // 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.
+        let dbContent = opts.content;
+        let skipDiskWrite = false;
+        if (existsSync(fullPath)) {
+            const existingSize = statSync(fullPath).size;
+            const newSize = Buffer.byteLength(opts.content, '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');
+                skipDiskWrite = true;
+            }
+        }
         db.insertArtifact({
             path: opts.path,
             artifact_type: opts.artifact_type,
             milestone_id: opts.milestone_id ?? null,
             slice_id: opts.slice_id ?? null,
             task_id: opts.task_id ?? null,
-            full_content: opts.content,
+            full_content: dbContent,
         });
-        // Write the file to disk (guard against path traversal)
-        const gsdDir = resolve(basePath, '.gsd');
-        const fullPath = resolve(basePath, '.gsd', opts.path);
-        if (!fullPath.startsWith(gsdDir)) {
-            throw new GSDError(GSD_IO_ERROR, `saveArtifactToDb: path escapes .gsd/ directory: ${opts.path}`);
-        }
-        try {
-            await saveFile(fullPath, opts.content);
-        }
-        catch (diskErr) {
-            process.stderr.write(`gsd-db: saveArtifactToDb — disk write failed, rolling back DB row: ${diskErr.message}\n`);
-            const rollbackAdapter = db._getAdapter();
-            rollbackAdapter?.prepare('DELETE FROM artifacts WHERE path = :path').run({ ':path': opts.path });
-            throw diskErr;
+        // Write the file to disk (only if we're not preserving a richer existing file)
+        if (!skipDiskWrite) {
+            try {
+                await saveFile(fullPath, opts.content);
+            }
+            catch (diskErr) {
+                logError('manifest', 'disk write failed, rolling back DB row', { fn: 'saveArtifactToDb', error: String(diskErr.message) });
+                const rollbackAdapter = db._getAdapter();
+                rollbackAdapter?.prepare('DELETE FROM artifacts WHERE path = :path').run({ ':path': opts.path });
+                throw diskErr;
+            }
         }
         // Invalidate file-read caches so deriveState() sees the updated markdown.
         // Do NOT clear the artifacts table — we just wrote to it intentionally.
@@ -386,7 +404,7 @@ export async function saveArtifactToDb(opts, basePath) {
         clearParseCache();
     }
     catch (err) {
-        process.stderr.write(`gsd-db: saveArtifactToDb failed: ${err.message}\n`);
+        logError('manifest', 'saveArtifactToDb failed', { fn: 'saveArtifactToDb', error: String(err.message) });
         throw err;
     }
 }

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

@@ -3,7 +3,7 @@ import { basename, dirname, join, sep } from "node:path";
 import { readRepoMeta, externalProjectsRoot, cleanNumberedGsdVariants } from "./repo-identity.js";
 import { loadFile } from "./files.js";
 import { parseRoadmap as parseLegacyRoadmap } from "./parsers-legacy.js";
-import { isDbAvailable, getMilestoneSlices } from "./gsd-db.js";
+import { isDbAvailable, _getAdapter, getMilestoneSlices } from "./gsd-db.js";
 import { resolveMilestoneFile, milestonesDir, gsdRoot, resolveGsdRootFile } from "./paths.js";
 import { deriveState, isMilestoneComplete } from "./state.js";
 import { saveFile } from "./files.js";
@@ -17,7 +17,9 @@ import { getAllWorktreeHealth } from "./worktree-health.js";
 import { readAllSessionStatuses, isSessionStale, removeSessionStatus } from "./session-status-io.js";
 import { recoverFailedMigration } from "./migrate-external.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode = "worktree") {
+import { readEvents } from "./workflow-events.js";
+import { renderAllProjections } from "./workflow-projections.js";
+export async function checkGitHealth(basePath, issues, fixesApplied, shouldFix, isolationMode = "none") {
     // Degrade gracefully if not a git repo
     if (!nativeIsRepo(basePath)) {
         return; // Not a git repo — skip all git health checks
@@ -1067,3 +1069,166 @@ export async function checkGlobalHealth(issues, fixesApplied, shouldFix) {
         // Non-fatal — global health check must not block per-project doctor
     }
 }
+// ── Engine Health Checks ────────────────────────────────────────────────────
+// DB constraint violation detection and projection drift checks.
+export async function checkEngineHealth(basePath, issues, fixesApplied) {
+    // ── DB constraint violation detection (full doctor only, not pre-dispatch per D-10) ──
+    try {
+        if (isDbAvailable()) {
+            const adapter = _getAdapter();
+            // a. Orphaned tasks (task.slice_id points to non-existent slice)
+            try {
+                const orphanedTasks = adapter
+                    .prepare(`SELECT t.id, t.slice_id, t.milestone_id
+             FROM tasks t
+             LEFT JOIN slices s ON t.milestone_id = s.milestone_id AND t.slice_id = s.id
+             WHERE s.id IS NULL`)
+                    .all();
+                for (const row of orphanedTasks) {
+                    issues.push({
+                        severity: "error",
+                        code: "db_orphaned_task",
+                        scope: "task",
+                        unitId: `${row.milestone_id}/${row.slice_id}/${row.id}`,
+                        message: `Task ${row.id} references slice ${row.slice_id} in milestone ${row.milestone_id} but no such slice exists in the database`,
+                        fixable: false,
+                    });
+                }
+            }
+            catch {
+                // Non-fatal — orphaned task check failed
+            }
+            // b. Orphaned slices (slice.milestone_id points to non-existent milestone)
+            try {
+                const orphanedSlices = adapter
+                    .prepare(`SELECT s.id, s.milestone_id
+             FROM slices s
+             LEFT JOIN milestones m ON s.milestone_id = m.id
+             WHERE m.id IS NULL`)
+                    .all();
+                for (const row of orphanedSlices) {
+                    issues.push({
+                        severity: "error",
+                        code: "db_orphaned_slice",
+                        scope: "slice",
+                        unitId: `${row.milestone_id}/${row.id}`,
+                        message: `Slice ${row.id} references milestone ${row.milestone_id} but no such milestone exists in the database`,
+                        fixable: false,
+                    });
+                }
+            }
+            catch {
+                // Non-fatal — orphaned slice check failed
+            }
+            // c. Tasks marked complete without summaries
+            try {
+                const doneTasks = adapter
+                    .prepare(`SELECT id, slice_id, milestone_id FROM tasks
+             WHERE status = 'done' AND (summary IS NULL OR summary = '')`)
+                    .all();
+                for (const row of doneTasks) {
+                    issues.push({
+                        severity: "warning",
+                        code: "db_done_task_no_summary",
+                        scope: "task",
+                        unitId: `${row.milestone_id}/${row.slice_id}/${row.id}`,
+                        message: `Task ${row.id} is marked done but has no summary in the database`,
+                        fixable: false,
+                    });
+                }
+            }
+            catch {
+                // Non-fatal — done-task-no-summary check failed
+            }
+            // d. Duplicate entity IDs (safety check)
+            try {
+                const dupMilestones = adapter
+                    .prepare("SELECT id, COUNT(*) as cnt FROM milestones GROUP BY id HAVING cnt > 1")
+                    .all();
+                for (const row of dupMilestones) {
+                    issues.push({
+                        severity: "error",
+                        code: "db_duplicate_id",
+                        scope: "milestone",
+                        unitId: row.id,
+                        message: `Duplicate milestone ID "${row.id}" appears ${row.cnt} times in the database`,
+                        fixable: false,
+                    });
+                }
+                const dupSlices = adapter
+                    .prepare("SELECT id, milestone_id, COUNT(*) as cnt FROM slices GROUP BY id, milestone_id HAVING cnt > 1")
+                    .all();
+                for (const row of dupSlices) {
+                    issues.push({
+                        severity: "error",
+                        code: "db_duplicate_id",
+                        scope: "slice",
+                        unitId: `${row.milestone_id}/${row.id}`,
+                        message: `Duplicate slice ID "${row.id}" in milestone ${row.milestone_id} appears ${row.cnt} times`,
+                        fixable: false,
+                    });
+                }
+                const dupTasks = adapter
+                    .prepare("SELECT id, slice_id, milestone_id, COUNT(*) as cnt FROM tasks GROUP BY id, slice_id, milestone_id HAVING cnt > 1")
+                    .all();
+                for (const row of dupTasks) {
+                    issues.push({
+                        severity: "error",
+                        code: "db_duplicate_id",
+                        scope: "task",
+                        unitId: `${row.milestone_id}/${row.slice_id}/${row.id}`,
+                        message: `Duplicate task ID "${row.id}" in slice ${row.slice_id} appears ${row.cnt} times`,
+                        fixable: false,
+                    });
+                }
+            }
+            catch {
+                // Non-fatal — duplicate ID check failed
+            }
+        }
+    }
+    catch {
+        // Non-fatal — DB constraint checks failed entirely
+    }
+    // ── Projection drift detection ──────────────────────────────────────────
+    // If the DB is available, check whether markdown projections are stale
+    // relative to the event log and re-render them.
+    try {
+        if (isDbAvailable()) {
+            const eventLogPath = join(basePath, ".gsd", "event-log.jsonl");
+            const events = readEvents(eventLogPath);
+            if (events.length > 0) {
+                const lastEventTs = new Date(events[events.length - 1].ts).getTime();
+                const state = await deriveState(basePath);
+                for (const milestone of state.registry) {
+                    if (milestone.status === "complete")
+                        continue;
+                    const roadmapPath = resolveMilestoneFile(basePath, milestone.id, "ROADMAP");
+                    if (!roadmapPath || !existsSync(roadmapPath)) {
+                        try {
+                            await renderAllProjections(basePath, milestone.id);
+                            fixesApplied.push(`re-rendered missing projections for ${milestone.id}`);
+                        }
+                        catch {
+                            // Non-fatal — projection re-render failed
+                        }
+                        continue;
+                    }
+                    const projectionMtime = statSync(roadmapPath).mtimeMs;
+                    if (lastEventTs > projectionMtime) {
+                        try {
+                            await renderAllProjections(basePath, milestone.id);
+                            fixesApplied.push(`re-rendered stale projections for ${milestone.id}`);
+                        }
+                        catch {
+                            // Non-fatal — projection re-render failed
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch {
+        // Non-fatal — projection drift check must never block doctor
+    }
+}