@opengsd/gsd-pi 1.3.0-dev.eed73bea → 1.4.0-dev.5fc22c6f

package/src/resources/extensions/gsd/tests/flat-phase-migration.test.ts

@@ -2,12 +2,17 @@
 // File Purpose: Tests the one-time migration from nested to flat-phase layout.
 import test, { afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, readdirSync, readFileSync } from "node:fs";
+import { mkdtempSync, mkdirSync, renameSync, rmSync, writeFileSync, existsSync, readdirSync, readFileSync, utimesSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
 
-import { migrateToFlatPhase, needsFlatPhaseMigration } from "../flat-phase-migration.ts";
+import {
+  _setFlatPhaseMigrationFsOpsForTest,
+  migrateToFlatPhase,
+  needsFlatPhaseMigration,
+  pruneStaleFlatPhaseBackups,
+} from "../flat-phase-migration.ts";
 import { openDatabase, closeDatabase, insertMilestone, insertSlice, insertTask, getAllMilestones, getMilestoneSlices, getSliceTasks } from "../gsd-db.ts";
 
 const tmpDirs: string[] = [];
@@ -60,6 +65,42 @@ test("migrateToFlatPhase moves content from milestones/ to phases/", async () =>
   assert.ok(!existsSync(join(base, ".gsd", "milestones")), "milestones/ should be removed");
 });
 
+test("migrateToFlatPhase ignores and removes stale phase dirs from prior aborted runs", async () => {
+  const base = makeTmp();
+  const stalePhaseDir = join(base, ".gsd", "phases", "99-stale-aborted-run");
+  mkdirSync(stalePhaseDir, { recursive: true });
+
+  await migrateToFlatPhase(base);
+
+  assert.ok(existsSync(join(base, ".gsd", "phases", "01-foundation")), "current DB phase should render");
+  assert.equal(existsSync(stalePhaseDir), false, "stale pre-existing phase dir should be removed");
+});
+
+test("migrateToFlatPhase falls back to copy-delete when legacy rename is blocked", async (t) => {
+  const base = makeTmp();
+  const milestonesPath = join(base, ".gsd", "milestones");
+  const migratingPath = join(base, ".gsd", "milestones.migrating");
+  let blockedRenameAttempts = 0;
+
+  const restoreFsOps = _setFlatPhaseMigrationFsOpsForTest({
+    renameSync(src, dst) {
+      if (src === milestonesPath && dst === migratingPath) {
+        blockedRenameAttempts++;
+        throw Object.assign(new Error("simulated busy handle"), { code: "EPERM" });
+      }
+      return renameSync(src, dst);
+    },
+  });
+  t.after(restoreFsOps);
+
+  await migrateToFlatPhase(base);
+
+  assert.equal(blockedRenameAttempts, 1, "test should exercise the rename fallback path");
+  assert.ok(existsSync(join(base, ".gsd", "phases", "01-foundation")), "flat phase should render");
+  assert.equal(existsSync(milestonesPath), false, "legacy milestones dir should be removed");
+  assert.equal(existsSync(migratingPath), false, "staging dir should be removed after success");
+});
+
 test("migrateToFlatPhase creates a backup", async () => {
   const base = makeTmp();
   await migrateToFlatPhase(base);
@@ -112,3 +153,34 @@ test("migrateToFlatPhase preserves slice sidecar artifacts and skips recovery pl
     "recovery placeholder PLAN should not be promoted when no DB tasks can render a real plan",
   );
 });
+
+test("pruneStaleFlatPhaseBackups removes migrate-* dirs older than retention window", async () => {
+  const base = makeTmp();
+  await migrateToFlatPhase(base);
+
+  const backupRoot = join(base, ".gsd-backups");
+  assert.ok(existsSync(backupRoot), "backup should exist immediately after migration");
+
+  const staleDir = join(backupRoot, "migrate-stale");
+  mkdirSync(staleDir, { recursive: true });
+  writeFileSync(join(staleDir, "marker.txt"), "old backup\n", "utf-8");
+  const staleDate = new Date(Date.now() - 31 * 24 * 60 * 60 * 1000);
+  utimesSync(staleDir, staleDate, staleDate);
+
+  const removed = pruneStaleFlatPhaseBackups(base);
+  assert.equal(removed, 1, "stale migrate-* dir should be pruned");
+  assert.equal(existsSync(staleDir), false, "stale backup dir should be gone");
+  assert.ok(existsSync(backupRoot), "fresh migration backup should remain");
+});
+
+test("pruneStaleFlatPhaseBackups is a no-op while flat-phase migration is still needed", () => {
+  const base = makeTmp();
+  const backupRoot = join(base, ".gsd-backups", "migrate-stale");
+  mkdirSync(backupRoot, { recursive: true });
+  writeFileSync(join(backupRoot, "marker.txt"), "old backup\n", "utf-8");
+  const staleDate = new Date(Date.now() - 31 * 24 * 60 * 60 * 1000);
+  utimesSync(backupRoot, staleDate, staleDate);
+
+  assert.equal(pruneStaleFlatPhaseBackups(base), 0, "must not prune while migration is pending");
+  assert.ok(existsSync(backupRoot), "backup must remain until migration completes");
+});

