gsd-pi 2.82.0 → 3.0.0-dev.2e8b124f7

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

@@ -14,7 +14,7 @@ import { isClosedStatus } from "./status-guards.js";
 import { join, relative } from "node:path";
 import { createRequire } from "node:module";
 import { getAllMilestones, getMilestone, getMilestoneSlices, getSliceTasks, getTask, getSlice, getArtifact, insertArtifact, getGateResults, } from "./gsd-db.js";
-import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksDir, gsdRoot, buildTaskFileName, buildSliceFileName, } from "./paths.js";
+import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, gsdProjectionRoot, gsdRoot, buildTaskFileName, buildSliceFileName, } from "./paths.js";
 import { saveFile, clearParseCache } from "./files.js";
 import { invalidateStateCache } from "./state.js";
 import { clearPathCache } from "./paths.js";
@@ -24,7 +24,11 @@ import { clearPathCache } from "./paths.js";
  * E.g. "/project/.gsd/milestones/M001/M001-ROADMAP.md" → "milestones/M001/M001-ROADMAP.md"
  */
 function toArtifactPath(absPath, basePath) {
-    const root = gsdRoot(basePath);
+    const projectionRoot = gsdProjectionRoot(basePath);
+    const projectionRel = relative(projectionRoot, absPath);
+    const root = projectionRel && !projectionRel.startsWith("..") && !projectionRel.startsWith("/")
+        ? projectionRoot
+        : gsdRoot(basePath);
     const rel = relative(root, absPath);
     // Normalize to forward slashes for consistent DB keys
     return rel.replace(/\\/g, "/");
@@ -112,7 +116,12 @@ function renderRoadmapMarkdown(milestone, slices) {
     for (const slice of slices) {
         const done = isClosedStatus(slice.status) ? "x" : " ";
         const depends = `[${(slice.depends ?? []).join(",")}]`;
-        lines.push(`- [${done}] **${slice.id}: ${slice.title}** \`risk:${slice.risk}\` \`depends:${depends}\``);
+        // ADR-011: sketch slices get a `[sketch]` badge so the roadmap shows at a
+        // glance which slices are still pending refine-slice expansion. The badge
+        // sits in front of `risk:` so it's visible in narrow terminals that may
+        // truncate the line.
+        const sketchBadge = slice.is_sketch === 1 ? "`[sketch]` " : "";
+        lines.push(`- [${done}] **${slice.id}: ${slice.title}** ${sketchBadge}\`risk:${slice.risk}\` \`depends:${depends}\``);
         lines.push(`  > After this: ${slice.demo}`);
         lines.push("");
     }
@@ -300,10 +309,9 @@ export async function renderPlanFromDb(basePath, milestoneId, sliceId) {
     if (tasks.length === 0) {
         throw new Error(`no tasks found for ${milestoneId}/${sliceId}`);
     }
-    const slicePath = resolveSlicePath(basePath, milestoneId, sliceId)
-        ?? join(gsdRoot(basePath), "milestones", milestoneId, "slices", sliceId);
-    const absPath = resolveSliceFile(basePath, milestoneId, sliceId, "PLAN")
-        ?? join(slicePath, `${sliceId}-PLAN.md`);
+    const slicePath = join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId);
+    mkdirSync(slicePath, { recursive: true });
+    const absPath = join(slicePath, `${sliceId}-PLAN.md`);
     const artifactPath = toArtifactPath(absPath, basePath);
     const sliceGates = getGateResults(milestoneId, sliceId, "slice");
     const content = renderSlicePlanMarkdown(slice, tasks, sliceGates);
@@ -324,8 +332,7 @@ export async function renderTaskPlanFromDb(basePath, milestoneId, sliceId, taskI
     if (!task) {
         throw new Error(`task ${milestoneId}/${sliceId}/${taskId} not found`);
     }
-    const tasksDir = resolveTasksDir(basePath, milestoneId, sliceId)
-        ?? join(gsdRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks");
+    const tasksDir = join(gsdProjectionRoot(basePath), "milestones", milestoneId, "slices", sliceId, "tasks");
     mkdirSync(tasksDir, { recursive: true });
     const absPath = join(tasksDir, buildTaskFileName(taskId, "PLAN"));
     const artifactPath = toArtifactPath(absPath, basePath);
@@ -605,13 +612,14 @@ export function detectStaleRenders(basePath) {
     const _require = createRequire(import.meta.url);
     let parseRoadmap, parsePlan;
     try {
-        const m = _require("./parsers-legacy.ts");
+        // Prefer compiled JS for packaged/runtime installs; TS exists only in source/dev contexts.
+        const m = _require("./parsers-legacy.js");
         parseRoadmap = m.parseRoadmap;
         parsePlan = m.parsePlan;
     }
     catch (e) {
-        logWarning("renderer", `parsers-legacy.ts require failed, falling back to .js: ${e.message}`);
-        const m = _require("./parsers-legacy.js");
+        logWarning("renderer", `parsers-legacy.js require failed, falling back to .ts: ${e.message}`);
+        const m = _require("./parsers-legacy.ts");
         parseRoadmap = m.parseRoadmap;
         parsePlan = m.parsePlan;
     }

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

@@ -0,0 +1,58 @@
+import { existsSync, readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { resolveModelMcpConfig } from "./preferences-mcp.js";
+export function discoverMcpServerNames(projectDir) {
+    const mcpJsonPath = resolve(projectDir, ".mcp.json");
+    const settingsPath = resolve(projectDir, ".claude", "settings.json");
+    let mcpJsonServers = [];
+    if (existsSync(mcpJsonPath)) {
+        const raw = readFileSync(mcpJsonPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        mcpJsonServers = Object.keys(parsed.mcpServers ?? {});
+    }
+    let settingsServers = [];
+    if (existsSync(settingsPath)) {
+        try {
+            const raw = readFileSync(settingsPath, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (parsed.mcpServers) {
+                settingsServers = Object.keys(parsed.mcpServers);
+            }
+        }
+        catch {
+            // settings.json parse errors are silently ignored
+        }
+    }
+    return [...new Set([...mcpJsonServers, ...settingsServers])];
+}
+export function computeMcpDisallowedTools(modelId, mcpConfig, discoveredServers, workflowServerName) {
+    if (!mcpConfig)
+        return [];
+    const entry = resolveModelMcpConfig(modelId, mcpConfig);
+    if (!entry)
+        return [];
+    const allServers = [...discoveredServers, ...(workflowServerName ? [workflowServerName] : [])];
+    const blocked = new Set();
+    // Allowlist phase: block every server NOT in the allowlist (except workflowServerName)
+    if (entry.allowed_servers !== undefined) {
+        const allowSet = new Set(entry.allowed_servers);
+        for (const server of allServers) {
+            if (server === workflowServerName)
+                continue;
+            if (!allowSet.has(server)) {
+                blocked.add(server);
+            }
+        }
+    }
+    // Blocklist phase: explicitly blocked servers are added
+    if (entry.blocked_servers !== undefined) {
+        for (const server of entry.blocked_servers) {
+            blocked.add(server);
+        }
+    }
+    // gsd-workflow implicit allow: remove unless explicitly in blocked_servers
+    if (workflowServerName && !(entry.blocked_servers ?? []).includes(workflowServerName)) {
+        blocked.delete(workflowServerName);
+    }
+    return [...blocked].map((name) => `mcp__${name}__*`);
+}

package/dist/resources/extensions/gsd/md-importer.js

@@ -256,7 +256,7 @@ function importRequirements(gsdDir) {
 }
 // ─── Hierarchy Artifact Walker ─────────────────────────────────────────────
 /** Artifact suffixes to look for at each hierarchy level */
-const MILESTONE_SUFFIXES = ['ROADMAP', 'CONTEXT', 'RESEARCH', 'ASSESSMENT'];
+const MILESTONE_SUFFIXES = ['ROADMAP', 'CONTEXT', 'RESEARCH', 'ASSESSMENT', 'SUMMARY', 'VALIDATION'];
 const SLICE_SUFFIXES = ['PLAN', 'SUMMARY', 'RESEARCH', 'CONTEXT', 'ASSESSMENT', 'UAT'];
 const TASK_SUFFIXES = ['PLAN', 'SUMMARY', 'CONTINUE', 'CONTEXT', 'RESEARCH'];
 /**

package/dist/resources/extensions/gsd/memory-backfill.js

@@ -1,9 +1,10 @@
 // GSD2 — Decisions -> memories backfill (ADR-013 step 5)
 //
-// Idempotent one-shot migration that copies every active decisions row into
-// the memories table with category="architecture" and a structured_fields
-// payload preserving the original gsd_save_decision schema (when_context,
-// scope, decision, choice, rationale, made_by, revisable, sourceDecisionId).
+// Idempotent migration that copies every decisions row (active and
+// superseded — see Stage 2a note below) into the memories table with
+// category="architecture" and a structured_fields payload preserving the
+// original gsd_save_decision schema (when_context, scope, decision, choice,
+// rationale, made_by, revisable, superseded_by, sourceDecisionId).
 //
 // The backfill exists so the cutover in ADR-013 step 6 can drop the
 // decisions table without losing schema fidelity. Idempotency is enforced
@@ -14,11 +15,18 @@
 // only ever fires once per project. Costs O(N) inserts on first run where
 // N is the active-decisions count; subsequent runs are an O(N) lookup that
 // finds existing markers and exits.
+//
+// ADR-013 Stage 2a (PR #5755): backfill now includes superseded rows so the
+// DECISIONS.md projection regen can source from memories without losing
+// historical entries. An auto-heal pass runs after the initial migration to
+// pick up superseded_by changes that occurred after the source decision was
+// already migrated (e.g. a fresh md-importer run that introduced a new
+// supersedes-chain).
 import { isDbAvailable, _getAdapter } from "./gsd-db.js";
 import { createMemory } from "./memory-store.js";
 import { logWarning } from "./workflow-logger.js";
 /**
- * Backfill active decisions rows into the memories table.
+ * Backfill decisions rows into the memories table.
  *
  * - Idempotent (per-row): every row written carries
  *   `structured_fields.sourceDecisionId = "<decisionId>"`. Each candidate
@@ -27,13 +35,18 @@ import { logWarning } from "./workflow-logger.js";
  *   their own `sourceDecisionId` does NOT abort the backfill.
  * - Best-effort: never throws. Logs and returns 0 on failure so a broken
  *   backfill cannot block agent startup.
- * - Active-only: skips rows where `superseded_by IS NOT NULL`. Superseded
- *   decisions are historical record; the memory store is for active
- *   knowledge.
+ * - Full migration (ADR-013 Stage 2a): both active and superseded rows are
+ *   migrated. `structured_fields.superseded_by` preserves the supersedes
+ *   chain so the DECISIONS.md projection regen can source from memories
+ *   without losing historical entries.
+ * - Drift auto-heal: after the initial insert pass, the function updates
+ *   any pre-existing memory whose `structured_fields.superseded_by` drifted
+ *   from the source decision (e.g. a fresh md-importer run introduced a
+ *   new supersedes annotation after the initial migration).
  *
  * Returns the number of memories written (0 when already backfilled or
- * when the DB has no decisions). Callers can log the result or surface it
- * to the user.
+ * when the DB has no decisions). Drift-heal updates are not counted in
+ * this return — they are logged separately.
  */
 export function backfillDecisionsToMemories() {
     if (!isDbAvailable())
@@ -43,7 +56,7 @@ export function backfillDecisionsToMemories() {
         return 0;
     try {
         const decisions = adapter
-            .prepare("SELECT id, when_context, scope, decision, choice, rationale, made_by, revisable, superseded_by FROM decisions WHERE superseded_by IS NULL")
+            .prepare("SELECT id, when_context, scope, decision, choice, rationale, made_by, revisable, superseded_by FROM decisions ORDER BY seq")
             .all();
         if (decisions.length === 0)
             return 0;
@@ -52,8 +65,10 @@ export function backfillDecisionsToMemories() {
         // per row by matching that exact id, NOT by a global sentinel — a global
         // sentinel would silently abort the backfill if a user manually called
         // capture_thought with their own structuredFields.sourceDecisionId.
-        const checkExisting = adapter.prepare("SELECT 1 FROM memories WHERE structured_fields LIKE :pattern LIMIT 1");
+        const checkExisting = adapter.prepare("SELECT id, structured_fields FROM memories WHERE structured_fields LIKE :pattern LIMIT 1");
+        const updateStructuredFields = adapter.prepare("UPDATE memories SET structured_fields = :sf, updated_at = :ts WHERE id = :id");
         let written = 0;
+        let healed = 0;
         for (const raw of decisions) {
             const row = {
                 id: String(raw["id"] ?? ""),
@@ -68,11 +83,40 @@ export function backfillDecisionsToMemories() {
             };
             if (!row.id)
                 continue;
-            // Pattern is anchored to the JSON-stringified shape and the exact
-            // decision id to avoid prefix collisions (e.g. "D1" vs "D10").
-            if (checkExisting.get({ ":pattern": `%"sourceDecisionId":"${row.id}"%` }))
+            const pattern = `%"sourceDecisionId":"${row.id}"%`;
+            const existing = checkExisting.get({ ":pattern": pattern });
+            if (existing) {
+                // Drift auto-heal: if the source decision's superseded_by has changed
+                // since the original migration, update the memory in place. Read-side
+                // queries reconstruct Decision.superseded_by from this field, so the
+                // DECISIONS.md projection stays accurate without us having to track
+                // supersedes events at the write site.
+                const parsedSf = existing.structured_fields
+                    ? safeParse(existing.structured_fields)
+                    : {};
+                if (existing.structured_fields && !parsedSf) {
+                    logWarning("memory-backfill", `decisions->memories drift heal skipped for ${row.id}: invalid structured_fields JSON`);
+                    continue;
+                }
+                const currentSf = parsedSf ?? {};
+                const memorySuperseded = typeof currentSf["superseded_by"] === "string" || currentSf["superseded_by"] === null
+                    ? currentSf["superseded_by"]
+                    : null;
+                if (memorySuperseded !== row.superseded_by) {
+                    const merged = {
+                        ...currentSf,
+                        superseded_by: row.superseded_by,
+                    };
+                    updateStructuredFields.run({
+                        ":id": existing.id,
+                        ":sf": JSON.stringify(merged),
+                        ":ts": new Date().toISOString(),
+                    });
+                    healed += 1;
+                }
                 continue;
-            const content = synthesizeContent(row);
+            }
+            const content = synthesizeDecisionMemoryContent(row);
             const id = createMemory({
                 category: "architecture",
                 content,
@@ -87,11 +131,15 @@ export function backfillDecisionsToMemories() {
                     rationale: row.rationale,
                     made_by: row.made_by,
                     revisable: row.revisable,
+                    superseded_by: row.superseded_by,
                 },
             });
             if (id)
                 written += 1;
         }
+        if (healed > 0) {
+            logWarning("memory-backfill", `decisions->memories drift healed: ${healed} row${healed === 1 ? "" : "s"} updated superseded_by`);
+        }
         return written;
     }
     catch (e) {
@@ -99,6 +147,14 @@ export function backfillDecisionsToMemories() {
         return 0;
     }
 }
+function safeParse(raw) {
+    try {
+        return JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Combine the decision's structured fields into a 1-3 sentence content
  * string suitable for keyword retrieval and human review.
@@ -107,7 +163,7 @@ export function backfillDecisionsToMemories() {
  * Truncates each field to keep the synthesized line under ~600 chars so
  * memory_query rendering stays readable.
  */
-function synthesizeContent(row) {
+export function synthesizeDecisionMemoryContent(row) {
     const trim = (value, max) => {
         const cleaned = value.replace(/\s+/g, " ").trim();
         return cleaned.length > max ? cleaned.slice(0, max - 1) + "\u2026" : cleaned;

package/dist/resources/extensions/gsd/memory-consolidation-scanner.js

@@ -0,0 +1,222 @@
+// GSD-2 — ADR-013 Phase 6 preflight scanner.
+//
+// Read-only detection of rows in the legacy knowledge surfaces (decisions
+// table, `.gsd/KNOWLEDGE.md`) that lack a corresponding `memories` row.
+// Runs on session start (and on demand via doctor); never mutates state.
+//
+// The scanner exists so the destructive Phase 6 cutover (#5755) can prove
+// the migration is complete before any tables are dropped. Today's
+// `backfillDecisionsToMemories` writes a `structured_fields.sourceDecisionId`
+// marker on each migrated row; the scanner uses that marker for decisions
+// detection. A `sourceKnowledgeId` marker is reserved for the parallel
+// KNOWLEDGE.md backfill that Phase 6 will introduce — until that ships,
+// every KNOWLEDGE.md row is reported as unmigrated, which is the honest
+// state of the consolidation.
+import { existsSync, readFileSync } from "node:fs";
+import { _getAdapter, isDbAvailable } from "./gsd-db.js";
+import { appendNotification } from "./notification-store.js";
+import { resolveGsdRootFile } from "./paths.js";
+import { logWarning } from "./workflow-logger.js";
+// ─── KNOWLEDGE.md parsing ────────────────────────────────────────────────────
+const KNOWLEDGE_SECTIONS = [
+    { table: "rules", heading: "## Rules", idPrefix: "K" },
+    { table: "patterns", heading: "## Patterns", idPrefix: "P" },
+    { table: "lessons", heading: "## Lessons Learned", idPrefix: "L" },
+];
+/**
+ * Parse `.gsd/KNOWLEDGE.md` into rows, one per table entry. Skips the table
+ * header and separator lines; ignores rows from unrecognized sections.
+ *
+ * The format is locked in `files.ts:appendKnowledge` — three `## ` sections
+ * (Rules, Patterns, Lessons Learned), each a Markdown table. Row IDs are
+ * `K###` / `P###` / `L###`.
+ */
+export function parseKnowledgeRows(content) {
+    const rows = [];
+    if (!content.trim())
+        return rows;
+    // Slice the content into sections by heading. The leading text before the
+    // first ## heading is intro prose — ignored.
+    const lines = content.split("\n");
+    let activeSection;
+    for (const line of lines) {
+        const trimmed = line.trim();
+        if (trimmed.startsWith("## ")) {
+            activeSection = KNOWLEDGE_SECTIONS.find((s) => s.heading === trimmed);
+            continue;
+        }
+        if (!activeSection)
+            continue;
+        if (!trimmed.startsWith("|"))
+            continue;
+        // Skip the table header rows: the column-titles line and the |---|---| separator.
+        // Real data rows start with `| <prefix>### |`.
+        const idMatch = new RegExp(`^\\|\\s*(${activeSection.idPrefix}\\d+)\\s*\\|`).exec(trimmed);
+        if (!idMatch)
+            continue;
+        rows.push({
+            table: activeSection.table,
+            id: idMatch[1] ?? "",
+            row: trimmed,
+        });
+    }
+    return rows;
+}
+function knowledgeMdContent(basePath) {
+    const path = resolveGsdRootFile(basePath, "KNOWLEDGE");
+    if (!existsSync(path))
+        return "";
+    try {
+        return readFileSync(path, "utf-8");
+    }
+    catch {
+        return "";
+    }
+}
+function getActiveDecisions() {
+    if (!isDbAvailable())
+        return [];
+    const adapter = _getAdapter();
+    if (!adapter)
+        return [];
+    try {
+        const rows = adapter
+            .prepare("SELECT id, decision FROM decisions WHERE superseded_by IS NULL")
+            .all();
+        return rows
+            .map((row) => ({
+            id: String(row["id"] ?? ""),
+            decision: String(row["decision"] ?? ""),
+        }))
+            .filter((row) => row.id.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * True when a memory row has a `structured_fields` JSON payload containing
+ * the given `markerKey: "value"` pair. Matches the LIKE pattern used by
+ * `backfillDecisionsToMemories` so the scanner is consistent with the
+ * backfill's idempotency check.
+ */
+function memoryHasSourceMarker(markerKey, value) {
+    if (!isDbAvailable())
+        return false;
+    const adapter = _getAdapter();
+    if (!adapter)
+        return false;
+    try {
+        const pattern = `%"${markerKey}":"${value}"%`;
+        const row = adapter
+            .prepare("SELECT 1 FROM memories WHERE structured_fields LIKE :pattern LIMIT 1")
+            .get({ ":pattern": pattern });
+        return row !== undefined;
+    }
+    catch {
+        return false;
+    }
+}
+// ─── Public API ──────────────────────────────────────────────────────────────
+const SAMPLE_LIMIT = 5;
+/**
+ * Scan the legacy knowledge surfaces and return a structured report of what's
+ * already in the `memories` table vs what's still unmigrated. Pure detection
+ * — no DB writes, no file writes, no notifications.
+ */
+export function scanConsolidationGaps(basePath) {
+    // ── Decisions ────────────────────────────────────────────────────────
+    const decisions = getActiveDecisions();
+    const decisionSamples = [];
+    let decisionMigrated = 0;
+    for (const decision of decisions) {
+        if (memoryHasSourceMarker("sourceDecisionId", decision.id)) {
+            decisionMigrated += 1;
+            continue;
+        }
+        if (decisionSamples.length < SAMPLE_LIMIT) {
+            decisionSamples.push({
+                id: decision.id,
+                decision: decision.decision.length > 80 ? decision.decision.slice(0, 79) + "…" : decision.decision,
+            });
+        }
+    }
+    // ── KNOWLEDGE.md ─────────────────────────────────────────────────────
+    const knowledgeRows = parseKnowledgeRows(knowledgeMdContent(basePath));
+    const knowledgeByTable = { rules: 0, patterns: 0, lessons: 0 };
+    const knowledgeSamples = [];
+    let knowledgeMigrated = 0;
+    for (const row of knowledgeRows) {
+        knowledgeByTable[row.table] += 1;
+        // Phase 6 will introduce a `sourceKnowledgeId` marker as part of the
+        // KNOWLEDGE.md backfill. Until that path ships, this check returns
+        // false for every row, which is the honest state of the consolidation.
+        if (memoryHasSourceMarker("sourceKnowledgeId", row.id)) {
+            knowledgeMigrated += 1;
+            continue;
+        }
+        if (knowledgeSamples.length < SAMPLE_LIMIT) {
+            knowledgeSamples.push({
+                table: row.table,
+                id: row.id,
+                row: row.row.length > 100 ? row.row.slice(0, 99) + "…" : row.row,
+            });
+        }
+    }
+    const decisionsReport = {
+        total: decisions.length,
+        migrated: decisionMigrated,
+        unmigrated: decisions.length - decisionMigrated,
+        samples: decisionSamples,
+    };
+    const knowledgeReport = {
+        total: knowledgeRows.length,
+        migrated: knowledgeMigrated,
+        unmigrated: knowledgeRows.length - knowledgeMigrated,
+        byTable: knowledgeByTable,
+        samples: knowledgeSamples,
+    };
+    const totalGaps = decisionsReport.unmigrated + knowledgeReport.unmigrated;
+    // Summary line is intentionally short so it fits in a single notification
+    // (notification-store truncates messages over 500 chars). Detail is
+    // accessible via getProviderSwitchStats-style callers, not embedded here.
+    const parts = [];
+    if (decisionsReport.unmigrated > 0) {
+        parts.push(`${decisionsReport.unmigrated} of ${decisionsReport.total} active decisions`);
+    }
+    if (knowledgeReport.unmigrated > 0) {
+        parts.push(`${knowledgeReport.unmigrated} of ${knowledgeReport.total} KNOWLEDGE.md rows`);
+    }
+    const summary = parts.length === 0
+        ? "Memory consolidation: all decisions and KNOWLEDGE.md rows are in memories."
+        : `Memory consolidation: ${parts.join(" and ")} not yet in memories table. Run /doctor for details.`;
+    return { decisions: decisionsReport, knowledge: knowledgeReport, totalGaps, summary };
+}
+/**
+ * Run the scanner and emit a persistent notification + workflow-logger
+ * warning when gaps exist. Best-effort: never throws; a broken scanner
+ * cannot block agent startup.
+ *
+ * Returns the full {@link ConsolidationGapReport} regardless of whether gaps
+ * exist (including when `totalGaps === 0`). Returns `null` only when
+ * `scanConsolidationGaps` itself throws. `appendNotification` and
+ * `logWarning` are called only when `report.totalGaps > 0`.
+ *
+ * Idempotent at the surface: the notification store applies its own
+ * 30-second dedup window keyed on (severity, source, message), so repeated
+ * boots with identical gaps produce one notification, not a flood.
+ */
+export function reportConsolidationGaps(basePath) {
+    try {
+        const report = scanConsolidationGaps(basePath);
+        if (report.totalGaps === 0)
+            return report;
+        appendNotification(report.summary, "warning", "workflow-logger");
+        logWarning("memory-consolidation", report.summary);
+        return report;
+    }
+    catch (e) {
+        logWarning("memory-consolidation", `scanner failed: ${e.message}`);
+        return null;
+    }
+}

package/dist/resources/extensions/gsd/migrate/command.js

@@ -21,6 +21,9 @@ import { migrateFromMarkdown } from "../md-importer.js";
 import { invalidateStateCache } from "../state.js";
 function assertMigrationImportMatchesPreview(imported, preview) {
     const mismatches = [];
+    if (imported.decisions !== preview.decisions.total) {
+        mismatches.push(`decisions ${imported.decisions}/${preview.decisions.total}`);
+    }
     if (imported.hierarchy.milestones !== preview.milestoneCount) {
         mismatches.push(`milestones ${imported.hierarchy.milestones}/${preview.milestoneCount}`);
     }
@@ -55,6 +58,7 @@ export async function importWrittenMigrationToDb(basePath, preview) {
 /** Format preview stats for embedding in the review prompt. */
 function formatPreviewStats(preview) {
     const lines = [
+        `- Decisions: ${preview.decisions.total}`,
         `- Milestones: ${preview.milestoneCount}`,
         `- Slices: ${preview.totalSlices} (${preview.doneSlices} done — ${preview.sliceCompletionPct}%)`,
         `- Tasks: ${preview.totalTasks} (${preview.doneTasks} done — ${preview.taskCompletionPct}%)`,
@@ -124,6 +128,7 @@ export async function handleMigrate(args, ctx, pi) {
     const preview = generatePreview(project);
     // ── Build preview text ─────────────────────────────────────────────────────
     const lines = [
+        `Decisions: ${preview.decisions.total}`,
         `Milestones: ${preview.milestoneCount}`,
         `Slices: ${preview.totalSlices} (${preview.doneSlices} done — ${preview.sliceCompletionPct}%)`,
         `Tasks: ${preview.totalTasks} (${preview.doneTasks} done — ${preview.taskCompletionPct}%)`,

package/dist/resources/extensions/gsd/migrate/parsers.js

@@ -71,6 +71,16 @@ function parsePhaseEntry(line) {
             raw: line,
         };
     }
+    // Format 3: - ✅ v1.0 MVP — Phases 1-6
+    const fmtVersionPhases = stripped.match(/^-\s+([✅🚧])\s+v\d+(?:\.\d+)*\s+(.+?)\s*[—–]\s*Phases?\s+(\d+(?:\.\d+)?)(?:\s*-\s*\d+(?:\.\d+)?)?(?:\s+\(.*\))?\s*$/iu);
+    if (fmtVersionPhases) {
+        return {
+            number: parseFloat(fmtVersionPhases[3]),
+            title: fmtVersionPhases[2].trim(),
+            done: fmtVersionPhases[1] === '✅',
+            raw: line,
+        };
+    }
     return null;
 }
 /**

package/dist/resources/extensions/gsd/migrate/preview.js

@@ -1,5 +1,11 @@
 // GSD Migration Preview — Pre-write statistics
 // Pure function, no I/O. Computes counts from a GSDProject.
+function countCanonicalDecisionRows(content) {
+    return content
+        .split('\n')
+        .filter((line) => /^\|\s*D\d+\s*\|/.test(line.trim()))
+        .length;
+}
 /**
  * Compute pre-write statistics from a GSDProject without performing I/O.
  * Used to show the user what a migration will produce before writing anything.
@@ -35,6 +41,9 @@ export function generatePreview(project) {
         reqCounts.total++;
     }
     return {
+        decisions: {
+            total: countCanonicalDecisionRows(project.decisionsContent),
+        },
         milestoneCount: project.milestones.length,
         totalSlices,
         totalTasks,