@opengsd/gsd-pi 1.3.0 → 1.4.0

package/src/resources/extensions/gsd/mcp-filter.ts

@@ -1,4 +1,4 @@
-import { existsSync, readFileSync } from "node:fs";
+import { readFileSync, statSync } from "node:fs";
 import { homedir } from "node:os";
 import { resolve } from "node:path";
 
@@ -21,12 +21,50 @@ interface DiscoveredMcpServer {
   config: unknown;
 }
 
+interface JsonFileSignature {
+  exists: boolean;
+  mtimeMs?: number;
+  size?: number;
+}
+
+interface ProjectMcpDiscoveryCacheEntry {
+  signatures: JsonFileSignature[];
+  servers: DiscoveredMcpServer[];
+}
+
+const projectMcpDiscoveryCache = new Map<string, ProjectMcpDiscoveryCacheEntry>();
+
 function isRecord(value: unknown): value is Record<string, unknown> {
   return !!value && typeof value === "object" && !Array.isArray(value);
 }
 
-function readJsonFile(path: string, ignoreParseErrors = false): unknown | undefined {
-  if (!existsSync(path)) return undefined;
+function getJsonFileSignature(path: string, ignoreAccessErrors = false): JsonFileSignature {
+  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: JsonFileSignature[], b: JsonFileSignature[]): boolean {
+  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: string,
+  ignoreParseErrors = false,
+  signature = getJsonFileSignature(path, ignoreParseErrors),
+): unknown | undefined {
+  if (!signature.exists) return undefined;
   try {
     return JSON.parse(readFileSync(path, "utf-8")) as unknown;
   } catch (err) {
@@ -41,13 +79,23 @@ function collectServerEntries(servers: unknown): DiscoveredMcpServer[] {
 }
 
 export function discoverMcpServers(projectDir: string): DiscoveredMcpServer[] {
-  const mcpJsonPath = resolve(projectDir, ".mcp.json");
-  const settingsPath = resolve(projectDir, ".claude", "settings.json");
-  const localSettingsPath = resolve(projectDir, ".claude", "settings.local.json");
+  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) as McpJsonFile | undefined;
-  const settings = readJsonFile(settingsPath, true) as ClaudeSettingsFile | undefined;
-  const localSettings = readJsonFile(localSettingsPath, true) as ClaudeSettingsFile | undefined;
+  const mcpJson = readJsonFile(mcpJsonPath, false, signatures[0]) as McpJsonFile | undefined;
+  const settings = readJsonFile(settingsPath, true, signatures[1]) as ClaudeSettingsFile | undefined;
+  const localSettings = readJsonFile(localSettingsPath, true, signatures[2]) as ClaudeSettingsFile | undefined;
 
   const seen = new Set<string>();
   const discovered: DiscoveredMcpServer[] = [];
@@ -61,7 +109,8 @@ export function discoverMcpServers(projectDir: string): DiscoveredMcpServer[] {
     seen.add(entry.name);
     discovered.push(entry);
   }
-  return discovered;
+  projectMcpDiscoveryCache.set(resolvedProjectDir, { signatures, servers: discovered });
+  return [...discovered];
 }
 
 function isWorkflowMcpServerConfig(config: unknown): boolean {

package/src/resources/extensions/gsd/md-importer.ts

@@ -5,7 +5,7 @@
 // Exports: parseDecisionsTable, parseRequirementsSections, migrateFromMarkdown
 
 import { readFileSync, readdirSync, existsSync, statSync } from 'node:fs';
-import { join, relative } from 'node:path';
+import { join, relative, basename } from 'node:path';
 import type { Decision, Requirement } from './types.js';
 import {
   upsertDecision,
@@ -24,13 +24,14 @@ import {
   resolveGsdRootFile,
   resolveMilestoneFile,
   resolveSliceFile,
-  resolveSlicePath,
   resolveTasksDir,
-  milestonesDir,
+  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';
@@ -329,7 +330,7 @@ function importRequirements(gsdDir: string): number {
 
 /** 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'];
 
 /**
@@ -359,75 +360,220 @@ function importHierarchyArtifacts(gsdDir: string): number {
     }
   }
 
-  // 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) continue;
-    const milestoneFullPath = join(msDir, 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;
+    }
 
-    // Milestone-level files
-    count += importFilesAtLevel(
-      milestoneFullPath,
-      milestoneId,
+    // 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 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,
-      `milestones/${milestoneDirName}`,
+      artifactBase,
       milestoneId,
       null,
       null,
     );
+    if (phaseArtifacts === 0) {
+      phaseArtifacts = importFilesAtLevel(
+        phaseFullPath,
+        milestoneId,
+        MILESTONE_SUFFIXES,
+        artifactBase,
+        milestoneId,
+        null,
+        null,
+      );
+    }
+    count += phaseArtifacts;
 
-    // Walk slices
-    const slicesDir = join(milestoneFullPath, 'slices');
-    if (!existsSync(slicesDir)) continue;
-
-    const sliceDirs = readdirSync(slicesDir, { withFileTypes: true })
-      .filter(d => d.isDirectory() && /^S\d+/.test(d.name))
-      .map(d => d.name)
+    // 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);
+    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;
+
+      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++;
+          }
+        }
+      }
+    }
 
-      // Slice-level files
-      count += importFilesAtLevel(
-        sliceFullPath,
-        sliceId,
-        SLICE_SUFFIXES,
-        `milestones/${milestoneDirName}/slices/${sliceDirName}`,
+    // Partial migration may leave nested milestones/M00N/ content alongside phases/.
+    const milestoneDirName = findDirByPrefix(legacyDir, milestoneId);
+    if (milestoneDirName) {
+      count += importLegacyMilestoneArtifacts(
+        join(legacyDir, milestoneDirName),
+        milestoneDirName,
         milestoneId,
-        sliceId,
-        null,
       );
+    }
+  }
 
-      // Walk tasks
-      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;
+}
+
+/** Walk a pre-flat-phase milestones/M001/ tree when no phases/NN-slug dir exists. */
+function importLegacyMilestoneArtifacts(
+  milestoneFullPath: string,
+  milestoneDirName: string,
+  milestoneId: string,
+): number {
+  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++;
       }
     }
   }
@@ -504,9 +650,10 @@ function findFileByPrefixAndSuffix(dir: string, idPrefix: string, suffix: string
     const target = `${idPrefix}-${suffix}.md`.toUpperCase();
     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 {
     return null;
@@ -669,9 +816,11 @@ export function migrateHierarchyToDb(basePath: string): {
         // Per K002: use 'complete' not 'done'
         let taskStatus: string = 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) {
@@ -709,10 +858,11 @@ export function migrateHierarchyToDb(basePath: string): {
         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);
-          if (!tDir) return t.done;
-          const summaryFile = join(tDir, `${t.id}-SUMMARY.md`);
-          return t.done && existsSync(summaryFile);
+          // Flat-phase has no per-task summary files — checkbox state is authoritative.
+          if (!tDir) return true;
+          return existsSync(join(tDir, `${t.id}-SUMMARY.md`));
         });
         if (allTasksDone && hasSliceSummary) {
           if (_getAdapter()) {

package/src/resources/extensions/gsd/memory-backfill.ts

@@ -49,8 +49,8 @@ type DecisionContentFields = Pick<DecisionRow, "decision" | "choice" | "rational
  *   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
@@ -146,24 +146,30 @@ export function backfillDecisionsToMemories(): number {
       }
 
       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) {

package/src/resources/extensions/gsd/memory-consolidation-scanner.ts

@@ -142,23 +142,53 @@ function getActiveDecisions(): DecisionRow[] {
 }
 
 /**
- * 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.
+ * Source IDs already present in memory `structured_fields`. Collected with one
+ * pass over the memories table so the scanner does not perform a non-indexable
+ * LIKE probe for every decision and KNOWLEDGE.md row.
  */
-function memoryHasSourceMarker(markerKey: string, value: string): boolean {
-  if (!isDbAvailable()) return false;
+interface MemorySourceMarkers {
+  decisionIds: Set<string>;
+  knowledgeIds: Set<string>;
+}
+
+function emptyMemorySourceMarkers(): MemorySourceMarkers {
+  return { decisionIds: new Set(), knowledgeIds: new Set() };
+}
+
+function getMemorySourceMarkers(): MemorySourceMarkers {
+  const markers = emptyMemorySourceMarkers();
+  if (!isDbAvailable()) return markers;
   const adapter = _getAdapter();
-  if (!adapter) return false;
+  if (!adapter) return markers;
+  try {
+    const rows = adapter
+      .prepare("SELECT structured_fields FROM memories WHERE structured_fields IS NOT NULL")
+      .all() as Array<Record<string, unknown>>;
+    for (const row of rows) {
+      collectMemorySourceMarker(markers, row["structured_fields"]);
+    }
+  } catch {
+    return markers;
+  }
+  return markers;
+}
+
+function collectMemorySourceMarker(markers: MemorySourceMarkers, raw: unknown): void {
+  if (typeof raw !== "string" || raw.length === 0) return;
   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 parsed = JSON.parse(raw);
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return;
+    const fields = parsed as Record<string, unknown>;
+    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 false;
+    return;
   }
 }
 
@@ -174,10 +204,14 @@ const SAMPLE_LIMIT = 5;
 export function scanConsolidationGaps(basePath: string): ConsolidationGapReport {
   // ── Decisions ────────────────────────────────────────────────────────
   const decisions = getActiveDecisions();
+  const knowledgeRows = parseKnowledgeRows(knowledgeMdContent(basePath));
+  const memorySourceMarkers = decisions.length > 0 || knowledgeRows.length > 0
+    ? getMemorySourceMarkers()
+    : emptyMemorySourceMarkers();
   const decisionSamples: DecisionsSurfaceReport["samples"] = [];
   let decisionMigrated = 0;
   for (const decision of decisions) {
-    if (memoryHasSourceMarker("sourceDecisionId", decision.id)) {
+    if (memorySourceMarkers.decisionIds.has(decision.id)) {
       decisionMigrated += 1;
       continue;
     }
@@ -190,16 +224,14 @@ export function scanConsolidationGaps(basePath: string): ConsolidationGapReport
   }
 
   // ── KNOWLEDGE.md ─────────────────────────────────────────────────────
-  const knowledgeRows = parseKnowledgeRows(knowledgeMdContent(basePath));
   const knowledgeByTable = { rules: 0, patterns: 0, lessons: 0 };
   const knowledgeSamples: KnowledgeSurfaceReport["samples"] = [];
   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;
     }