@opengsd/gsd-pi 1.3.0-dev.65546769 → 1.3.0-dev.965d1788

package/src/resources/extensions/gsd/tests/integration/git-service.test.ts

@@ -3,7 +3,7 @@
 import { describe, test } from 'node:test';
 import assert from 'node:assert/strict';
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, existsSync, symlinkSync, readFileSync, chmodSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { join, dirname, delimiter } from "node:path";
 import { tmpdir } from "node:os";
 import { execFileSync, execSync } from "node:child_process";
 
@@ -23,6 +23,7 @@ import {
   type PreMergeCheckResult,
   type TaskCommitContext,
 } from "../../git-service.ts";
+import { GIT_NO_PROMPT_ENV } from "../../git-constants.ts";
 import { nativeAddAllWithExclusions, nativeHasChanges, _resetHasChangesCache } from "../../native-git-bridge.ts";
 function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
@@ -293,12 +294,13 @@ describe('git-service', async () => {
 
   assert.deepStrictEqual(
     RUNTIME_EXCLUSION_PATHS.length,
-    17,
-    "exactly 17 runtime exclusion paths"
+    18,
+    "exactly 18 runtime exclusion paths"
   );
 
   const expectedPaths = [
     ".gsd-worktrees/",
+    ".gsd-backups/**",
     ".gsd/activity/",
     ".gsd/audit/",
     ".gsd/forensics/",
@@ -405,6 +407,49 @@ describe('git-service', async () => {
     }).trim();
   }
 
+  function findGitExecutable(): string {
+    const command = process.platform === "win32" ? "where git" : "command -v git";
+    const output = execSync(command, { encoding: "utf-8" });
+    const found = output.split(/\r?\n/).map(line => line.trim()).find(Boolean);
+    assert.ok(found, "git executable is available");
+    return found;
+  }
+
+  function installGitRmCachedCounterShim(shimDir: string): void {
+    const shimScript = join(shimDir, "git-shim.cjs");
+    writeFileSync(shimScript, `
+const { appendFileSync } = require("node:fs");
+const { spawnSync } = require("node:child_process");
+
+const args = process.argv.slice(2);
+if (args[0] === "rm" && args[1] === "--cached") {
+  appendFileSync(process.env.GSD_GIT_SHIM_LOG, args.join("\\0") + "\\n");
+}
+
+const result = spawnSync(process.env.GSD_REAL_GIT || "git", args, {
+  stdio: "inherit",
+  env: process.env,
+});
+if (result.error) {
+  console.error(result.error.message);
+  process.exit(1);
+}
+process.exit(result.status ?? 0);
+`.trimStart(), "utf-8");
+
+    const posixShim = join(shimDir, "git");
+    const quotedScript = `'${shimScript.replace(/'/g, "'\\''")}'`;
+    writeFileSync(posixShim, `#!/bin/sh\nexec node ${quotedScript} "$@"\n`, "utf-8");
+    chmodSync(posixShim, 0o755);
+
+    writeFileSync(join(shimDir, "git.cmd"), "@echo off\r\nnode \"%~dp0git-shim.cjs\" %*\r\n", "utf-8");
+  }
+
+  function countRmCachedInvocations(logFile: string): number {
+    if (!existsSync(logFile)) return 0;
+    return readFileSync(logFile, "utf-8").split(/\r?\n/).filter(Boolean).length;
+  }
+
   // ─── GitServiceImpl: smart staging ─────────────────────────────────────
 
   test('GitServiceImpl: smart staging', () => {
@@ -447,6 +492,80 @@ describe('git-service', async () => {
     rmSync(repo, { recursive: true, force: true });
   });
 
+  test('GitServiceImpl: runtime cleanup runs once per repo across service instances', () => {
+    const repo = initTempRepo();
+    const shimDir = mkdtempSync(join(tmpdir(), "gsd-git-rm-shim-"));
+    const logFile = join(shimDir, "git-rm-cached.log");
+    const originalPath = process.env.PATH;
+    const originalRealGit = process.env.GSD_REAL_GIT;
+    const originalShimLog = process.env.GSD_GIT_SHIM_LOG;
+    const originalSafePath = GIT_NO_PROMPT_ENV.PATH;
+    const originalSafeRealGit = GIT_NO_PROMPT_ENV.GSD_REAL_GIT;
+    const originalSafeShimLog = GIT_NO_PROMPT_ENV.GSD_GIT_SHIM_LOG;
+
+    try {
+      installGitRmCachedCounterShim(shimDir);
+      const realGit = findGitExecutable();
+      process.env.GSD_REAL_GIT = realGit;
+      process.env.GSD_GIT_SHIM_LOG = logFile;
+      process.env.PATH = `${shimDir}${delimiter}${originalPath ?? ""}`;
+      GIT_NO_PROMPT_ENV.GSD_REAL_GIT = realGit;
+      GIT_NO_PROMPT_ENV.GSD_GIT_SHIM_LOG = logFile;
+      GIT_NO_PROMPT_ENV.PATH = process.env.PATH;
+
+      createFile(repo, "src/first.ts", "first");
+      const first = new GitServiceImpl(repo).commit({ message: "test: first cleanup pass" });
+      assert.deepStrictEqual(first, "test: first cleanup pass", "first commit succeeds");
+      assert.deepStrictEqual(
+        countRmCachedInvocations(logFile),
+        RUNTIME_EXCLUSION_PATHS.length,
+        "first service instance checks each runtime exclusion once",
+      );
+
+      createFile(repo, "src/second.ts", "second");
+      const second = new GitServiceImpl(repo).commit({ message: "test: second cleanup pass" });
+      assert.deepStrictEqual(second, "test: second cleanup pass", "second commit succeeds");
+      assert.deepStrictEqual(
+        countRmCachedInvocations(logFile),
+        RUNTIME_EXCLUSION_PATHS.length,
+        "fresh service instance for the same repo does not rerun runtime cleanup",
+      );
+    } finally {
+      if (originalPath === undefined) {
+        delete process.env.PATH;
+      } else {
+        process.env.PATH = originalPath;
+      }
+      if (originalRealGit === undefined) {
+        delete process.env.GSD_REAL_GIT;
+      } else {
+        process.env.GSD_REAL_GIT = originalRealGit;
+      }
+      if (originalShimLog === undefined) {
+        delete process.env.GSD_GIT_SHIM_LOG;
+      } else {
+        process.env.GSD_GIT_SHIM_LOG = originalShimLog;
+      }
+      if (originalSafePath === undefined) {
+        delete GIT_NO_PROMPT_ENV.PATH;
+      } else {
+        GIT_NO_PROMPT_ENV.PATH = originalSafePath;
+      }
+      if (originalSafeRealGit === undefined) {
+        delete GIT_NO_PROMPT_ENV.GSD_REAL_GIT;
+      } else {
+        GIT_NO_PROMPT_ENV.GSD_REAL_GIT = originalSafeRealGit;
+      }
+      if (originalSafeShimLog === undefined) {
+        delete GIT_NO_PROMPT_ENV.GSD_GIT_SHIM_LOG;
+      } else {
+        GIT_NO_PROMPT_ENV.GSD_GIT_SHIM_LOG = originalSafeShimLog;
+      }
+      rmSync(repo, { recursive: true, force: true });
+      rmSync(shimDir, { recursive: true, force: true });
+    }
+  });
+
   test('GitServiceImpl: task autoCommit skips keyFiles inside submodules', () => {
     const repo = initTempRepo();
     const subSrc = mkdtempSync(join(tmpdir(), "gsd-git-submodule-src-"));
@@ -1505,11 +1624,13 @@ describe('git-service', async () => {
     // Create and track runtime files (simulates pre-.gitignore state)
     mkdirSync(join(repo, ".gsd", "activity"), { recursive: true });
     mkdirSync(join(repo, ".gsd", "runtime"), { recursive: true });
+    mkdirSync(join(repo, ".gsd-backups", "migrate-old"), { recursive: true });
     writeFileSync(join(repo, ".gsd", "completed-units.json"), '["u1"]');
     writeFileSync(join(repo, ".gsd", "metrics.json"), '{}');
     writeFileSync(join(repo, ".gsd", "STATE.md"), "# State");
     writeFileSync(join(repo, ".gsd", "activity", "log.jsonl"), "{}");
     writeFileSync(join(repo, ".gsd", "runtime", "data.json"), "{}");
+    writeFileSync(join(repo, ".gsd-backups", "migrate-old", "marker.txt"), "backup");
     writeFileSync(join(repo, "src.ts"), "code");
     runGit(repo, ["add", "-A"]);
     runGit(repo, ["commit", "-m", "init"]);
@@ -1518,6 +1639,8 @@ describe('git-service', async () => {
     const trackedBefore = run("git ls-files .gsd/", repo);
     assert.ok(trackedBefore.includes("completed-units.json"), "untrack: precondition — completed-units tracked");
     assert.ok(trackedBefore.includes("metrics.json"), "untrack: precondition — metrics tracked");
+    const backupTrackedBefore = run("git ls-files .gsd-backups/", repo);
+    assert.ok(backupTrackedBefore.includes("marker.txt"), "untrack: precondition — migration backup tracked");
 
     // Run untrackRuntimeFiles
     untrackRuntimeFiles(repo);
@@ -1525,6 +1648,8 @@ describe('git-service', async () => {
     // Runtime files should be removed from the index
     const trackedAfter = run("git ls-files .gsd/", repo);
     assert.deepStrictEqual(trackedAfter, "", "untrack: all runtime files removed from index");
+    const backupTrackedAfter = run("git ls-files .gsd-backups/", repo);
+    assert.deepStrictEqual(backupTrackedAfter, "", "untrack: migration backups removed from index");
 
     // Non-runtime files remain tracked
     const srcTracked = run("git ls-files src.ts", repo);
@@ -1535,6 +1660,8 @@ describe('git-service', async () => {
       "untrack: completed-units.json still on disk");
     assert.ok(existsSync(join(repo, ".gsd", "metrics.json")),
       "untrack: metrics.json still on disk");
+    assert.ok(existsSync(join(repo, ".gsd-backups", "migrate-old", "marker.txt")),
+      "untrack: migration backup still on disk");
 
     // Idempotent — running again doesn't error
     untrackRuntimeFiles(repo);

package/src/resources/extensions/gsd/tests/integration/queue-active-milestone-context-budget.test.ts

@@ -0,0 +1,93 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+import { buildExistingMilestonesContext } from "../../guided-flow-queue.ts";
+import type { GSDState, MilestoneRegistryEntry } from "../../types.ts";
+
+const LARGE_BODY = "A".repeat(150_000);
+const LARGE_DRAFT = "D".repeat(150_000);
+const LARGE_ROADMAP = "R".repeat(150_000);
+
+function makeState(registry: MilestoneRegistryEntry[]): GSDState {
+  return {
+    activeMilestone: registry.find(m => m.status === "active") ?? null,
+    activeSlice: null,
+    activeTask: null,
+    phase: "executing",
+    recentDecisions: [],
+    blockers: [],
+    nextAction: "",
+    registry,
+  };
+}
+
+function writeMilestoneArtifact(base: string, mid: string, suffix: string, content: string): void {
+  mkdirSync(join(base, ".gsd", "milestones", mid), { recursive: true });
+  writeFileSync(join(base, ".gsd", "milestones", mid, `${mid}-${suffix}.md`), content);
+}
+
+describe("queue active/pending milestone context budget", () => {
+  test("summarizes active and pending artifacts with source paths and bounded excerpts", async () => {
+    const tmpBase = mkdtempSync(join(tmpdir(), "gsd-queue-active-budget-"));
+    try {
+      writeMilestoneArtifact(tmpBase, "M001", "CONTEXT", `# Active context\n\n${LARGE_BODY}\nEND_ACTIVE_CONTEXT`);
+      writeMilestoneArtifact(tmpBase, "M001", "ROADMAP", `# Active roadmap\n\n${LARGE_ROADMAP}\nEND_ACTIVE_ROADMAP`);
+      writeMilestoneArtifact(tmpBase, "M002", "CONTEXT-DRAFT", `# Pending draft\n\n${LARGE_DRAFT}\nEND_PENDING_DRAFT`);
+      writeMilestoneArtifact(tmpBase, "M002", "ROADMAP", `# Pending roadmap\n\n${LARGE_ROADMAP}\nEND_PENDING_ROADMAP`);
+
+      const registry: MilestoneRegistryEntry[] = [
+        { id: "M001", title: "Active milestone", status: "active" },
+        { id: "M002", title: "Pending milestone", status: "pending" },
+      ];
+
+      const context = await buildExistingMilestonesContext(tmpBase, ["M001", "M002"], makeState(registry));
+
+      assert.match(context, /Source: `.gsd\/milestones\/M001\/M001-CONTEXT.md`/);
+      assert.match(context, /Source: `.gsd\/milestones\/M001\/M001-ROADMAP.md`/);
+      assert.match(context, /Source: `.gsd\/milestones\/M002\/M002-CONTEXT-DRAFT.md`/);
+      assert.match(context, /Source: `.gsd\/milestones\/M002\/M002-ROADMAP.md`/);
+      assert.match(context, /Read `.gsd\/milestones\/M001\/M001-CONTEXT.md` for full content/);
+      assert.equal(context.includes("END_ACTIVE_CONTEXT"), false);
+      assert.equal(context.includes("END_ACTIVE_ROADMAP"), false);
+      assert.equal(context.includes("END_PENDING_DRAFT"), false);
+      assert.equal(context.includes("END_PENDING_ROADMAP"), false);
+    } finally {
+      rmSync(tmpBase, { recursive: true, force: true });
+    }
+  });
+
+  test("caps the total existing milestones context", async () => {
+    const tmpBase = mkdtempSync(join(tmpdir(), "gsd-queue-total-budget-"));
+    try {
+      const registry: MilestoneRegistryEntry[] = [];
+      const milestoneIds: string[] = [];
+      for (let i = 1; i <= 5; i++) {
+        const mid = `M${String(i).padStart(3, "0")}`;
+        milestoneIds.push(mid);
+        registry.push({ id: mid, title: `Pending milestone ${i}`, status: "pending" });
+        writeMilestoneArtifact(tmpBase, mid, "CONTEXT", `# ${mid} context\n\n${LARGE_BODY}\nEND_${mid}_CONTEXT`);
+        writeMilestoneArtifact(tmpBase, mid, "ROADMAP", `# ${mid} roadmap\n\n${LARGE_ROADMAP}\nEND_${mid}_ROADMAP`);
+      }
+
+      const context = await buildExistingMilestonesContext(tmpBase, milestoneIds, makeState(registry));
+
+      assert.ok(
+        context.length <= 120_000,
+        `expected total context to stay within budget, got ${context.length} chars`,
+      );
+      assert.match(context, /Existing milestones context truncated/);
+      for (let i = 1; i <= 5; i++) {
+        const mid = `M${String(i).padStart(3, "0")}`;
+        assert.match(context, new RegExp(`### ${mid}: Pending milestone ${i}`));
+        assert.match(context, new RegExp(`Source: \`.gsd/milestones/${mid}/${mid}-CONTEXT.md\``));
+        assert.match(context, new RegExp(`Source: \`.gsd/milestones/${mid}/${mid}-ROADMAP.md\``));
+      }
+      assert.equal(context.includes("END_M005_ROADMAP"), false);
+    } finally {
+      rmSync(tmpBase, { recursive: true, force: true });
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/integration/quick-branch-lifecycle.test.ts

@@ -16,6 +16,7 @@ import { execSync } from "node:child_process";
 
 import { captureIntegrationBranch, getCurrentBranch } from "../../worktree.ts";
 import { readIntegrationBranch, QUICK_BRANCH_RE } from "../../git-service.ts";
+import { disableDebug, enableDebug, getDebugCounters } from "../../debug-logger.ts";
 
 function run(command: string, cwd: string): string {
   return execSync(command, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
@@ -205,16 +206,25 @@ test('cleanupQuickBranch: recovers from disk state (cross-session)', async () =>
 test('cleanupQuickBranch: no-op without pending state', async () => {
     const repo = createTestRepo();
     const origCwd = process.cwd();
-    process.chdir(repo);
-
-    const { cleanupQuickBranch } = await import("../../quick.ts");
-    const result = cleanupQuickBranch();
-
-    assert.ok(!result, "returns false when no pending state");
-    assert.deepStrictEqual(getCurrentBranch(repo), "main", "stays on main");
+    try {
+      process.chdir(repo);
+      enableDebug(repo);
 
-    process.chdir(origCwd);
-    rmSync(repo, { recursive: true, force: true });
+      const { cleanupQuickBranch } = await import("../../quick.ts");
+      const result = cleanupQuickBranch();
+      const firstGitInvocations = getDebugCounters().gitInvocations;
+      const secondResult = cleanupQuickBranch();
+
+      assert.ok(!result, "returns false when no pending state");
+      assert.ok(!secondResult, "still returns false when no pending state");
+      assert.deepStrictEqual(getDebugCounters().gitInvocations, firstGitInvocations,
+        "cached no-state cleanup does not re-run git branch inference");
+      assert.deepStrictEqual(getCurrentBranch(repo), "main", "stays on main");
+    } finally {
+      disableDebug();
+      process.chdir(origCwd);
+      rmSync(repo, { recursive: true, force: true });
+    }
 });
 
 test('cleanupQuickBranch: infers return state from current gsd/quick branch', async () => {
@@ -240,6 +250,43 @@ test('cleanupQuickBranch: infers return state from current gsd/quick branch', as
     }
 });
 
+  // ═══════════════════════════════════════════════════════════════════════
+  // cleanupQuickBranch: stale miss invalidated after mid-session branch switch
+  // ═══════════════════════════════════════════════════════════════════════
+test('cleanupQuickBranch: clears stale miss when branch switches to gsd/quick mid-session', async () => {
+    const repo = createTestRepo();
+    const origCwd = process.cwd();
+    try {
+      // Create a quick branch with real product work (so inference finds a diff)
+      run("git checkout -b gsd/quick/3-stale-miss", repo);
+      writeFileSync(join(repo, "stale.txt"), "stale miss test\n");
+      run("git add stale.txt", repo);
+      run('git commit -m "test: stale miss"', repo);
+      // Return to main so the first cleanupQuickBranch call records a miss
+      run("git checkout main", repo);
+
+      process.chdir(repo);
+      const { cleanupQuickBranch } = await import("../../quick.ts");
+
+      // First call: on main with no disk state → miss recorded (keyed to "main")
+      const result1 = cleanupQuickBranch();
+      assert.ok(!result1, "first call (on main) returns false — miss recorded");
+
+      // Simulate mid-session external branch switch to the stranded quick branch
+      run("git checkout gsd/quick/3-stale-miss", repo);
+
+      // Second call: branch changed from the recorded miss, so cache is invalidated
+      // and inferQuickReturnFromBranch runs — cleanup must succeed
+      const result2 = cleanupQuickBranch();
+      assert.ok(result2, "second call returns true after mid-session switch to quick branch");
+      assert.deepStrictEqual(getCurrentBranch(repo), "main",
+        "cleanup merged back to main after stale-miss invalidation");
+    } finally {
+      process.chdir(origCwd);
+      rmSync(repo, { recursive: true, force: true });
+    }
+});
+
   // ═══════════════════════════════════════════════════════════════════════
   // End-to-end: quick branch does NOT contaminate integration branch
   // ═══════════════════════════════════════════════════════════════════════

package/src/resources/extensions/gsd/tests/json-persistence-atomic.test.ts

@@ -19,6 +19,7 @@ import { tmpdir } from "node:os";
 
 import {
   saveJsonFile,
+  saveJsonFileCompact,
   loadJsonFile,
   writeJsonFileAtomic,
 } from "../json-persistence.ts";
@@ -56,6 +57,37 @@ test("saveJsonFile creates file with valid JSON content", () => {
   }
 });
 
+test("saveJsonFile keeps pretty-printed output for human-readable state", () => {
+  const dir = makeTempDir();
+  const filePath = join(dir, "pretty.json");
+
+  try {
+    const data = { foo: "bar", nested: { count: 42 } };
+    saveJsonFile(filePath, data);
+
+    const content = readFileSync(filePath, "utf-8");
+    assert.equal(content, JSON.stringify(data, null, 2) + "\n");
+  } finally {
+    cleanup(dir);
+  }
+});
+
+test("saveJsonFileCompact writes valid compact JSON content", () => {
+  const dir = makeTempDir();
+  const filePath = join(dir, "compact.json");
+
+  try {
+    const data = { foo: "bar", nested: { count: 42 } };
+    saveJsonFileCompact(filePath, data);
+
+    const content = readFileSync(filePath, "utf-8");
+    assert.equal(content, JSON.stringify(data) + "\n");
+    assert.deepEqual(JSON.parse(content), data);
+  } finally {
+    cleanup(dir);
+  }
+});
+
 test("saveJsonFile does not leave .tmp files on success", () => {
   const dir = makeTempDir();
   const filePath = join(dir, "clean.json");
@@ -72,6 +104,21 @@ test("saveJsonFile does not leave .tmp files on success", () => {
   }
 });
 
+test("saveJsonFileCompact does not leave .tmp files on success", () => {
+  const dir = makeTempDir();
+  const filePath = join(dir, "compact-clean.json");
+
+  try {
+    saveJsonFileCompact(filePath, { test: true });
+
+    const files = readdirSync(dir);
+    const tmpFiles = files.filter(f => f.includes(".tmp"));
+    assert.equal(tmpFiles.length, 0, `Unexpected .tmp files: ${tmpFiles.join(", ")}`);
+  } finally {
+    cleanup(dir);
+  }
+});
+
 test("saveJsonFile creates parent directories", () => {
   const dir = makeTempDir();
   const filePath = join(dir, "deep", "nested", "data.json");

package/src/resources/extensions/gsd/tests/knowledge-backfill-projection.test.ts

@@ -161,6 +161,41 @@ test("backfill is idempotent — second run on the same file is a no-op", () =>
   }
 });
 
+test("backfill skips a knowledge row whose memory insert throws and continues later rows", () => {
+  const base = makeTmpBase();
+  try {
+    writeKnowledgeMd(base, FIXTURE);
+
+    const adapter = _getAdapter();
+    assert.ok(adapter);
+    adapter.exec(`
+      CREATE TRIGGER fail_p002_memory_insert
+      BEFORE INSERT ON memories
+      WHEN json_extract(NEW.structured_fields, '$.sourceKnowledgeId') = 'P002'
+      BEGIN
+        SELECT RAISE(ABORT, 'poison knowledge P002');
+      END
+    `);
+
+    const written = backfillKnowledgeToMemories(base);
+    assert.equal(written, 2, "one poisoned row should not abort the batch");
+
+    const rows = adapter
+      .prepare(
+        "SELECT structured_fields FROM memories WHERE structured_fields LIKE '%\"sourceKnowledgeId\":\"%' ORDER BY seq",
+      )
+      .all() as Array<{ structured_fields: string }>;
+
+    assert.deepEqual(
+      rows.map((row) => JSON.parse(row.structured_fields).sourceKnowledgeId),
+      ["P001", "L001"],
+      "rows after the poisoned knowledge entry should still be migrated",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 test("backfill returns 0 when KNOWLEDGE.md is absent", () => {
   const base = makeTmpBase();
   try {

package/src/resources/extensions/gsd/tests/knowledge-cold-start.test.ts

@@ -136,8 +136,10 @@ test("#896 startup maintenance skips repeated sentinel work in one session", asy
   closeDatabase();
   assert.equal(isDbAvailable(), false);
 
+  let sessionId = "session-one";
   const ctx = {
     projectRoot: base,
+    sessionManager: { getSessionId: () => sessionId },
     ui: { notify: () => undefined },
   } as unknown as ExtensionContext;
 
@@ -190,6 +192,18 @@ test("#896 startup maintenance skips repeated sentinel work in one session", asy
     .prepare("SELECT COUNT(*) AS count FROM memories WHERE structured_fields LIKE '%\"sourceKnowledgeId\":\"P002\"%'")
     .get() as { count: number };
   assert.equal(secondPass.count, 0, "second startup in same session should not re-run KNOWLEDGE.md sentinel backfill");
+
+  sessionId = "session-two";
+  await buildBeforeAgentStartResult(
+    { prompt: "Inspect project knowledge in a new session", systemPrompt: "base system prompt" },
+    ctx,
+  );
+  await _flushDeferredContextMaintenanceForTest(base);
+
+  const nextSessionPass = adapter
+    .prepare("SELECT COUNT(*) AS count FROM memories WHERE structured_fields LIKE '%\"sourceKnowledgeId\":\"P002\"%'")
+    .get() as { count: number };
+  assert.equal(nextSessionPass.count, 1, "startup maintenance should run once for a later session");
 });
 
 test("#896 later turns reopen the project DB after startup maintenance is complete", async (t) => {

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

@@ -16,6 +16,7 @@ import {
   openDatabase,
   closeDatabase,
   insertDecision,
+  _getAdapter,
 } from "../gsd-db.ts";
 import { createMemory } from "../memory-store.ts";
 import {
@@ -271,6 +272,83 @@ test("scanConsolidationGaps combines decisions and KNOWLEDGE.md gaps in summary"
   }
 });
 
+test("scanConsolidationGaps collects memory source markers with one memories scan", () => {
+  const base = makeTmpBase();
+  try {
+    insertDecision({
+      id: "D001",
+      when_context: "2026-01-01",
+      scope: "M001",
+      decision: "Unmigrated decision",
+      choice: "A",
+      rationale: "x",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+    insertDecision({
+      id: "D002",
+      when_context: "2026-01-02",
+      scope: "M001",
+      decision: "Migrated decision",
+      choice: "B",
+      rationale: "y",
+      revisable: "yes",
+      made_by: "agent",
+      superseded_by: null,
+    });
+    createMemory({
+      category: "architecture",
+      content: "Migrated decision Chose: B. Rationale: y.",
+      scope: "M001",
+      structuredFields: { sourceDecisionId: "D002" },
+    });
+    createMemory({
+      category: "pattern",
+      content: "Migrated knowledge pattern",
+      scope: "project",
+      structuredFields: { sourceKnowledgeId: "P001" },
+    });
+    writeKnowledgeMd(
+      base,
+      `## Patterns
+
+| # | Pattern | Where | Notes |
+|---|---------|-------|-------|
+| P001 | Migrated knowledge pattern | scanner | covered |
+| P002 | Unmigrated knowledge pattern | scanner | gap |
+`,
+    );
+
+    const adapter = _getAdapter();
+    assert.ok(adapter);
+    const originalPrepare = adapter.prepare.bind(adapter);
+    const memorySql: string[] = [];
+    adapter.prepare = (sql: string) => {
+      if (sql.includes("FROM memories")) memorySql.push(sql);
+      return originalPrepare(sql);
+    };
+
+    const report = scanConsolidationGaps(base);
+    assert.equal(report.decisions.migrated, 1);
+    assert.equal(report.decisions.unmigrated, 1);
+    assert.equal(report.knowledge.migrated, 1);
+    assert.equal(report.knowledge.unmigrated, 1);
+    assert.equal(
+      memorySql.filter((sql) => sql.includes("SELECT structured_fields FROM memories")).length,
+      1,
+      "source marker detection should read memories once",
+    );
+    assert.equal(
+      memorySql.some((sql) => sql.includes("LIKE :pattern")),
+      false,
+      "scanner must not reintroduce per-row LIKE marker probes",
+    );
+  } finally {
+    cleanup(base);
+  }
+});
+
 // ─── reportConsolidationGaps ───────────────────────────────────────────────
 
 test("reportConsolidationGaps emits a notification + warning when gaps exist", () => {

package/src/resources/extensions/gsd/tests/merge-closeout-consistency-gate.test.ts

@@ -9,7 +9,15 @@ import { tmpdir } from "node:os";
 import { execFileSync } from "node:child_process";
 
 import { mergeMilestoneToMain } from "../auto-worktree.ts";
-import { closeDatabase, insertMilestone, openDatabase } from "../gsd-db.ts";
+import { checkCloseoutConsistencyGate } from "../closeout-consistency-gate.ts";
+import {
+  closeDatabase,
+  insertAssessment,
+  insertMilestone,
+  insertSlice,
+  insertTask,
+  openDatabase,
+} from "../gsd-db.ts";
 
 function git(args: string[], cwd: string): string {
   return execFileSync("git", args, {
@@ -61,3 +69,25 @@ test("mergeMilestoneToMain blocks when project DB closeout is still open", () =>
     if (existsSync(repo)) rmSync(repo, { recursive: true, force: true });
   }
 });
+
+test("closeout consistency treats deferred slices as inactive", () => {
+  try {
+    assert.equal(openDatabase(":memory:"), true);
+    insertMilestone({ id: "M001", title: "Milestone One", status: "complete" });
+    insertSlice({ milestoneId: "M001", id: "S01", title: "Done", status: "complete" });
+    insertTask({ milestoneId: "M001", sliceId: "S01", id: "T01", title: "Done", status: "complete" });
+    insertSlice({ milestoneId: "M001", id: "S02", title: "Deferred", status: "deferred" });
+    insertTask({ milestoneId: "M001", sliceId: "S02", id: "T02", title: "Deferred", status: "pending" });
+    insertAssessment({
+      path: "milestones/M001/M001-VALIDATION.md",
+      milestoneId: "M001",
+      status: "pass",
+      scope: "milestone-validation",
+      fullContent: "verdict: pass",
+    });
+
+    assert.deepEqual(checkCloseoutConsistencyGate("M001"), { ok: true });
+  } finally {
+    closeDatabase();
+  }
+});

package/src/resources/extensions/gsd/tests/metrics-prune-cache-invalidation.test.ts

@@ -112,6 +112,12 @@ describe("pruneMetricsLedger: invalidates scoped ledger cache", () => {
     // 3. Prune to keepCount=2 — should evict 3 old units from disk AND clear scopedLedgers.
     const removed = pruneMetricsLedger(tmpDir, 2);
     assert.equal(removed, 3, "pruneMetricsLedger should report 3 removed units");
+    const prunedRaw = readFileSync(metricsPath(tmpDir), "utf-8");
+    assert.equal(
+      prunedRaw,
+      JSON.stringify(JSON.parse(prunedRaw)) + "\n",
+      "pruneMetricsLedger should persist compact metrics.json",
+    );
 
     // 4. Snapshot a new unit via scope. This exercises the lazy-reload path
     //    (scopedLedgers was cleared by prune) and writes the result to disk.