gsd-pi 2.82.0 → 3.0.0-dev.04f5ccf82

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

@@ -45,6 +45,7 @@ function parsePhaseEntry(line) {
         let title = fmtPhaseColon[3].trim();
         // Strip trailing parentheticals, plan counts, and completion notes
         title = title.replace(/\s*\(\d+\/\d+\s+plans?\)/, '')
+            .replace(/\s*[—–]\s+.*$/, '') // strip em/en-dash description suffix
             .replace(/\s*--\s+.*$/, '')
             .replace(/\s*-\s+.*$/, '') // strip "- description" suffix
             .replace(/\s*\(completed.*\)$/i, '')
@@ -71,6 +72,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;
 }
 /**
@@ -120,7 +131,13 @@ export function parseOldRoadmap(content) {
         }
         return result;
     }
-    // ─── Strategy 2: Detect ## heading-sectioned milestones ───
+    // ─── Strategy 2: Detect ## Milestones summary + ### vN.N subsections ───
+    const summaryMilestones = parseMilestoneSummaryFormat(lines);
+    if (summaryMilestones.length > 0) {
+        result.milestones = summaryMilestones;
+        return result;
+    }
+    // ─── Strategy 3: Detect ## heading-sectioned milestones ───
     const milestoneHeadingRegex = /^##\s+(.+)$/;
     const milestoneHeadings = [];
     for (let i = 0; i < lines.length; i++) {
@@ -165,7 +182,7 @@ export function parseOldRoadmap(content) {
         }
     }
     else {
-        // ─── Strategy 3: Flat format — just extract all phase checkbox lines ───
+        // ─── Strategy 4: Flat format — just extract all phase checkbox lines ───
         for (const line of lines) {
             const entry = parsePhaseEntry(line.trim());
             if (entry) {
@@ -219,6 +236,108 @@ function parseDetailsBlockMilestones(lines) {
     }
     return milestones;
 }
+/**
+ * Parse a `## Milestones` summary section paired with `### vN.N ... (Phases N-M)` subsections.
+ * Returns empty array if not detected.
+ */
+function parseMilestoneSummaryFormat(lines) {
+    let milestoneSectionStart = -1;
+    let milestoneSectionEnd = lines.length;
+    for (let i = 0; i < lines.length; i++) {
+        if (/^##\s+Milestones?\s*$/i.test(lines[i].trim())) {
+            milestoneSectionStart = i + 1;
+            for (let j = i + 1; j < lines.length; j++) {
+                if (/^##\s+/.test(lines[j])) {
+                    milestoneSectionEnd = j;
+                    break;
+                }
+            }
+            break;
+        }
+    }
+    if (milestoneSectionStart === -1)
+        return [];
+    const summaryEntries = [];
+    for (let i = milestoneSectionStart; i < milestoneSectionEnd; i++) {
+        const line = lines[i].trim();
+        if (!line.startsWith('-'))
+            continue;
+        const stripped = line.replace(/\*\*/g, '');
+        const match = stripped.match(/^-\s+\[([ xX])\]\s+(?:Phase\s+)?\d+(?:\.\d+)?\s*:\s*(v[\d.]+)\s+(.+?)(?:\s*[—–]\s*Phases?\s+(\d+(?:\.\d+)?)\s*-\s*(\d+(?:\.\d+)?))?(?:\s*\(.*\))?\s*$/);
+        if (!match)
+            continue;
+        const id = match[2];
+        const titleSuffix = match[3]
+            .replace(/\s*[—–]\s*Phases?\s+\d+(?:\.\d+)?\s*-\s*\d+(?:\.\d+)?.*$/, '')
+            .replace(/\s*\(.*\)\s*$/, '')
+            .trim();
+        summaryEntries.push({
+            id,
+            title: `${id} ${titleSuffix}`.trim(),
+            done: match[1].toLowerCase() === 'x',
+            phaseStart: match[4] ? parseFloat(match[4]) : 0,
+            phaseEnd: match[5] ? parseFloat(match[5]) : 0,
+        });
+    }
+    if (summaryEntries.length === 0)
+        return [];
+    const subsectionPhases = new Map();
+    for (let i = 0; i < lines.length; i++) {
+        const headingMatch = lines[i].trim().match(/^###\s+(v[\d.]+)\s+(.+?)(?:\s*\(Phases?\s+[\d.]+\s*-\s*[\d.]+\))?\s*$/i);
+        if (!headingMatch)
+            continue;
+        const id = headingMatch[1];
+        const phases = [];
+        for (let j = i + 1; j < lines.length; j++) {
+            const sectionLine = lines[j].trim();
+            if (/^##\s+/.test(sectionLine) || /^###\s+/.test(sectionLine))
+                break;
+            const entry = parsePhaseEntry(sectionLine);
+            if (entry)
+                phases.push(entry);
+        }
+        if (phases.length > 0)
+            subsectionPhases.set(id, phases);
+    }
+    const milestones = [];
+    for (const entry of summaryEntries) {
+        const phases = subsectionPhases.get(entry.id);
+        if (phases && phases.length > 0) {
+            milestones.push({
+                id: entry.id,
+                title: entry.title,
+                collapsed: false,
+                phases,
+            });
+            continue;
+        }
+        if (entry.done && entry.phaseStart > 0 && entry.phaseEnd >= entry.phaseStart) {
+            const synthetic = [];
+            for (let n = entry.phaseStart; n <= entry.phaseEnd; n += 1) {
+                synthetic.push({
+                    number: n,
+                    title: `Phase ${n}`,
+                    done: true,
+                    raw: `synthetic:${entry.id}:${n}`,
+                });
+            }
+            milestones.push({
+                id: entry.id,
+                title: entry.title,
+                collapsed: false,
+                phases: synthetic,
+            });
+            continue;
+        }
+        milestones.push({
+            id: entry.id,
+            title: entry.title,
+            collapsed: false,
+            phases: [],
+        });
+    }
+    return milestones;
+}
 // ─── Plan Parser (XML-in-Markdown) ─────────────────────────────────────────
 /** Strip surrounding quotes from YAML string values */
 function unquote(val) {

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,

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

@@ -187,16 +187,48 @@ function normalizeStatus(status) {
         return 'validated';
     return 'active';
 }
+function normalizeRequirementId(id) {
+    const match = id.trim().match(/^R(\d+)$/i);
+    if (!match)
+        return null;
+    return `R${match[1].padStart(3, '0')}`;
+}
 function mapRequirements(reqs) {
     let autoId = 0;
+    const reservedIds = new Set(reqs
+        .map((req) => normalizeRequirementId(req.id))
+        .filter((id) => id !== null));
+    const usedIds = new Set();
+    function nextRequirementId() {
+        let id = '';
+        do {
+            autoId++;
+            id = padId('R', autoId, 3);
+        } while (usedIds.has(id) || reservedIds.has(id));
+        usedIds.add(id);
+        return id;
+    }
     return reqs.map((req) => {
-        autoId++;
+        const originalId = req.id.trim();
+        const canonicalId = normalizeRequirementId(originalId);
+        let id;
+        let description = req.description;
+        if (canonicalId && !usedIds.has(canonicalId)) {
+            id = canonicalId;
+            usedIds.add(id);
+        }
+        else {
+            id = nextRequirementId();
+            if (originalId) {
+                description = `Legacy ID: ${originalId}\n\n${description}`;
+            }
+        }
         return {
-            id: req.id && req.id.trim() !== '' ? req.id : padId('R', autoId, 3),
+            id,
             title: req.title,
             class: 'core-capability',
             status: normalizeStatus(req.status),
-            description: req.description,
+            description,
             source: 'inferred',
             primarySlice: 'none yet',
         };
@@ -233,7 +265,22 @@ function deriveDecisions(parsed) {
     }
     if (decisions.length === 0)
         return '';
-    return decisions.map((d) => `- ${d}`).join('\n');
+    const lines = [
+        '# Decisions Register',
+        '',
+        '<!-- Append-only. Never edit or remove existing rows.',
+        '     To reverse a decision, add a new row that supersedes it.',
+        '     Read this file at the start of any planning or research phase. -->',
+        '',
+        '| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |',
+        '|---|------|-------|----------|--------|-----------|------------|---------|',
+    ];
+    decisions.forEach((decision, index) => {
+        const id = padId('D', index + 1, 3);
+        const escaped = decision.replace(/\|/g, '\\|');
+        lines.push(`| ${id} | migration | migrated-summary | ${escaped} | ${escaped} | Migrated from legacy summary key-decisions | Yes | agent |`);
+    });
+    return lines.join('\n') + '\n';
 }
 // ─── Main Entry Point ──────────────────────────────────────────────────────
 export function transformToGSD(parsed) {

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

@@ -296,7 +296,17 @@ export function formatProject(content) {
  */
 export function formatDecisions(content) {
     if (!content || !content.trim()) {
-        return '# Decisions\n\n<!-- Append-only register of architectural and pattern decisions -->\n\n| ID | Decision | Rationale | Date |\n|----|----------|-----------|------|\n';
+        return [
+            '# Decisions Register',
+            '',
+            '<!-- Append-only. Never edit or remove existing rows.',
+            '     To reverse a decision, add a new row that supersedes it.',
+            '     Read this file at the start of any planning or research phase. -->',
+            '',
+            '| # | When | Scope | Decision | Choice | Rationale | Revisable? | Made By |',
+            '|---|------|-------|----------|--------|-----------|------------|---------|',
+            '',
+        ].join('\n');
     }
     return content.endsWith('\n') ? content : content + '\n';
 }

package/dist/resources/extensions/gsd/migration-auto-check.js

@@ -1,10 +1,8 @@
 import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
-import { clearEngineHierarchy, getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, transaction, } from "./gsd-db.js";
-import { migrateHierarchyToDb } from "./md-importer.js";
+import { getAllMilestones, getMilestoneSlices, getSliceTasks, isDbAvailable, } from "./gsd-db.js";
 import { parsePlan, parseRoadmap } from "./parsers-legacy.js";
 import { milestonesDir, resolveMilestoneFile, resolveSliceFile, } from "./paths.js";
-import { invalidateStateCache } from "./state.js";
 function zeroCounts() {
     return { milestones: 0, slices: 0, tasks: 0 };
 }
@@ -50,7 +48,7 @@ export function countDbHierarchy() {
     }
     return counts;
 }
-export async function autoImportMarkdownHierarchyIfDbMismatch(basePath) {
+export async function checkMarkdownHierarchyAgainstDb(basePath) {
     const markdown = countMarkdownHierarchy(basePath);
     if (sameCounts(markdown, zeroCounts())) {
         return {
@@ -70,18 +68,15 @@ export async function autoImportMarkdownHierarchyIfDbMismatch(basePath) {
         return { action: "none", reason: "in-sync", markdown, beforeDb, afterDb: beforeDb };
     }
     const reason = sameCounts(beforeDb, zeroCounts()) ? "db-empty" : "count-mismatch";
-    const imported = transaction(() => {
-        clearEngineHierarchy();
-        return migrateHierarchyToDb(basePath);
-    });
-    invalidateStateCache();
-    const afterDb = {
-        milestones: imported.milestones,
-        slices: imported.slices,
-        tasks: imported.tasks,
+    return {
+        action: "recovery-required",
+        reason,
+        markdown,
+        beforeDb,
+        afterDb: beforeDb,
+        recoveryCommand: "gsd recover",
+        message: `Markdown planning artifacts (${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T) ` +
+            `do not match the authoritative DB (${beforeDb.milestones}M/${beforeDb.slices}S/${beforeDb.tasks}T). ` +
+            "Runtime startup will not import markdown automatically; run explicit GSD recovery if markdown should repopulate the database.",
     };
-    if (!sameCounts(markdown, afterDb)) {
-        throw new Error(`migration auto-import verification failed: markdown ${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T, db ${afterDb.milestones}M/${afterDb.slices}S/${afterDb.tasks}T`);
-    }
-    return { action: "imported", reason, markdown, beforeDb, afterDb };
 }

package/dist/resources/extensions/gsd/milestone-actions.js

@@ -19,6 +19,7 @@ import { deleteMilestone, getMilestone, isDbAvailable, updateMilestoneStatus } f
 import { removeWorktree } from "./worktree-manager.js";
 import { logWarning } from "./workflow-logger.js";
 import { isAutoActive } from "./auto.js";
+import { isClosedStatus } from "./status-guards.js";
 /**
  * Writer-side assert for mutations that race with auto-mode's squash merge (#4704).
  * Auto-mode is confirmed not to call parkMilestone/discardMilestone/unparkMilestone
@@ -34,7 +35,7 @@ function assertNotAutoActive(action) {
 /**
  * Park a milestone — creates a PARKED.md marker file with reason and timestamp.
  * Parked milestones are skipped during active-milestone discovery but stay on disk.
- * Returns true if successfully parked, false if milestone not found or already parked.
+ * Returns true if successfully parked, false if milestone not found, already parked, or complete.
  */
 export function parkMilestone(basePath, milestoneId, reason) {
     assertNotAutoActive("park milestone");
@@ -42,9 +43,15 @@ export function parkMilestone(basePath, milestoneId, reason) {
     if (!mDir || !existsSync(mDir))
         return false;
     // Guard: do not park a completed milestone — it would corrupt depends_on satisfaction
-    const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
-    if (summaryFile)
+    const dbAvailable = isDbAvailable();
+    const milestone = dbAvailable ? getMilestone(milestoneId) : null;
+    if (milestone && isClosedStatus(milestone.status))
         return false;
+    if (!dbAvailable) {
+        const summaryFile = resolveMilestoneFile(basePath, milestoneId, "SUMMARY");
+        if (summaryFile)
+            return false;
+    }
     const parkedPath = join(mDir, buildMilestoneFileName(milestoneId, "PARKED"));
     if (existsSync(parkedPath))
         return false; // already parked
@@ -61,7 +68,7 @@ export function parkMilestone(basePath, milestoneId, reason) {
     ].join("\n");
     writeFileSync(parkedPath, content, "utf-8");
     // Sync DB status so deriveStateFromDb also skips this milestone (#2694)
-    if (isDbAvailable()) {
+    if (dbAvailable) {
         try {
             updateMilestoneStatus(milestoneId, "parked");
         }