@opengsd/gsd-pi 1.2.0 → 1.3.0-dev.eed73bea

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

@@ -0,0 +1,10 @@
+// mcp-bridge.ts — stable runtime seam for MCP server consumption (phase 1).
+export { loadWriteGateSnapshot, shouldBlockPendingGateInSnapshot, shouldBlockQueueExecutionInSnapshot, } from "./bootstrap/write-gate.js";
+export { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
+export { _getAdapter, checkpointDatabase, closeDatabase, getAllMilestones, getDb, getGateResults, getMilestoneSlices, getPendingGates, getSliceTasks, insertDecision, insertMilestone, insertSlice, openDatabase, upsertMilestonePlanning, } from "./gsd-db.js";
+export { invalidateStateCache, isReusableGhostMilestone } from "./state.js";
+export { loadEffectiveGSDPreferences } from "./preferences.js";
+export { saveDecisionToDb, saveRequirementToDb, updateRequirementInDb, } from "./db-writer.js";
+export { rebuildState } from "./doctor.js";
+export { queryJournal } from "./journal.js";
+export { claimReservedId, findMilestoneIds, getReservedMilestoneIds, milestoneIdSort, nextMilestoneId, } from "./milestone-ids.js";

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

@@ -1,12 +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"));
@@ -23,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 [
@@ -42,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))
@@ -62,29 +98,11 @@ function isWorkflowMcpServerConfig(config) {
     const args = Array.isArray(config.args) ? config.args.filter((arg) => typeof arg === "string") : [];
     return args.some((arg) => arg.includes("gsd-mcp-server") || arg.includes("packages/mcp-server"));
 }
-function isBrowserMcpServerConfig(config) {
-    if (!isRecord(config))
-        return false;
-    const command = typeof config.command === "string" ? config.command : "";
-    if (command.includes("gsd-browser") || command.includes("@opengsd/gsd-browser")) {
-        return true;
-    }
-    const env = config.env;
-    if (isRecord(env)) {
-        if (typeof env.GSD_BROWSER_CLI_PATH === "string"
-            || typeof env.GSD_BROWSER_BIN_PATH === "string"
-            || typeof env.GSD_BROWSER_MCP_COMMAND === "string") {
-            return true;
-        }
-    }
-    const args = Array.isArray(config.args) ? config.args.filter((arg) => typeof arg === "string") : [];
-    return args.some((arg) => arg.includes("gsd-browser") || arg.includes("@opengsd/gsd-browser"));
-}
 export function discoverWorkflowMcpServerName(projectDir) {
     return discoverMcpServers(projectDir).find((server) => isWorkflowMcpServerConfig(server.config))?.name;
 }
 export function discoverBrowserMcpServerName(projectDir) {
-    return discoverMcpServers(projectDir).find((server) => isBrowserMcpServerConfig(server.config))?.name;
+    return discoverMcpServers(projectDir).find((server) => isGsdBrowserMcpServerConfig(server.config))?.name;
 }
 export function discoverMcpServerNames(projectDir) {
     return discoverMcpServers(projectDir).map((server) => server.name);
@@ -123,5 +141,5 @@ export function computeMcpDisallowedTools(modelId, mcpConfig, discoveredServers,
     if (workflowServerName && !(entry.blocked_servers ?? []).includes(workflowServerName)) {
         blocked.delete(workflowServerName);
     }
-    return [...blocked].map((name) => `mcp__${name}__*`);
+    return [...blocked].map(toMcpWildcardToolName);
 }

package/dist/resources/extensions/gsd/mcp-tool-name.js

@@ -0,0 +1,18 @@
+// Project/App: gsd-pi
+// File Purpose: GSD-facing face over the shared @gsd/pi-ai MCP tool-name helpers.
+import { parseMcpToolName as parsePiAiMcpToolName, stripMcpToolPrefix } from "@gsd/pi-ai";
+const MCP_TOOL_PREFIX = "mcp__";
+export function parseMcpToolName(toolName) {
+    const parsed = parsePiAiMcpToolName(toolName);
+    return parsed ? { serverName: parsed.server, toolName: parsed.tool } : null;
+}
+export { stripMcpToolPrefix };
+export function toMcpToolName(serverName, toolName) {
+    return `${MCP_TOOL_PREFIX}${serverName}__${toolName}`;
+}
+export function toMcpWildcardToolName(serverName) {
+    return toMcpToolName(serverName, "*");
+}
+export function mcpToolMatchesBaseName(toolName, baseName) {
+    return parseMcpToolName(toolName)?.toolName === baseName;
+}

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

@@ -4,10 +4,12 @@
 //
 // Exports: parseDecisionsTable, parseRequirementsSections, migrateFromMarkdown
 import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { upsertDecision, upsertRequirement, insertArtifact, insertMilestone, insertSlice, insertTask, openDatabase, transaction, updateMilestoneStatus, updateSliceStatus, _getAdapter, } from './gsd-db.js';
-import { resolveGsdRootFile, resolveMilestoneFile, resolveSliceFile, resolveTasksDir, milestonesDir, gsdRoot, resolveTaskFiles, } from './paths.js';
+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, 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';
@@ -277,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.
@@ -304,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;
 }
@@ -417,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 {
@@ -542,7 +641,7 @@ export function migrateHierarchyToDb(basePath) {
                 title: sliceEntry.title,
                 status: sliceStatus,
                 risk: sliceEntry.risk,
-                depends: sliceEntry.depends,
+                depends: (sliceEntry.depends ?? []).map(d => d.replace(/^\[|\]$/g, '')).filter(d => /^[A-Za-z0-9][A-Za-z0-9-]*$/.test(d)),
                 demo: sliceEntry.demo,
                 sequence: si + 1, // Preserve roadmap parse order (#3356)
                 isSketch: sliceEntry.isSketch ?? false, // ADR-011: preserve the `[sketch]` flag on re-import
@@ -563,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) {
@@ -599,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()) {
@@ -628,7 +731,7 @@ export function migrateFromMarkdown(gsdDir) {
     const dbPath = join(gsdRoot(gsdDir), 'gsd.db');
     // Open DB if not already open
     if (!_getAdapter()) {
-        openDatabase(dbPath);
+        openWorkflowDatabasePath(dbPath);
     }
     let decisions = 0;
     let requirements = 0;

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;
         }
@@ -211,7 +234,7 @@ export function reportConsolidationGaps(basePath) {
         const report = scanConsolidationGaps(basePath);
         if (report.totalGaps === 0)
             return report;
-        appendNotification(report.summary, "warning", "workflow-logger");
+        appendNotification(report.summary, "warning", "workflow-logger", { kind: "memory-consolidation" });
         logWarning("memory-consolidation", report.summary);
         return report;
     }

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

@@ -3,7 +3,7 @@
 // Phase 4 companion to memory-store.ts. Edges live in the `memory_relations`
 // table and are created by (a) explicit LINK actions emitted by the memory
 // extractor, or (b) future `/gsd memory link` CLI commands. All writes go
-// through the single-writer gate in `gsd-db.ts`.
+// through typed writer wrappers re-exported by `gsd-db.ts`.
 import { _getAdapter, deleteMemoryRelationsFor, insertMemoryRelationRow, isDbAvailable, } from "./gsd-db.js";
 export const VALID_RELATIONS = [
     "related_to",

package/dist/resources/extensions/gsd/metrics.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);
+    disk.units = keepNewestUnits(disk.units, keepCount);
     saveJsonFile(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);
+            saveJsonFile(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)");
+        data.units = keepNewestUnits(data.units);
         saveJsonFile(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;
+}