@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.738160b9

package/src/resources/extensions/gsd/guided-flow-queue.ts

@@ -20,6 +20,7 @@ import { invalidateAllCaches } from "./cache.js";
 import {
   gsdRoot, resolveMilestoneFile, resolveSliceFile,
   resolveGsdRootFile, relGsdRootFile, relSliceFile,
+  relMilestoneFile,
 } from "./paths.js";
 import { readFileSync, writeFileSync, existsSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -29,6 +30,10 @@ import { loadQueueOrder, sortByQueueOrder, saveQueueOrder } from "./queue-order.
 import { findMilestoneIds, nextMilestoneId } from "./milestone-ids.js";
 import { isFutureMilestoneStatus } from "./status-guards.js";
 
+const QUEUE_ARTIFACT_EXCERPT_MAX_CHARS = 20_000;
+const QUEUE_EXISTING_MILESTONES_CONTEXT_MAX_CHARS = 120_000;
+const QUEUE_CONTEXT_SECTION_SEPARATOR = "\n\n---\n\n";
+
 // ─── Queue Entry Point ──────────────────────────────────────────────────────
 
 /**
@@ -280,7 +285,9 @@ export async function buildExistingMilestonesContext(
     if (contextFile) {
       const content = await loadFile(contextFile);
       if (content) {
-        parts.push(`\n**Context:**\n${content.trim()}`);
+        parts.push(
+          `\n**Context:**\n${summarizeArtifactForQueue(content, relMilestoneFile(basePath, mid, "CONTEXT"))}`,
+        );
       }
     } else {
       // No full CONTEXT.md — check for CONTEXT-DRAFT.md (draft seed from prior discussion)
@@ -288,7 +295,9 @@ export async function buildExistingMilestonesContext(
       if (draftFile) {
         const draftContent = await loadFile(draftFile);
         if (draftContent) {
-          parts.push(`\n**Draft context available:**\n${draftContent.trim()}`);
+          parts.push(
+            `\n**Draft context available:**\n${summarizeArtifactForQueue(draftContent, relMilestoneFile(basePath, mid, "CONTEXT-DRAFT"))}`,
+          );
         }
       }
     }
@@ -300,7 +309,9 @@ export async function buildExistingMilestonesContext(
       if (roadmapFile) {
         const content = await loadFile(roadmapFile);
         if (content) {
-          parts.push(`\n**Roadmap:**\n${content.trim()}`);
+          parts.push(
+            `\n**Roadmap:**\n${summarizeArtifactForQueue(content, relMilestoneFile(basePath, mid, "ROADMAP"))}`,
+          );
         }
       }
     }
@@ -317,7 +328,81 @@ export async function buildExistingMilestonesContext(
     }
   }
 
-  return sections.join("\n\n---\n\n");
+  return capExistingMilestonesContext(sections);
+}
+
+function summarizeArtifactForQueue(
+  content: string,
+  sourcePath: string,
+  cap = QUEUE_ARTIFACT_EXCERPT_MAX_CHARS,
+): string {
+  const trimmed = content.trim();
+  if (trimmed.length <= cap) {
+    return `Source: \`${sourcePath}\`\n\n${trimmed}`;
+  }
+
+  const excerpt = trimmed.slice(0, cap).trimEnd();
+  const omittedChars = trimmed.length - excerpt.length;
+  return [
+    `Source: \`${sourcePath}\``,
+    "",
+    excerpt,
+    "",
+    `[Truncated ${omittedChars} chars. Read \`${sourcePath}\` for full content.]`,
+  ].join("\n");
+}
+
+function capExistingMilestonesContext(
+  sections: string[],
+  cap = QUEUE_EXISTING_MILESTONES_CONTEXT_MAX_CHARS,
+): string {
+  const fullContext = sections.join(QUEUE_CONTEXT_SECTION_SEPARATOR);
+  if (fullContext.length <= cap) return fullContext;
+
+  const notice = `[Existing milestones context truncated to ${cap} chars. Read source paths in this prompt or the corresponding .gsd artifacts for full details.]`;
+  const noticeSuffix = `${QUEUE_CONTEXT_SECTION_SEPARATOR}${notice}`;
+
+  const selected: string[] = [];
+  for (const section of sections) {
+    const candidate = [...selected, section].join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
+    if (candidate.length <= cap) {
+      selected.push(section);
+      continue;
+    }
+    break;
+  }
+
+  if (selected.length === sections.length) {
+    return selected.join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
+  }
+
+  const compactTail = sections.slice(selected.length).map(compactSectionForQueueBudget);
+  const hybrid = [...selected, ...compactTail].join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
+  if (hybrid.length <= cap) return hybrid;
+
+  const compact = sections.map(compactSectionForQueueBudget);
+  const compactContext = compact.join(QUEUE_CONTEXT_SECTION_SEPARATOR) + noticeSuffix;
+  if (compactContext.length <= cap) return compactContext;
+
+  return `${compactContext.slice(0, Math.max(0, cap - notice.length - 2)).trimEnd()}\n\n${notice}`;
+}
+
+function compactSectionForQueueBudget(section: string): string {
+  const lines = section.split("\n");
+  const compact: string[] = [];
+
+  if (lines[0]) compact.push(lines[0]);
+
+  const statusLine = lines.find(line => line.startsWith("**Status:**"));
+  if (statusLine) compact.push(statusLine);
+
+  const sourceLines = lines.filter(line => line.startsWith("Source: `"));
+  if (sourceLines.length > 0) {
+    compact.push("", "**Sources:**", ...sourceLines);
+    compact.push("", "[Artifact excerpts omitted due to total queue/rethink context budget.]");
+  }
+
+  return compact.join("\n");
 }
 
 // ─── Internal Helpers ───────────────────────────────────────────────────────

package/src/resources/extensions/gsd/health-widget.ts

@@ -2,11 +2,12 @@
 // File Purpose: Always-on ambient health signal rendered below the editor.
 
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
+import { execFile } from "node:child_process";
 import type { GSDState } from "./types.js";
-import { runProviderChecks, summariseProviderIssues } from "./doctor-providers.js";
+import { runProviderChecks, runProviderChecksAsync, summariseProviderIssues } from "./doctor-providers.js";
 import { runEnvironmentChecks, runEnvironmentChecksAsync } from "./doctor-environment.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { nativeIsRepo, nativeLastCommitEpoch, nativeGetCurrentBranch, nativeCommitSubject } from "./native-git-bridge.js";
+import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadLedgerFromDisk, getProjectTotals } from "./metrics.js";
 import { describeNextUnit, estimateTimeRemaining, updateSliceProgressCache } from "./auto-dashboard.js";
 import { projectRoot } from "./commands/context.js";
@@ -15,32 +16,75 @@ import {
   buildHealthLines,
   detectHealthWidgetProjectState,
   type HealthWidgetData,
+  type HealthWidgetProjectState,
 } from "./health-widget-core.js";
 
 export const HEALTH_WIDGET_ACTIVE_HINTS =
   "  /gsd auto to run  ·  /gsd status to inspect  ·  /gsd report for snapshots  ·  /gsd notifications for history  ·  /gsd help";
 
+const LAST_COMMIT_LOOKUP_TIMEOUT_MS = 3_000;
+const REFRESH_INTERVAL_MS = 60_000;
+const PROJECT_STATE_CACHE_TTL_MS = REFRESH_INTERVAL_MS;
+
 // ── Data loader ────────────────────────────────────────────────────────────────
 
-// Last-commit lookup is subprocess-backed (native-git-bridge → git spawns),
-// so it is treated like the other expensive checks: skipped on first paint,
-// run only by the background refresh.
-function loadLastCommitInfo(basePath: string): { epoch: number | null; message: string | null } {
+const projectStateCache = new Map<string, { state: HealthWidgetProjectState; computedAt: number }>();
+
+export function getCachedProjectState(basePath: string, force?: boolean): HealthWidgetProjectState {
+  const now = Date.now();
+  const cached = projectStateCache.get(basePath);
+  if (!force && cached && now - cached.computedAt <= PROJECT_STATE_CACHE_TTL_MS) {
+    return cached.state;
+  }
+
+  const state = detectHealthWidgetProjectState(basePath);
+  projectStateCache.set(basePath, { state, computedAt: now });
+  return state;
+}
+
+function runHealthWidgetGit(basePath: string, args: string[]): Promise<string | null> {
+  return new Promise((resolve) => {
+    const child = execFile(
+      "git",
+      args,
+      {
+        cwd: basePath,
+        timeout: LAST_COMMIT_LOOKUP_TIMEOUT_MS,
+        encoding: "utf-8",
+        env: GIT_NO_PROMPT_ENV,
+      },
+      (err, stdout) => resolve(err ? null : String(stdout).trimEnd()),
+    );
+    child.on("error", () => resolve(null));
+  });
+}
+
+async function loadLastCommitInfoAsync(basePath: string): Promise<{ epoch: number | null; message: string | null }> {
   try {
-    if (nativeIsRepo(basePath)) {
-      const branch = nativeGetCurrentBranch(basePath);
-      const epoch = nativeLastCommitEpoch(basePath, branch || "HEAD");
-      if (epoch > 0) {
-        return { epoch, message: nativeCommitSubject(basePath, branch || "HEAD") || null };
-      }
+    if ((await runHealthWidgetGit(basePath, ["rev-parse", "--git-dir"])) === null) {
+      return { epoch: null, message: null };
     }
-  } catch { /* non-fatal */ }
-  return { epoch: null, message: null };
+
+    const branch = await runHealthWidgetGit(basePath, ["branch", "--show-current"]);
+    const ref = branch || "HEAD";
+    const raw = await runHealthWidgetGit(basePath, ["log", "-1", "--format=%ct%x00%s", ref]);
+    if (!raw) return { epoch: null, message: null };
+
+    const separator = raw.indexOf("\0");
+    const epochText = separator >= 0 ? raw.slice(0, separator) : raw;
+    const epoch = parseInt(epochText.trim(), 10) || 0;
+    if (epoch <= 0) return { epoch: null, message: null };
+
+    const message = separator >= 0 ? raw.slice(separator + 1).trim() : "";
+    return { epoch, message: message || null };
+  } catch {
+    return { epoch: null, message: null };
+  }
 }
 
 function loadHealthWidgetData(
   basePath: string,
-  options?: { includeChecks?: boolean },
+  options?: { includeChecks?: boolean; forceProjectState?: boolean },
 ): HealthWidgetData {
   // `includeChecks` gates the expensive subprocess-backed checks (provider +
   // environment doctor: `lsof`, `docker`, `node --version`, ...). The initial
@@ -55,7 +99,7 @@ function loadHealthWidgetData(
   let lastCommitEpoch: number | null = null;
   let lastCommitMessage: string | null = null;
 
-  const projectState = detectHealthWidgetProjectState(basePath);
+  const projectState = getCachedProjectState(basePath, options?.forceProjectState);
 
   try {
     const prefs = loadEffectiveGSDPreferences();
@@ -83,13 +127,6 @@ function loadHealthWidgetData(
     } catch { /* non-fatal */ }
   }
 
-  // ── Last commit info ── (git spawns — gated like the other expensive checks)
-  if (includeChecks) {
-    const commit = loadLastCommitInfo(basePath);
-    lastCommitEpoch = commit.epoch;
-    lastCommitMessage = commit.message;
-  }
-
   return {
     projectState,
     budgetCeiling,
@@ -104,10 +141,8 @@ function loadHealthWidgetData(
 }
 
 // Non-blocking variant used by the widget's background refresh: the cheap fields
-// come from the synchronous snapshot, then provider + environment checks are
-// layered in off the event-loop critical path (env checks run concurrently via
-// runEnvironmentChecksAsync). Keeps the always-on widget from stalling the UI on
-// its initial enrichment or its 60s refresh.
+// come from the synchronous snapshot, then provider, environment, and last-commit
+// checks are layered in off the event-loop critical path.
 async function loadHealthWidgetDataAsync(basePath: string): Promise<HealthWidgetData> {
   const data = loadHealthWidgetData(basePath, { includeChecks: false });
   let providerIssue = data.providerIssue;
@@ -115,7 +150,7 @@ async function loadHealthWidgetDataAsync(basePath: string): Promise<HealthWidget
   let environmentWarningCount = 0;
 
   try {
-    providerIssue = summariseProviderIssues(runProviderChecks());
+    providerIssue = summariseProviderIssues(await runProviderChecksAsync());
   } catch { /* non-fatal */ }
 
   try {
@@ -126,7 +161,7 @@ async function loadHealthWidgetDataAsync(basePath: string): Promise<HealthWidget
     }
   } catch { /* non-fatal */ }
 
-  const commit = loadLastCommitInfo(basePath);
+  const commit = await loadLastCommitInfoAsync(basePath);
 
   return {
     ...data,
@@ -141,8 +176,6 @@ async function loadHealthWidgetDataAsync(basePath: string): Promise<HealthWidget
 
 // ── Widget init ────────────────────────────────────────────────────────────────
 
-const REFRESH_INTERVAL_MS = 60_000;
-
 /**
  * Initialize the always-on gsd-health widget (belowEditor).
  * Call once from the extension entry point after context is available.
@@ -152,13 +185,17 @@ export function initHealthWidget(ctx: ExtensionContext): void {
 
   const basePath = projectRoot();
 
+  // Re-init must reflect filesystem changes immediately; the TTL cache is for
+  // interval refreshes, not this one-off synchronous paint.
+  projectStateCache.delete(basePath);
+
   // String-array fallback — used in RPC mode (factory is a no-op there).
   // Skip the expensive provider/environment doctor checks here: this runs
   // synchronously on the interactive-startup path, where running them would
   // block first paint by ~0.9s (lsof/docker probes, otherwise run again
   // immediately by the factory below). The factory's async refresh fills in
   // real health once the screen is up.
-  const initialData = loadHealthWidgetData(basePath, { includeChecks: false });
+  const initialData = loadHealthWidgetData(basePath, { includeChecks: false, forceProjectState: true });
   ctx.ui.setWidget("gsd-health", buildHealthLines(initialData), { placement: "belowEditor" });
 
   // Factory-based widget for TUI mode — replaces the string-array above

package/src/resources/extensions/gsd/json-persistence.ts

@@ -62,6 +62,26 @@ export function saveJsonFile<T>(filePath: string, data: T): void {
   }
 }
 
+/**
+ * Save a JSON file atomically using compact serialization.
+ *
+ * Intended for machine-only ledgers where pretty-printing has no consumer.
+ * Keeps the same write-tmp-rename safety and non-fatal error behavior as
+ * saveJsonFile.
+ */
+export function saveJsonFileCompact<T>(filePath: string, data: T): void {
+  try {
+    mkdirSync(dirname(filePath), { recursive: true });
+    // Use randomized tmp suffix to prevent concurrent-write data loss
+    const tmp = `${filePath}.tmp.${randomBytes(4).toString("hex")}`;
+    writeFileSync(tmp, JSON.stringify(data) + "\n", "utf-8");
+    renameSync(tmp, filePath);
+    // No cleanup needed — renameSync atomically removes tmp on success
+  } catch {
+    // Non-fatal — don't let persistence failures break operation
+  }
+}
+
 /**
  * Write a JSON file atomically (write to .tmp, then rename).
  * Creates parent directories as needed. Non-fatal on error.

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

@@ -35,8 +35,8 @@ interface SynthesizedRow {
  * - Idempotent (per-row): each migrated memory carries
  *   `structured_fields.sourceKnowledgeId = "<P|L>NNN"`. Rows whose ID is
  *   already present in the memory store are skipped.
- * - 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.
  * - Rules (K###) are intentionally skipped — they remain manually maintained
  *   in `KNOWLEDGE.md` per ADR-013.
  *
@@ -69,14 +69,20 @@ export function backfillKnowledgeToMemories(basePath: string): number {
       const matchPattern = `%"sourceKnowledgeId":"${synth.id}"%`;
       if (checkExisting.get({ ":pattern": matchPattern })) continue;
 
-      const id = createMemory({
-        category: synth.category,
-        content: synth.content,
-        scope: synth.scope,
-        confidence: 0.85,
-        structuredFields: synth.structuredFields,
-      });
-      if (id) written += 1;
+      try {
+        const id = createMemory({
+          category: synth.category,
+          content: synth.content,
+          scope: synth.scope,
+          confidence: 0.85,
+          structuredFields: synth.structuredFields,
+        });
+        if (id) written += 1;
+      } catch (rowErr) {
+        const message = rowErr instanceof Error ? rowErr.message : String(rowErr);
+        logWarning("knowledge-backfill", `KNOWLEDGE.md -> memories backfill skipped ${synth.id}: ${message}`);
+        continue;
+      }
     }
 
     return written;

package/src/resources/extensions/gsd/layout-policy.ts

@@ -47,8 +47,9 @@ export function dbPath(basePath: string): string {
  * Used by the renderer to derive the phase number from the DB's milestone_id.
  */
 export function milestoneIdToPhaseNum(milestoneId: string): number {
-  // No $ anchor: accepts bare (M012) and team-suffixed (M012-abc123) IDs.
+  // No $ anchor: accepts bare (M012), team-suffixed (M012-abc123), and legacy numeric IDs.
   const m = milestoneId.match(/^M0*(\d+)/i);
+  if (!m && /^\d+$/.test(milestoneId)) return Number.parseInt(milestoneId, 10);
   return m ? Number.parseInt(m[1]!, 10) : 1;
 }
 

package/src/resources/extensions/gsd/markdown-renderer.ts

@@ -25,6 +25,7 @@ import {
   insertArtifact,
   deleteArtifactByPath,
   getGateResults,
+  isDbAvailable,
 } from "./gsd-db.js";
 import type { MilestoneRow, ArtifactRow } from "./db-milestone-artifact-rows.js";
 import type { SliceRow, TaskRow } from "./db-task-slice-rows.js";
@@ -631,16 +632,8 @@ export async function renderRoadmapCheckboxes(
   basePath: string,
   milestoneId: string,
 ): Promise<boolean> {
-  const slices = getMilestoneSlices(milestoneId);
-  if (slices.length === 0) {
-    process.stderr.write(
-      `markdown-renderer: no slices found for milestone ${milestoneId}\n`,
-    );
-    return false;
-  }
-
-  await renderRoadmapFromDb(basePath, milestoneId);
-  return true;
+  const rendered = await renderRoadmapFromDb(basePath, milestoneId);
+  return !("skipped" in rendered);
 }
 
 /**
@@ -737,7 +730,8 @@ function isAutoRecoveryPlaceholderPlan(content: string): boolean {
  * projection (the 4S/0T-vs-5S/13T drift class). The artifacts table is an
  * output sink, never a render input.
  *
- * @returns true if the plan was written, false on skip/error
+ * @returns true if the plan was written, false when the DB slice has no tasks
+ * @throws when the DB connection is unavailable or the render write fails
  */
 export async function renderPlanCheckboxes(
   basePath: string,
@@ -747,6 +741,9 @@ export async function renderPlanCheckboxes(
 ): Promise<boolean> {
   const tasks = getSliceTasks(milestoneId, sliceId);
   if (tasks.length === 0) {
+    if (!isDbAvailable()) {
+      throw new Error(`database unavailable while rendering plan checkboxes for ${milestoneId}/${sliceId}`);
+    }
     process.stderr.write(
       `markdown-renderer: no tasks found for ${milestoneId}/${sliceId}\n`,
     );

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;
     }

package/src/resources/extensions/gsd/metrics.ts

@@ -19,7 +19,7 @@ import { openSync, closeSync, unlinkSync, statSync, writeFileSync } from "node:f
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
 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";
@@ -873,7 +873,7 @@ export function pruneMetricsLedger(base: string, keepCount: number): number {
   if (!disk || disk.units.length <= keepCount) return 0;
   const removed = disk.units.length - keepCount;
   disk.units = keepNewestUnits(disk.units, keepCount);
-  saveJsonFile(metricsPath(base), disk);
+  saveJsonFileCompact(metricsPath(base), disk);
   // Keep the in-memory ledger in sync if it is loaded for this session.
   if (ledger) {
     ledger.units = keepNewestUnits(ledger.units, keepCount);
@@ -1041,7 +1041,7 @@ function saveLedger(base: string, data: MetricsLedger): void {
           : dataUnits;
       merged.sort(compareUnitsByTime);
       data.units = keepNewestUnits(merged);
-      saveJsonFile(path, data);
+      saveJsonFileCompact(path, data);
     } finally {
       releaseLock(lockPath);
     }
@@ -1053,6 +1053,6 @@ function saveLedger(base: string, data: MetricsLedger): void {
     // 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);
+    saveJsonFileCompact(path, data);
   }
 }