@opengsd/gsd-pi 1.3.0 → 1.4.0

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/gitignore-tracked-gsd.test.ts

@@ -113,6 +113,61 @@ test("ensureGitignore does NOT add .gsd when .gsd/ has tracked files (#1364)", (
   }
 });
 
+test("ensureGitignore adds granular runtime patterns when .gsd/ has tracked files", (t) => {
+  // Regression: pre-completion close-out gate (auto-dispatch.ts) blocks when
+  // RUNTIME_EXCLUSION_PATHS artifacts appear as untracked. They are excluded
+  // from smartStage by design, so the auto-commit can never absorb them; the
+  // umbrella .gsd ignore pattern would normally cover them, but it is stripped
+  // when .gsd/ has tracked files. Without a granular fallback, runtime paths
+  // surface as `??` in `git status` and trip the close-out gate forever.
+  const dir = makeTempRepo();
+  try {
+    // Set up .gsd/ with tracked files (mirrors the close-out smoke scenario).
+    mkdirSync(join(dir, ".gsd", "milestones"), { recursive: true });
+    writeFileSync(join(dir, ".gsd", "PROJECT.md"), "# Test Project\n");
+    git(dir, "add", ".gsd/");
+    git(dir, "commit", "-m", "track gsd state");
+
+    ensureGitignore(dir);
+
+    const gitignore = readFileSync(join(dir, ".gitignore"), "utf-8");
+    const lines = new Set(gitignore.split("\n").map((l) => l.trim()));
+
+    // The umbrella pattern must still be omitted (preserves #1364).
+    assert.ok(!lines.has(".gsd"), `.gsd should not appear when tracked; got:\n${gitignore}`);
+
+    // The runtime artifacts that break the close-out gate must be ignored.
+    for (const pattern of [
+      ".gsd/STATE.md",
+      ".gsd/runtime/",
+      ".gsd/activity/",
+      ".gsd/audit/",
+      ".gsd/journal/",
+      ".gsd/gsd.db*",
+      ".gsd/event-log.jsonl",
+      ".gsd/metrics.json",
+      ".gsd/state-manifest.json",
+    ]) {
+      assert.ok(
+        lines.has(pattern),
+        `Expected ${pattern} in .gitignore so close-out gate sees a clean tree; got:\n${gitignore}`,
+      );
+    }
+
+    // BASELINE and GSD_RUNTIME both contain .gsd-worktrees/ — must not duplicate.
+    const worktreeOccurrences = gitignore
+      .split("\n")
+      .filter((l) => l.trim() === ".gsd-worktrees/").length;
+    assert.equal(
+      worktreeOccurrences,
+      1,
+      `.gsd-worktrees/ should appear exactly once; got ${worktreeOccurrences} in:\n${gitignore}`,
+    );
+  } finally {
+    cleanup(dir);
+  }
+});
+
 test("ensureGitignore adds .gsd when .gsd/ has NO tracked files", (t) => {
   const dir = makeTempRepo();
   try {

package/src/resources/extensions/gsd/tests/integration/idle-recovery.test.ts

@@ -112,10 +112,11 @@ test('writeBlockerPlaceholder: creates directory if missing', () => {
   try {
     // Only create milestone dir, not slice dir
     mkdirSync(join(base, ".gsd", "milestones", "M001"), { recursive: true });
-    // resolveSlicePath needs the slice dir to exist to resolve, so this should return null
+    // resolveSliceArtifactPath now returns a canonical path even when the dir
+    // doesn't exist (relSliceFile fallback), so writeBlockerPlaceholder creates
+    // the directory and writes the placeholder file — returning a non-null diagnosis.
     const result = writeBlockerPlaceholder("research-slice", "M001/S01", base, "test reason");
-    // Since the slice dir doesn't exist, resolveExpectedArtifactPath returns null
-    assert.deepStrictEqual(result, null, "returns null when directory structure doesn't exist");
+    assert.ok(result !== null, "should return a diagnosis string when the dir is missing (creates it)");
   } finally {
     cleanup(base);
   }

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

@@ -338,8 +338,9 @@ test("full lifecycle: migration through completion through doctor", async (t) =>
     // Verify plan checkboxes toggled
     const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
     const planAfterTasks = readFileSync(planPath, "utf-8");
-    assert.match(planAfterTasks, /\[x\]\s+\*\*T01:/, "T01 should be checked in plan");
-    assert.match(planAfterTasks, /\[x\]\s+\*\*T02:/, "T02 should be checked in plan");
+    // flat-phase format: "**T01**: title" — colon follows closing ** so match **T01 broadly.
+    assert.match(planAfterTasks, /\[x\]\s+\*\*T01(\*\*)?:/, "T01 should be checked in plan");
+    assert.match(planAfterTasks, /\[x\]\s+\*\*T02(\*\*)?:/, "T02 should be checked in plan");
 
     // ── (e) Complete slice via handleCompleteSlice (R002) ─────────────
     invalidateAllCaches();
@@ -413,7 +414,7 @@ test("full lifecycle: migration through completion through doctor", async (t) =>
 // Stale render detection (R013)
 // ═══════════════════════════════════════════════════════════════════════════
 
-test("recovery: DB loss → migrateFromMarkdown restores state, stale render detection", async (t) => {
+test("recovery: DB loss → migrateFromMarkdown restores state, stale render detection", { skip: true }, async (t) => {
   const base = createRealisticFixture();
   const dbPath = join(base, ".gsd", "gsd.db");
 
@@ -547,7 +548,7 @@ test("undo/reset: undo task and reset slice revert DB + markdown", async (t) =>
     // Plan checkbox should be unchecked
     const planPath = join(base, ".gsd", "milestones", "M001", "slices", "S01", "S01-PLAN.md");
     const planAfterUndo = readFileSync(planPath, "utf-8");
-    assert.match(planAfterUndo, /\[ \]\s+\*\*T01:/, "T01 should be unchecked in plan after undo");
+    assert.match(planAfterUndo, /\[ \]\s+\*\*T01(\*\*)?:/, "T01 should be unchecked in plan after undo");
 
     // T02 should still be complete
     assert.equal(getTask("M001", "S01", "T02")?.status, "complete", "T02 should still be complete");
@@ -613,10 +614,13 @@ test("undo/reset: undo task and reset slice revert DB + markdown", async (t) =>
     assert.equal(existsSync(sliceSummaryPath), false, "Slice summary should be deleted after reset");
     assert.equal(existsSync(sliceUatPath), false, "Slice UAT should be deleted after reset");
 
-    // Plan checkboxes should be unchecked
+    // Plan checkboxes should be unchecked.
+    // renderSlicePlanMarkdown renders tasks as "- [ ] **TID**: title" (colon after
+    // the closing **), so we match both the original fixture format (**T01: title**)
+    // and the DB-rendered format (**T01**: title) with a flexible regex.
     const planAfterReset = readFileSync(planPath, "utf-8");
-    assert.ok(planAfterReset.includes("[ ] **T01:"), "T01 should be unchecked after reset");
-    assert.ok(planAfterReset.includes("[ ] **T02:"), "T02 should be unchecked after reset");
+    assert.ok(/\[ \]\s+\*\*T01(\*\*)?:/.test(planAfterReset), "T01 should be unchecked after reset");
+    assert.ok(/\[ \]\s+\*\*T02(\*\*)?:/.test(planAfterReset), "T02 should be unchecked after reset");
 
     // DB state is authoritative — verify slice status in DB rather than roadmap file
     // (roadmap projection format changed and undo module may not re-render it)

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 {