package/src/resources/extensions/gsd/tests/flat-rate-routing-guard.test.ts

@@ -1,7 +1,6 @@
 /**
- * Regression test for #3453: dynamic model routing must be disabled for
- * flat-rate providers like GitHub Copilot where all models cost the same
- * per request — routing only degrades quality with no cost benefit.
+ * Regression tests for flat-rate provider detection and the explicit opt-out
+ * that suppresses dynamic routing for subscription providers.
  */
 
 import { describe, test } from "node:test";
@@ -9,7 +8,7 @@ import assert from "node:assert/strict";
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
-import { buildFlatRateContext, isFlatRateProvider, resolvePreferredModelConfig } from "../auto-model-selection.ts";
+import { buildFlatRateContext, isFlatRateProvider, resolvePreferredModelConfig, selectAndApplyModel } from "../auto-model-selection.ts";
 
 describe("flat-rate provider routing guard (#3453)", () => {
 
@@ -35,23 +34,18 @@ describe("flat-rate provider routing guard (#3453)", () => {
     assert.equal(isFlatRateProvider("openai"), false);
   });
 
-  test("resolvePreferredModelConfig returns undefined for copilot start model", () => {
+  test("resolvePreferredModelConfig synthesizes routing config for copilot start model when routing is enabled", () => {
     const originalCwd = process.cwd();
     const originalGsdHome = process.env.GSD_HOME;
     const tempProject = mkdtempSync(join(tmpdir(), "gsd-flat-rate-project-"));
     const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-flat-rate-home-"));
 
-    // When the user's start model is on a flat-rate provider,
-    // resolvePreferredModelConfig should not synthesize a routing
-    // config from tier_models — it should return undefined so the
-    // user's selected model is preserved.
     try {
       mkdirSync(join(tempProject, ".gsd"), { recursive: true });
       writeFileSync(
         join(tempProject, ".gsd", "PREFERENCES.md"),
         [
           "---",
-          "token_profile: burn-max",
           "dynamic_routing:",
           "  enabled: true",
           "  tier_models:",
@@ -70,10 +64,83 @@ describe("flat-rate provider routing guard (#3453)", () => {
         id: "claude-sonnet-4",
       });
 
-      // Should be undefined (no routing config created for flat-rate)
-      // Note: this only tests the synthesis guard — explicit per-unit config
-      // still takes precedence when the user configured one.
-      assert.equal(result, undefined, "Should not create routing config for copilot");
+      assert.deepEqual(result, {
+        primary: "claude-opus-4-6",
+        fallbacks: [],
+        source: "synthesized",
+      });
+    } finally {
+      process.chdir(originalCwd);
+      if (originalGsdHome === undefined) delete process.env.GSD_HOME;
+      else process.env.GSD_HOME = originalGsdHome;
+      rmSync(tempProject, { recursive: true, force: true });
+      rmSync(tempGsdHome, { recursive: true, force: true });
+    }
+  });
+
+  test("selectAndApplyModel runs synthesized dynamic routing for flat-rate start model", async () => {
+    const originalCwd = process.cwd();
+    const originalGsdHome = process.env.GSD_HOME;
+    const tempProject = mkdtempSync(join(tmpdir(), "gsd-flat-rate-project-"));
+    const tempGsdHome = mkdtempSync(join(tmpdir(), "gsd-flat-rate-home-"));
+    const setModelCalls: string[] = [];
+
+    try {
+      mkdirSync(join(tempProject, ".gsd"), { recursive: true });
+      writeFileSync(
+        join(tempProject, ".gsd", "PREFERENCES.md"),
+        [
+          "---",
+          "dynamic_routing:",
+          "  enabled: true",
+          "  hooks: false",
+          "  budget_pressure: false",
+          "  tier_models:",
+          "    light: claude-haiku-4-5",
+          "    standard: claude-sonnet-4-6",
+          "    heavy: claude-opus-4-6",
+          "---",
+        ].join("\n"),
+        "utf-8",
+      );
+      process.env.GSD_HOME = tempGsdHome;
+      process.chdir(tempProject);
+
+      const availableModels = [
+        { id: "claude-haiku-4-5", provider: "claude-code", api: "anthropic-messages" },
+        { id: "claude-sonnet-4-6", provider: "claude-code", api: "anthropic-messages" },
+        { id: "claude-opus-4-6", provider: "claude-code", api: "anthropic-messages" },
+      ];
+
+      const result = await selectAndApplyModel(
+        {
+          modelRegistry: { getAvailable: () => availableModels },
+          sessionManager: { getSessionId: () => "test-session" },
+          ui: { notify: () => {} },
+          model: { provider: "claude-code", id: "claude-opus-4-6", api: "anthropic-messages" },
+        } as any,
+        {
+          setModel: async (model: { provider: string; id: string }) => {
+            setModelCalls.push(`${model.provider}/${model.id}`);
+            return true;
+          },
+          emitBeforeModelSelect: async () => undefined,
+          getActiveTools: () => [],
+          emitAdjustToolSet: async () => undefined,
+          setActiveTools: () => {},
+        } as any,
+        "execute-task",
+        "M001/S01/T01",
+        tempProject,
+        undefined,
+        false,
+        { provider: "claude-code", id: "claude-opus-4-6" },
+        undefined,
+        true,
+      );
+
+      assert.deepEqual(setModelCalls, ["claude-code/claude-sonnet-4-6"]);
+      assert.deepEqual(result.routing, { tier: "standard", modelDowngraded: true });
     } finally {
       process.chdir(originalCwd);
       if (originalGsdHome === undefined) delete process.env.GSD_HOME;
@@ -220,9 +287,9 @@ describe("buildFlatRateContext()", () => {
   });
 });
 
-// ─── #4386: allow_flat_rate_providers opt-in ────────────────────────────────
+// ─── #4386/#1115: allow_flat_rate_providers override ────────────────────────
 
-describe("flat-rate routing opt-in (#4386)", () => {
+describe("flat-rate routing override (#4386/#1115)", () => {
   function withPrefs(prefsYaml: string, fn: () => void): void {
     const originalCwd = process.cwd();
     const originalGsdHome = process.env.GSD_HOME;
@@ -247,7 +314,7 @@ describe("flat-rate routing opt-in (#4386)", () => {
     }
   }
 
-  test("default (opt-in absent): flat-rate start model still returns undefined", () => {
+  test("default (allow absent): flat-rate start model still synthesizes routing config", () => {
     withPrefs(
       [
         "dynamic_routing:",
@@ -260,12 +327,13 @@ describe("flat-rate routing opt-in (#4386)", () => {
           provider: "claude-code",
           id: "claude-opus-4-6",
         });
-        assert.equal(result, undefined, "default must preserve #3453 bypass");
+        assert.ok(result, "routing config should be synthesized");
+        assert.equal(result!.primary, "claude-opus-4-6");
       },
     );
   });
 
-  test("opt-in: synthesizes a routing config for flat-rate start model", () => {
+  test("explicit allow: synthesizes a routing config for flat-rate start model", () => {
     withPrefs(
       [
         "dynamic_routing:",

package/src/resources/extensions/gsd/tests/gate-1b-orphan-discrimination.test.ts

@@ -14,6 +14,7 @@ import { tmpdir } from "node:os";
 
 import {
   checkAutoStartAfterDiscuss,
+  _getPendingAutoStart,
   setPendingAutoStart,
   clearPendingAutoStart,
 } from "../guided-flow.ts";
@@ -21,6 +22,7 @@ import { drainLogs } from "../workflow-logger.ts";
 import {
   openDatabase,
   closeDatabase,
+  getMilestone,
   insertMilestone,
 } from "../gsd-db.ts";
 
@@ -59,6 +61,12 @@ function mkBase(): string {
   return base;
 }
 
+function mkFlatBase(): string {
+  const base = mkdtempSync(join(tmpdir(), "gsd-gate1b-flat-"));
+  mkdirSync(join(base, ".gsd", "phases", "01-m001"), { recursive: true });
+  return base;
+}
+
 function writeContext(base: string): void {
   writeFileSync(
     join(base, ".gsd", "milestones", "M001", "M001-CONTEXT.md"),
@@ -66,6 +74,13 @@ function writeContext(base: string): void {
   );
 }
 
+function writeFlatContext(base: string): void {
+  writeFileSync(
+    join(base, ".gsd", "phases", "01-m001", "01-CONTEXT.md"),
+    "# M001: Test Milestone\n\nContext written by discuss phase.\n",
+  );
+}
+
 describe("Gate 1b discussion handoff in checkAutoStartAfterDiscuss", () => {
   let base: string;
   let cap: MockCapture;
@@ -142,4 +157,78 @@ describe("Gate 1b discussion handoff in checkAutoStartAfterDiscuss", () => {
     );
     assert.equal(gate1bLog, undefined, "Gate 1b must not log when CONTEXT.md is absent");
   });
+
+  test("flat-phase CONTEXT.md accepts handoff without a legacy milestone context file", () => {
+    base = mkFlatBase();
+    openDatabase(":memory:");
+    insertMilestone({ id: "M001", title: "Test Milestone", status: "queued" });
+    writeFlatContext(base);
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      startAuto: false,
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    const result = checkAutoStartAfterDiscuss();
+
+    assert.equal(result, true, "flat-phase context must be found by the handoff");
+    assert.equal(cap.messages.length, 0, "startAuto=false must suppress scheduling");
+    assert.deepEqual(cap.notifies[0], {
+      msg: "Milestone M001 context captured. Continuing the planning pipeline.",
+      level: "success",
+    });
+  });
+
+  test("DB-unavailable recovery blocks handoff instead of reporting success", () => {
+    base = mkFlatBase();
+    writeFlatContext(base);
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      startAuto: false,
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    const result = checkAutoStartAfterDiscuss();
+
+    assert.equal(result, false, "handoff must fail closed when the DB row cannot be confirmed");
+    assert.equal(cap.messages.length, 0, "must not schedule auto-start when DB is unavailable");
+    assert.equal(
+      cap.notifies.some(n => n.level === "success"),
+      false,
+      "must not report a successful handoff when DB recovery was skipped",
+    );
+    assert.ok(_getPendingAutoStart(base), "pending handoff should remain for a later recovery attempt");
+  });
+
+  test("missing DB row with CONTEXT.md inserts a queued row and accepts handoff", () => {
+    base = mkFlatBase();
+    openDatabase(":memory:");
+    writeFlatContext(base);
+
+    cap = mkCapture();
+    setPendingAutoStart(base, {
+      basePath: base,
+      milestoneId: "M001",
+      startAuto: false,
+      ctx: mkCtx(cap),
+      pi: mkPi(cap),
+    });
+
+    const result = checkAutoStartAfterDiscuss();
+
+    assert.equal(result, true, "successful insert should recover the missing row");
+    assert.equal(getMilestone("M001")?.status, "queued");
+    assert.deepEqual(cap.notifies[0], {
+      msg: "Milestone M001 context captured. Continuing the planning pipeline.",
+      level: "success",
+    });
+  });
 });

package/src/resources/extensions/gsd/tests/gitignore-bg-shell-runtime.test.ts

@@ -40,6 +40,10 @@ describe('ensureGitignore writes .bg-shell/ baseline (#4902)', () => {
         lines.has('.bg-shell/'),
         `.gitignore should include .bg-shell/. Got:\n${ignore}`,
       );
+      assert.ok(
+        lines.has('.gsd-backups/'),
+        `.gitignore should include .gsd-backups/. Got:\n${ignore}`,
+      );
     } finally {
       cleanup(dir);
     }

package/src/resources/extensions/gsd/tests/guided-flow-session-isolation.test.ts

@@ -20,6 +20,7 @@ import {
   clearPendingAutoStart,
   checkAutoStartAfterDiscuss,
 } from "../guided-flow.ts";
+import { closeDatabase, openDatabase } from "../gsd-db.ts";
 
 function pendingInput(basePath: string, milestoneId: string) {
   return {
@@ -34,6 +35,7 @@ function pendingInput(basePath: string, milestoneId: string) {
 
 describe("#2985 Bug 3 — concurrent discuss sessions must be independent", () => {
   beforeEach(() => {
+    closeDatabase();
     clearPendingAutoStart();
   });
 
@@ -75,6 +77,7 @@ describe("#2985 Bug 3 — concurrent discuss sessions must be independent", () =
 
 describe("#2985 Bug 4 — getDiscussionMilestoneId must be keyed by basePath", () => {
   beforeEach(() => {
+    closeDatabase();
     clearPendingAutoStart();
   });
 
@@ -110,6 +113,7 @@ describe("#2985 Bug 4 — getDiscussionMilestoneId must be keyed by basePath", (
 test("checkAutoStartAfterDiscuss ignores missing manifest for single-milestone discuss on established project", () => {
   const base = mkdtempSync(join(tmpdir(), "gsd-auto-start-manifest-"));
   try {
+    openDatabase(":memory:");
     const gsdDir = join(base, ".gsd");
     const milestoneDir = join(gsdDir, "milestones", "M001");
     mkdirSync(milestoneDir, { recursive: true });
@@ -132,6 +136,7 @@ test("checkAutoStartAfterDiscuss ignores missing manifest for single-milestone d
     const started = checkAutoStartAfterDiscuss();
     assert.equal(started, true, "project history alone should not require a manifest");
   } finally {
+    closeDatabase();
     clearPendingAutoStart();
     rmSync(base, { recursive: true, force: true });
   }
@@ -151,6 +156,7 @@ test("checkAutoStartAfterDiscuss(basePath) selects the matching pending entry wh
   }
 
   try {
+    openDatabase(":memory:");
     clearPendingAutoStart();
     writeReadyArtifacts(projectA, "M001");
     writeReadyArtifacts(projectB, "M002");
@@ -172,6 +178,7 @@ test("checkAutoStartAfterDiscuss(basePath) selects the matching pending entry wh
     assert.equal(getDiscussionMilestoneId(projectA), "M001", "projectA should remain pending");
     assert.equal(getDiscussionMilestoneId(projectB), null, "projectB should be cleared after start");
   } finally {
+    closeDatabase();
     clearPendingAutoStart();
     rmSync(projectA, { recursive: true, force: true });
     rmSync(projectB, { recursive: true, force: true });
@@ -183,6 +190,7 @@ test("checkAutoStartAfterDiscuss can accept context handoff without scheduling a
   let waitForIdleCalls = 0;
   const notifications: string[] = [];
   try {
+    openDatabase(":memory:");
     const gsdDir = join(base, ".gsd");
     const milestoneDir = join(gsdDir, "milestones", "M001");
     mkdirSync(milestoneDir, { recursive: true });
@@ -215,6 +223,7 @@ test("checkAutoStartAfterDiscuss can accept context handoff without scheduling a
     assert.equal(waitForIdleCalls, 0, "headless-owned auto start must not schedule guided-flow auto");
     assert.equal(getDiscussionMilestoneId(base), null, "accepted handoff should still be cleared");
   } finally {
+    closeDatabase();
     clearPendingAutoStart();
     rmSync(base, { recursive: true, force: true });
   }

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

@@ -294,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/",
@@ -1623,11 +1624,13 @@ process.exit(result.status ?? 0);
     // 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"]);
@@ -1636,6 +1639,8 @@ process.exit(result.status ?? 0);
     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);
@@ -1643,6 +1648,8 @@ process.exit(result.status ?? 0);
     // 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);
@@ -1653,6 +1660,8 @@ process.exit(result.status ?? 0);
       "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/state-machine-edge-cases.test.ts

@@ -90,6 +90,8 @@ import { clearPathCache } from "../../paths.ts";
 // Fixture Helpers
 // ═══════════════════════════════════════════════════════════════════════════
 
+const UAT_VERDICT_GATE_RULE_NAME = "uat-verdict-gate (non-PASS observed; closeout enforces)";
+
 function makeTempDir(): string {
   return mkdtempSync(join(tmpdir(), "gsd-edge-cases-"));
 }
@@ -280,7 +282,7 @@ function buildDispatchCtx(
 
 function getUatVerdictGate(): import("../../auto-dispatch.ts").DispatchRule {
   const rule = DISPATCH_RULES.find(
-    r => r.name === "uat-verdict-gate (non-PASS blocks progression)",
+    r => r.name === UAT_VERDICT_GATE_RULE_NAME,
   );
   assert.ok(rule, "uat-verdict-gate rule should be registered");
   return rule;
@@ -867,7 +869,7 @@ describe("dispatch failure modes", () => {
     // Verify critical ordering constraints
     const summarizeIdx = ruleNames.indexOf("summarizing → complete-slice");
     const runUatIdx = ruleNames.indexOf("run-uat (post-completion)");
-    const uatGateIdx = ruleNames.indexOf("uat-verdict-gate (non-PASS blocks progression)");
+    const uatGateIdx = ruleNames.indexOf(UAT_VERDICT_GATE_RULE_NAME);
     const executeIdx = ruleNames.indexOf("executing → execute-task");
 
     // summarizing should come before execute-task

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 {