@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

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

@@ -1,14 +1,37 @@
-import { existsSync, readFileSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 import { isGsdBrowserMcpServerConfig } from "../shared/gsd-browser-cli.js";
 import { toMcpWildcardToolName } from "./mcp-tool-name.js";
 import { resolveModelMcpConfig } from "./preferences-mcp.js";
+const projectMcpDiscoveryCache = new Map();
 function isRecord(value) {
     return !!value && typeof value === "object" && !Array.isArray(value);
 }
-function readJsonFile(path, ignoreParseErrors = false) {
-    if (!existsSync(path))
+function getJsonFileSignature(path, ignoreAccessErrors = false) {
+    try {
+        const stats = statSync(path);
+        return { exists: true, mtimeMs: stats.mtimeMs, size: stats.size };
+    }
+    catch (err) {
+        const code = isRecord(err) ? err.code : undefined;
+        if (code === "ENOENT" || code === "ENOTDIR" || ignoreAccessErrors)
+            return { exists: false };
+        throw err;
+    }
+}
+function jsonFileSignaturesEqual(a, b) {
+    if (a.length !== b.length)
+        return false;
+    return a.every((signature, index) => {
+        const other = b[index];
+        return signature.exists === other.exists
+            && signature.mtimeMs === other.mtimeMs
+            && signature.size === other.size;
+    });
+}
+function readJsonFile(path, ignoreParseErrors = false, signature = getJsonFileSignature(path, ignoreParseErrors)) {
+    if (!signature.exists)
         return undefined;
     try {
         return JSON.parse(readFileSync(path, "utf-8"));
@@ -25,12 +48,22 @@ function collectServerEntries(servers) {
     return Object.entries(servers).map(([name, config]) => ({ name, config }));
 }
 export function discoverMcpServers(projectDir) {
-    const mcpJsonPath = resolve(projectDir, ".mcp.json");
-    const settingsPath = resolve(projectDir, ".claude", "settings.json");
-    const localSettingsPath = resolve(projectDir, ".claude", "settings.local.json");
-    const mcpJson = readJsonFile(mcpJsonPath);
-    const settings = readJsonFile(settingsPath, true);
-    const localSettings = readJsonFile(localSettingsPath, true);
+    const resolvedProjectDir = resolve(projectDir);
+    const mcpJsonPath = resolve(resolvedProjectDir, ".mcp.json");
+    const settingsPath = resolve(resolvedProjectDir, ".claude", "settings.json");
+    const localSettingsPath = resolve(resolvedProjectDir, ".claude", "settings.local.json");
+    const signatures = [
+        getJsonFileSignature(mcpJsonPath, true),
+        getJsonFileSignature(settingsPath, true),
+        getJsonFileSignature(localSettingsPath, true),
+    ];
+    const cached = projectMcpDiscoveryCache.get(resolvedProjectDir);
+    if (cached && jsonFileSignaturesEqual(cached.signatures, signatures)) {
+        return [...cached.servers];
+    }
+    const mcpJson = readJsonFile(mcpJsonPath, false, signatures[0]);
+    const settings = readJsonFile(settingsPath, true, signatures[1]);
+    const localSettings = readJsonFile(localSettingsPath, true, signatures[2]);
     const seen = new Set();
     const discovered = [];
     for (const entry of [
@@ -44,7 +77,8 @@ export function discoverMcpServers(projectDir) {
         seen.add(entry.name);
         discovered.push(entry);
     }
-    return discovered;
+    projectMcpDiscoveryCache.set(resolvedProjectDir, { signatures, servers: discovered });
+    return [...discovered];
 }
 function isWorkflowMcpServerConfig(config) {
     if (!isRecord(config))

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

@@ -4,11 +4,12 @@
 //
 // Exports: parseDecisionsTable, parseRequirementsSections, migrateFromMarkdown
 import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
-import { join } from 'node:path';
+import { join, basename } from 'node:path';
 import { upsertDecision, upsertRequirement, insertArtifact, insertMilestone, insertSlice, insertTask, transaction, updateMilestoneStatus, updateSliceStatus, _getAdapter, } from './gsd-db.js';
 import { openWorkflowDatabasePath } from './db-workspace.js';
-import { resolveGsdRootFile, resolveMilestoneFile, resolveSliceFile, resolveTasksDir, milestonesDir, gsdRoot, resolveTaskFiles, } from './paths.js';
+import { resolveGsdRootFile, resolveMilestoneFile, resolveSliceFile, resolveTasksDir, legacyMilestonesDir, gsdRoot, resolveTaskFiles, resolveMilestonePath, } from './paths.js';
 import { findMilestoneIds } from './guided-flow.js';
+import { milestoneIdToPhaseNum } from './layout-policy.js';
 import { parseRoadmap, parsePlan } from './parsers-legacy.js';
 import { parseContextDependsOn } from './files.js';
 import { logWarning } from './workflow-logger.js';
@@ -278,7 +279,7 @@ function importRequirements(gsdDir) {
 // ─── Hierarchy Artifact Walker ─────────────────────────────────────────────
 /** Artifact suffixes to look for at each hierarchy level */
 const MILESTONE_SUFFIXES = ['ROADMAP', 'CONTEXT', 'RESEARCH', 'ASSESSMENT', 'SUMMARY', 'VALIDATION'];
-const SLICE_SUFFIXES = ['PLAN', 'SUMMARY', 'RESEARCH', 'CONTEXT', 'ASSESSMENT', 'UAT'];
+const SLICE_SUFFIXES = ['PLAN', 'SUMMARY', 'RESEARCH', 'CONTEXT', 'CONTEXT-DRAFT', 'ASSESSMENT', 'UAT', 'CONTINUE'];
 const TASK_SUFFIXES = ['PLAN', 'SUMMARY', 'CONTINUE', 'CONTEXT', 'RESEARCH'];
 /**
  * Import hierarchy artifacts (roadmaps, plans, summaries, etc.) from the .gsd/ tree.
@@ -305,55 +306,151 @@ function importHierarchyArtifacts(gsdDir) {
             count++;
         }
     }
-    // Walk milestones
+    // Walk phases (flat-phase layout: phases/NN-slug/, legacy: milestones/M001/)
     const milestoneIds = findMilestoneIds(gsdDir);
-    const msDir = milestonesDir(gsdDir);
+    const legacyDir = legacyMilestonesDir(gsdDir);
     for (const milestoneId of milestoneIds) {
-        // Find the actual milestone directory name (handles legacy naming)
-        const milestoneDirName = findDirByPrefix(msDir, milestoneId);
-        if (!milestoneDirName)
+        // Use resolveMilestonePath so canonical-name / newest-dir selection matches
+        // the same logic used by the renderer and reconciler, preventing import and
+        // render from landing on different phase trees for the same milestone.
+        const resolvedPhaseFullPath = resolveMilestonePath(gsdDir, milestoneId);
+        if (!resolvedPhaseFullPath) {
+            // Last resort: findDirByPrefix for legacy dirs
+            const milestoneDirName = findDirByPrefix(legacyDir, milestoneId);
+            if (!milestoneDirName)
+                continue;
+            count += importLegacyMilestoneArtifacts(join(legacyDir, milestoneDirName), milestoneDirName, milestoneId);
             continue;
-        const milestoneFullPath = join(msDir, milestoneDirName);
-        // Milestone-level files
-        count += importFilesAtLevel(milestoneFullPath, milestoneId, MILESTONE_SUFFIXES, `milestones/${milestoneDirName}`, milestoneId, null, null);
-        // Walk slices
-        const slicesDir = join(milestoneFullPath, 'slices');
-        if (!existsSync(slicesDir))
+        }
+        // Determine if this is a legacy (milestones/) or flat-phase (phases/) dir.
+        const legacyDirNorm = legacyDir.replace(/\\/g, "/");
+        const resolvedNorm = resolvedPhaseFullPath.replace(/\\/g, "/");
+        const isLegacyResolved = resolvedNorm.startsWith(legacyDirNorm + "/") || resolvedNorm === legacyDirNorm;
+        const phaseDirName = basename(resolvedPhaseFullPath);
+        if (isLegacyResolved) {
+            count += importLegacyMilestoneArtifacts(resolvedPhaseFullPath, phaseDirName, milestoneId);
             continue;
-        const sliceDirs = readdirSync(slicesDir, { withFileTypes: true })
-            .filter(d => d.isDirectory() && /^S\d+/.test(d.name))
-            .map(d => d.name)
+        }
+        const phaseFullPath = resolvedPhaseFullPath;
+        const phaseNum = milestoneIdToPhaseNum(milestoneId);
+        // Phase-level files (flat-phase: NN-SUFFIX.md, legacy: M001-SUFFIX.md)
+        const phasePrefix = `${String(phaseNum).padStart(2, "0")}`;
+        const artifactBase = `phases/${phaseDirName}`;
+        let phaseArtifacts = importFilesAtLevel(phaseFullPath, phasePrefix, MILESTONE_SUFFIXES, artifactBase, milestoneId, null, null);
+        if (phaseArtifacts === 0) {
+            phaseArtifacts = importFilesAtLevel(phaseFullPath, milestoneId, MILESTONE_SUFFIXES, artifactBase, milestoneId, null, null);
+        }
+        count += phaseArtifacts;
+        // Flat-phase: plan files are NN-MM-SUFFIX.md inside the phase dir.
+        // Also check legacy slices/ subdir for backward compat.
+        const planFiles = readdirSync(phaseFullPath, { withFileTypes: true })
+            .filter(f => f.isFile() && /^\d+-\d+-/.test(f.name))
+            .map(f => f.name)
             .sort();
-        for (const sliceDirName of sliceDirs) {
-            const sliceId = sliceDirName.match(/^(S\d+)/)?.[1] ?? sliceDirName;
-            const sliceFullPath = join(slicesDir, sliceDirName);
-            // Slice-level files
-            count += importFilesAtLevel(sliceFullPath, sliceId, SLICE_SUFFIXES, `milestones/${milestoneDirName}/slices/${sliceDirName}`, milestoneId, sliceId, null);
-            // Walk tasks
-            const tasksDir = join(sliceFullPath, 'tasks');
-            if (!existsSync(tasksDir))
+        for (const planFile of planFiles) {
+            const planMatch = planFile.match(/^\d+-(\d+)-([A-Z0-9-]+)\.md$/i);
+            if (!planMatch)
+                continue;
+            const planNum = parseInt(planMatch[1], 10);
+            const sliceId = `S${String(planNum).padStart(2, '0')}`;
+            const suffix = planMatch[2].toUpperCase();
+            const filePath = join(phaseFullPath, planFile);
+            if (!existsSync(filePath))
                 continue;
-            for (const suffix of TASK_SUFFIXES) {
-                const taskFiles = resolveTaskFiles(tasksDir, suffix);
-                for (const taskFileName of taskFiles) {
-                    const taskId = taskFileName.match(/^(T\d+)/)?.[1] ?? null;
-                    const taskFilePath = join(tasksDir, taskFileName);
-                    if (!existsSync(taskFilePath))
-                        continue;
-                    const content = readFileSync(taskFilePath, 'utf-8');
-                    const relPath = `milestones/${milestoneDirName}/slices/${sliceDirName}/tasks/${taskFileName}`;
-                    insertArtifact({
-                        path: relPath,
-                        artifact_type: suffix,
-                        milestone_id: milestoneId,
-                        slice_id: sliceId,
-                        task_id: taskId,
-                        full_content: content,
-                    });
-                    count++;
+            const content = readFileSync(filePath, 'utf-8');
+            insertArtifact({
+                path: `${artifactBase}/${planFile}`,
+                artifact_type: suffix,
+                milestone_id: milestoneId,
+                slice_id: sliceId,
+                task_id: null,
+                full_content: content,
+            });
+            count++;
+        }
+        // Legacy fallback: walk slices/ subdir if it exists
+        const slicesDir = join(phaseFullPath, 'slices');
+        if (existsSync(slicesDir)) {
+            const sliceDirs = readdirSync(slicesDir, { withFileTypes: true })
+                .filter(d => d.isDirectory() && /^S\d+/.test(d.name))
+                .map(d => d.name)
+                .sort();
+            for (const sliceDirName of sliceDirs) {
+                const sliceId = sliceDirName.match(/^(S\d+)/)?.[1] ?? sliceDirName;
+                const sliceFullPath = join(slicesDir, sliceDirName);
+                count += importFilesAtLevel(sliceFullPath, sliceId, SLICE_SUFFIXES, `phases/${phaseDirName}/slices/${sliceDirName}`, milestoneId, sliceId, null);
+                // Legacy tasks walk
+                const tasksDir = join(sliceFullPath, 'tasks');
+                if (!existsSync(tasksDir))
+                    continue;
+                for (const suffix of TASK_SUFFIXES) {
+                    const taskFiles = resolveTaskFiles(tasksDir, suffix);
+                    for (const taskFileName of taskFiles) {
+                        const taskId = taskFileName.match(/^(T\d+)/)?.[1] ?? null;
+                        const taskFilePath = join(tasksDir, taskFileName);
+                        if (!existsSync(taskFilePath))
+                            continue;
+                        const content = readFileSync(taskFilePath, 'utf-8');
+                        const relPath = `phases/${phaseDirName}/slices/${sliceDirName}/tasks/${taskFileName}`;
+                        insertArtifact({
+                            path: relPath,
+                            artifact_type: suffix,
+                            milestone_id: milestoneId,
+                            slice_id: sliceId,
+                            task_id: taskId,
+                            full_content: content,
+                        });
+                        count++;
+                    }
                 }
             }
         }
+        // Partial migration may leave nested milestones/M00N/ content alongside phases/.
+        const milestoneDirName = findDirByPrefix(legacyDir, milestoneId);
+        if (milestoneDirName) {
+            count += importLegacyMilestoneArtifacts(join(legacyDir, milestoneDirName), milestoneDirName, milestoneId);
+        }
+    }
+    return count;
+}
+/** Walk a pre-flat-phase milestones/M001/ tree when no phases/NN-slug dir exists. */
+function importLegacyMilestoneArtifacts(milestoneFullPath, milestoneDirName, milestoneId) {
+    let count = 0;
+    count += importFilesAtLevel(milestoneFullPath, milestoneId, MILESTONE_SUFFIXES, `milestones/${milestoneDirName}`, milestoneId, null, null);
+    const slicesDir = join(milestoneFullPath, 'slices');
+    if (!existsSync(slicesDir))
+        return count;
+    const sliceDirs = readdirSync(slicesDir, { withFileTypes: true })
+        .filter(d => d.isDirectory() && /^S\d+/.test(d.name))
+        .map(d => d.name)
+        .sort();
+    for (const sliceDirName of sliceDirs) {
+        const sliceId = sliceDirName.match(/^(S\d+)/)?.[1] ?? sliceDirName;
+        const sliceFullPath = join(slicesDir, sliceDirName);
+        count += importFilesAtLevel(sliceFullPath, sliceId, SLICE_SUFFIXES, `milestones/${milestoneDirName}/slices/${sliceDirName}`, milestoneId, sliceId, null);
+        const tasksDir = join(sliceFullPath, 'tasks');
+        if (!existsSync(tasksDir))
+            continue;
+        for (const suffix of TASK_SUFFIXES) {
+            const taskFiles = resolveTaskFiles(tasksDir, suffix);
+            for (const taskFileName of taskFiles) {
+                const taskId = taskFileName.match(/^(T\d+)/)?.[1] ?? null;
+                const taskFilePath = join(tasksDir, taskFileName);
+                if (!existsSync(taskFilePath))
+                    continue;
+                const content = readFileSync(taskFilePath, 'utf-8');
+                const relPath = `milestones/${milestoneDirName}/slices/${sliceDirName}/tasks/${taskFileName}`;
+                insertArtifact({
+                    path: relPath,
+                    artifact_type: suffix,
+                    milestone_id: milestoneId,
+                    slice_id: sliceId,
+                    task_id: taskId,
+                    full_content: content,
+                });
+                count++;
+            }
+        }
     }
     return count;
 }
@@ -418,9 +515,10 @@ function findFileByPrefixAndSuffix(dir, idPrefix, suffix) {
         const direct = entries.find(e => e.toUpperCase() === target);
         if (direct)
             return direct;
-        // Legacy: ID-DESCRIPTOR-SUFFIX.md
+        // Legacy: ID-DESCRIPTOR-SUFFIX.md — exclude double-numbered (NN-NN-*) slice
+        // files so a phase-prefix like "01" never matches a slice file "01-01-SUMMARY.md".
         const pattern = new RegExp(`^${idPrefix}-.*-${suffix}\\.md$`, 'i');
-        const match = entries.find(e => pattern.test(e));
+        const match = entries.find(e => pattern.test(e) && !/^\d+-\d+-/.test(e));
         return match ?? null;
     }
     catch {
@@ -564,9 +662,11 @@ export function migrateHierarchyToDb(basePath) {
             for (const taskEntry of plan.tasks) {
                 // Per K002: use 'complete' not 'done'
                 let taskStatus = taskEntry.done ? 'complete' : 'pending';
-                // Pre-migration consistency: if task is marked done in the plan but has
-                // no summary file on disk, import as 'pending' so it gets re-executed
-                // rather than silently importing bad state as the new DB authority.
+                // Pre-migration consistency (legacy layout only): if a task is marked
+                // done but has no per-task SUMMARY.md, import it as pending so it gets
+                // re-executed rather than silently entering the DB as complete.
+                // Flat-phase has no per-task summary files by design — the checkbox
+                // state is the authoritative completion signal and is imported as-is.
                 if (taskStatus === 'complete') {
                     const tDir = resolveTasksDir(basePath, milestoneId, sliceEntry.id);
                     if (tDir) {
@@ -600,11 +700,13 @@ export function migrateHierarchyToDb(basePath) {
                 const sliceSummaryPath = resolveSliceFile(basePath, milestoneId, sliceEntry.id, 'SUMMARY');
                 const hasSliceSummary = sliceSummaryPath !== null && existsSync(sliceSummaryPath);
                 const allTasksDone = plan.tasks.length > 0 && plan.tasks.every(t => {
+                    if (!t.done)
+                        return false;
                     const tDir = resolveTasksDir(basePath, milestoneId, sliceEntry.id);
+                    // Flat-phase has no per-task summary files — checkbox state is authoritative.
                     if (!tDir)
-                        return t.done;
-                    const summaryFile = join(tDir, `${t.id}-SUMMARY.md`);
-                    return t.done && existsSync(summaryFile);
+                        return true;
+                    return existsSync(join(tDir, `${t.id}-SUMMARY.md`));
                 });
                 if (allTasksDone && hasSliceSummary) {
                     if (_getAdapter()) {

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

@@ -33,8 +33,8 @@ import { logWarning } from "./workflow-logger.js";
  *   decision is checked individually; only decisions whose id is already
  *   present in the memory store are skipped. A user-authored memory with
  *   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.
+ * - Best-effort: never throws. Failed memory inserts are logged and skipped;
+ *   setup/read failures log and return 0 so backfill cannot block startup.
  * - 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
@@ -117,25 +117,32 @@ export function backfillDecisionsToMemories() {
                 continue;
             }
             const content = synthesizeDecisionMemoryContent(row);
-            const id = createMemory({
-                category: "architecture",
-                content,
-                scope: row.scope || "project",
-                confidence: 0.85,
-                structuredFields: {
-                    sourceDecisionId: row.id,
-                    when_context: row.when_context,
-                    scope: row.scope,
-                    decision: row.decision,
-                    choice: row.choice,
-                    rationale: row.rationale,
-                    made_by: row.made_by,
-                    revisable: row.revisable,
-                    superseded_by: row.superseded_by,
-                },
-            });
-            if (id)
-                written += 1;
+            try {
+                const id = createMemory({
+                    category: "architecture",
+                    content,
+                    scope: row.scope || "project",
+                    confidence: 0.85,
+                    structuredFields: {
+                        sourceDecisionId: row.id,
+                        when_context: row.when_context,
+                        scope: row.scope,
+                        decision: row.decision,
+                        choice: row.choice,
+                        rationale: row.rationale,
+                        made_by: row.made_by,
+                        revisable: row.revisable,
+                        superseded_by: row.superseded_by,
+                    },
+                });
+                if (id)
+                    written += 1;
+            }
+            catch (rowErr) {
+                const message = rowErr instanceof Error ? rowErr.message : String(rowErr);
+                logWarning("memory-backfill", `decisions->memories backfill skipped ${row.id}: ${message}`);
+                continue;
+            }
         }
         if (healed > 0) {
             logWarning("memory-backfill", `decisions->memories drift healed: ${healed} row${healed === 1 ? "" : "s"} updated superseded_by`);

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

@@ -94,27 +94,48 @@ function getActiveDecisions() {
         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) {
+function emptyMemorySourceMarkers() {
+    return { decisionIds: new Set(), knowledgeIds: new Set() };
+}
+function getMemorySourceMarkers() {
+    const markers = emptyMemorySourceMarkers();
     if (!isDbAvailable())
-        return false;
+        return markers;
     const adapter = _getAdapter();
     if (!adapter)
-        return false;
+        return markers;
     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;
+        const rows = adapter
+            .prepare("SELECT structured_fields FROM memories WHERE structured_fields IS NOT NULL")
+            .all();
+        for (const row of rows) {
+            collectMemorySourceMarker(markers, row["structured_fields"]);
+        }
     }
     catch {
-        return false;
+        return markers;
+    }
+    return markers;
+}
+function collectMemorySourceMarker(markers, raw) {
+    if (typeof raw !== "string" || raw.length === 0)
+        return;
+    try {
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+            return;
+        const fields = parsed;
+        const decisionId = fields["sourceDecisionId"];
+        if (typeof decisionId === "string" && decisionId.length > 0) {
+            markers.decisionIds.add(decisionId);
+        }
+        const knowledgeId = fields["sourceKnowledgeId"];
+        if (typeof knowledgeId === "string" && knowledgeId.length > 0) {
+            markers.knowledgeIds.add(knowledgeId);
+        }
+    }
+    catch {
+        return;
     }
 }
 // ─── Public API ──────────────────────────────────────────────────────────────
@@ -127,10 +148,14 @@ const SAMPLE_LIMIT = 5;
 export function scanConsolidationGaps(basePath) {
     // ── Decisions ────────────────────────────────────────────────────────
     const decisions = getActiveDecisions();
+    const knowledgeRows = parseKnowledgeRows(knowledgeMdContent(basePath));
+    const memorySourceMarkers = decisions.length > 0 || knowledgeRows.length > 0
+        ? getMemorySourceMarkers()
+        : emptyMemorySourceMarkers();
     const decisionSamples = [];
     let decisionMigrated = 0;
     for (const decision of decisions) {
-        if (memoryHasSourceMarker("sourceDecisionId", decision.id)) {
+        if (memorySourceMarkers.decisionIds.has(decision.id)) {
             decisionMigrated += 1;
             continue;
         }
@@ -142,16 +167,14 @@ export function scanConsolidationGaps(basePath) {
         }
     }
     // ── 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)) {
+        // KNOWLEDGE.md backfill writes `sourceKnowledgeId`; rows without that
+        // marker are still reported as consolidation gaps.
+        if (memorySourceMarkers.knowledgeIds.has(row.id)) {
             knowledgeMigrated += 1;
             continue;
         }

package/dist/resources/extensions/gsd/metrics.js

@@ -17,7 +17,7 @@ import { join } from "node:path";
 import { openSync, closeSync, unlinkSync, statSync, writeFileSync } from "node:fs";
 import { gsdRoot } from "./paths.js";
 import { getAndClearSkills } from "./skill-telemetry.js";
-import { loadJsonFile, loadJsonFileOrNull, saveJsonFile } from "./json-persistence.js";
+import { loadJsonFile, loadJsonFileOrNull, saveJsonFileCompact } from "./json-persistence.js";
 import { parseUnitId } from "./unit-id.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
 import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
@@ -611,12 +611,19 @@ function isMetricsLedger(data) {
 function defaultLedger() {
     return { version: 1, projectStartedAt: Date.now(), units: [] };
 }
+export const METRICS_LEDGER_KEEP_UNITS = 1500;
+function compareUnitsByTime(a, b) {
+    return a.finishedAt - b.finishedAt || a.startedAt - b.startedAt;
+}
+function keepNewestUnits(units, keepCount = METRICS_LEDGER_KEEP_UNITS) {
+    return units.length > keepCount ? [...units].sort(compareUnitsByTime).slice(-keepCount) : units;
+}
 /**
  * Prune the metrics ledger to at most `keepCount` most-recent unit entries.
  *
  * Called by the doctor when the ledger exceeds the bloat threshold.
- * Keeps the newest entries (highest index = most recent) and discards
- * the oldest from the head of the array. Preserves `projectStartedAt`.
+ * Keeps the newest entries by unit timestamps and discards the oldest.
+ * Preserves `projectStartedAt`.
  *
  * Updates both the on-disk file and the in-memory ledger if it is loaded,
  * so the current session sees the pruned state immediately.
@@ -628,11 +635,11 @@ export function pruneMetricsLedger(base, keepCount) {
     if (!disk || disk.units.length <= keepCount)
         return 0;
     const removed = disk.units.length - keepCount;
-    disk.units = disk.units.slice(-keepCount);
-    saveJsonFile(metricsPath(base), disk);
+    disk.units = keepNewestUnits(disk.units, keepCount);
+    saveJsonFileCompact(metricsPath(base), disk);
     // Keep the in-memory ledger in sync if it is loaded for this session.
     if (ledger) {
-        ledger.units = ledger.units.slice(-keepCount);
+        ledger.units = keepNewestUnits(ledger.units, keepCount);
     }
     // Invalidate all scoped ledger cache entries. Prune is rare; clearing the
     // entire map is simpler than tracking which entry belongs to `base`. Without
@@ -786,13 +793,13 @@ function saveLedger(base, data) {
             // Read current on-disk state and merge with worker's in-memory units.
             // Worker units take precedence on conflict (by finishedAt in deduplicateUnits).
             const onDisk = loadJsonFileOrNull(path, isMetricsLedger);
-            if (onDisk && onDisk.units.length > 0) {
-                const merged = deduplicateUnits([...onDisk.units, ...data.units]);
-                saveJsonFile(path, { ...data, units: merged });
-            }
-            else {
-                saveJsonFile(path, data);
-            }
+            const dataUnits = keepNewestUnits(data.units);
+            const merged = onDisk && onDisk.units.length > 0
+                ? deduplicateUnits([...keepNewestUnits(onDisk.units), ...dataUnits])
+                : dataUnits;
+            merged.sort(compareUnitsByTime);
+            data.units = keepNewestUnits(merged);
+            saveJsonFileCompact(path, data);
         }
         finally {
             releaseLock(lockPath);
@@ -805,6 +812,7 @@ function saveLedger(base, data) {
         // to a torn write caused by two writers simultaneously executing the
         // read-merge-write sequence without mutual exclusion.
         logWarning("fs", "saveLedger: lock not acquired — falling back to direct write (no merge)");
-        saveJsonFile(path, data);
+        data.units = keepNewestUnits(data.units);
+        saveJsonFileCompact(path, data);
     }
 }

package/dist/resources/extensions/gsd/migrate/layout-detect.js

@@ -0,0 +1,32 @@
+// Project/App: gsd-pi
+// File Purpose: Classify a parsed .planning/ tree into its layout so the
+// round-trip writer can recreate the same structure gsd-core wrote.
+//
+// This extracts the implicit 3-way branch that was buried in transformer.ts
+// transformToGSD (lines 425-467). Priority matches the transformer's if/else
+// chain: legacy-milestone-dir > multi-milestone > flat-phases.
+/**
+ * Determine which .planning/ layout a parsed project uses. Returns null when
+ * no layout signal is present (caller decides: treat as inactive or error).
+ *
+ * Priority (must match transformer.ts transformToGSD):
+ *   1. legacy-milestone-dir — milestones/<id>/ contains <id>-phases/ subdirs
+ *      with phase content. Detected when parsed.milestones has any entry with
+ *      non-empty phases.
+ *   2. multi-milestone — ROADMAP.md parsed into milestone sections.
+ *      Detected when roadmap.milestones.length > 0.
+ *   3. flat-phases — ROADMAP.md parsed into checkbox phase lines only.
+ *      Detected when roadmap.phases.length > 0.
+ */
+export function detectPlanningLayout(parsed) {
+    const hasMilestoneDirectories = parsed.milestones.some((m) => Object.keys(m.phases).length > 0);
+    if (hasMilestoneDirectories)
+        return "legacy-milestone-dir";
+    const isMultiMilestone = parsed.roadmap !== null && parsed.roadmap.milestones.length > 0;
+    if (isMultiMilestone)
+        return "multi-milestone";
+    const hasFlatPhases = parsed.roadmap !== null && parsed.roadmap.phases.length > 0;
+    if (hasFlatPhases)
+        return "flat-phases";
+    return null;
+}