gsd-pi 2.76.0 → 2.77.0-dev.1594b263e

package/src/resources/extensions/gsd/tests/integration/state-machine-edge-cases.test.ts

@@ -277,6 +277,14 @@ function buildDispatchCtx(
   };
 }
 
+function getUatVerdictGate(): import("../../auto-dispatch.ts").DispatchRule {
+  const rule = DISPATCH_RULES.find(
+    r => r.name === "uat-verdict-gate (non-PASS blocks progression)",
+  );
+  assert.ok(rule, "uat-verdict-gate rule should be registered");
+  return rule;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Test Suite
 // ═══════════════════════════════════════════════════════════════════════════
@@ -355,10 +363,13 @@ describe("state derivation failures", () => {
     const state2 = await deriveState(base);
     assert.equal(state2.phase, "executing", "cached result should still show executing");
 
-    // After explicit invalidation, should reflect the DB mutation
+    // After explicit invalidation, should reflect the DB mutation and reconcile
+    // missing plan tasks instead of prematurely summarizing a partial DB row set.
     invalidateStateCache();
     const state3 = await deriveState(base);
-    assert.equal(state3.phase, "summarizing", "after cache invalidation should show summarizing");
+    assert.equal(state3.phase, "executing", "after cache invalidation should continue with the missing plan task");
+    assert.equal(state3.activeTask?.id, "T02", "missing plan task T02 should be imported and selected");
+    assert.deepEqual(state3.progress?.tasks, { done: 1, total: 2 });
   });
 
   test("corrupt ROADMAP: binary content does not crash deriveState", async () => {
@@ -691,7 +702,7 @@ describe("transition boundary failures", () => {
     );
   });
 
-  test("blocked state: all slices have unmet deps → fallback picks slice", async () => {
+  test("blocked state: all slices have unmet deps → blocks", async () => {
     base = makeTempDir();
     const mDir = join(base, ".gsd", "milestones", "M001");
     mkdirSync(join(mDir, "slices", "S01", "tasks"), { recursive: true });
@@ -736,9 +747,9 @@ describe("transition boundary failures", () => {
 
     invalidateAllCaches();
     const state = await deriveStateFromDb(base);
-    // With partial-dep fallback, circular deps no longer block — fallback picks first eligible slice
-    assert.equal(state.phase, "planning", "circular deps: fallback picks a slice instead of blocking");
-    assert.ok(state.activeSlice !== null, "activeSlice set via fallback");
+    assert.equal(state.phase, "blocked", "circular deps: no slice should be selected through unmet deps");
+    assert.equal(state.activeSlice, null, "activeSlice should remain null when all deps are blocked");
+    assert.ok(state.blockers.some(b => b.includes("No slice eligible")));
   });
 });
 
@@ -868,6 +879,132 @@ describe("dispatch failure modes", () => {
     // run-uat should come before uat-verdict-gate
     assert.ok(runUatIdx < uatGateIdx, "run-uat should precede uat-verdict-gate");
   });
+
+  test("UAT verdict gate: ASSESSMENT FAIL blocks closed slice progression", async () => {
+    base = createFullFixture();
+    openDatabase(join(base, ".gsd", "gsd.db"));
+    insertMilestone({ id: "M001", title: "Active", status: "active" });
+    insertSlice({ id: "S01", milestoneId: "M001", title: "First", status: "complete" });
+    insertSlice({ id: "S02", milestoneId: "M001", title: "Second", status: "pending" });
+
+    const s01Dir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    writeFileSync(
+      join(s01Dir, "S01-UAT.md"),
+      "# UAT File\n\n## UAT Type\n\n- UAT mode: artifact-driven\n",
+    );
+    writeFileSync(
+      join(s01Dir, "S01-ASSESSMENT.md"),
+      "---\nverdict: FAIL\n---\n# UAT Assessment\n",
+    );
+
+    const ctx = buildDispatchCtx(base, "M001", {
+      phase: "planning",
+      activeSlice: { id: "S02", title: "Second" },
+      activeTask: null,
+    });
+    ctx.prefs = { uat_dispatch: true } as any;
+
+    const result = await getUatVerdictGate().match(ctx);
+    assert.equal(result?.action, "stop", "ASSESSMENT FAIL should block progression");
+    assert.ok(
+      (result as any).reason?.includes('UAT verdict for S01 is "fail"'),
+      "stop reason should report normalized ASSESSMENT verdict",
+    );
+  });
+
+  test("UAT verdict gate: ROADMAP fallback gates done slices when DB is unavailable", async () => {
+    base = createFullFixture();
+    const mDir = join(base, ".gsd", "milestones", "M001");
+    writeFileSync(
+      join(mDir, "M001-ROADMAP.md"),
+      [
+        "# M001: Edge Case Milestone",
+        "",
+        "## Vision",
+        "Prove edge case correctness.",
+        "",
+        "## Success Criteria",
+        "- All edge cases handled",
+        "",
+        "## Slices",
+        "",
+        "- [x] **S01: First Feature** `risk:low` `depends:[]`",
+        "  - After this: First feature proven.",
+        "",
+        "- [ ] **S02: Second Feature** `risk:low` `depends:[]`",
+        "  - After this: Second feature proven.",
+        "",
+        "## Boundary Map",
+        "",
+        "| From | To | Produces | Consumes |",
+        "|------|----|----------|----------|",
+        "| S01 | terminal | feature-a | nothing |",
+        "| S02 | terminal | feature-b | nothing |",
+      ].join("\n"),
+    );
+
+    const s01Dir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+    writeFileSync(
+      join(s01Dir, "S01-UAT.md"),
+      "# UAT File\n\n## UAT Type\n\n- UAT mode: artifact-driven\n",
+    );
+    writeFileSync(
+      join(s01Dir, "S01-ASSESSMENT.md"),
+      "---\nverdict: needs-remediation\n---\n# UAT Assessment\n",
+    );
+
+    const ctx = buildDispatchCtx(base, "M001", {
+      phase: "planning",
+      activeSlice: { id: "S02", title: "Second" },
+      activeTask: null,
+    });
+    ctx.prefs = { uat_dispatch: true } as any;
+
+    const result = await getUatVerdictGate().match(ctx);
+    assert.equal(result?.action, "stop", "ROADMAP done slices should be gated without DB");
+    assert.ok(
+      (result as any).reason?.includes('UAT verdict for S01 is "needs-remediation"'),
+      "stop reason should report normalized ASSESSMENT verdict from disk fallback",
+    );
+  });
+
+  for (const status of ["done", "skipped"]) {
+    test(`UAT verdict gate: legacy closed status "${status}" is gated`, async () => {
+      base = createFullFixture();
+      openDatabase(join(base, ".gsd", "gsd.db"));
+      insertMilestone({ id: "M001", title: "Active", status: "active" });
+      insertSlice({ id: "S01", milestoneId: "M001", title: "First", status });
+      insertSlice({ id: "S02", milestoneId: "M001", title: "Second", status: "pending" });
+
+      const s01Dir = join(base, ".gsd", "milestones", "M001", "slices", "S01");
+      writeFileSync(
+        join(s01Dir, "S01-UAT.md"),
+        "# UAT File\n\n## UAT Type\n\n- UAT mode: artifact-driven\n",
+      );
+      writeFileSync(
+        join(s01Dir, "S01-ASSESSMENT.md"),
+        "---\nverdict: needs-remediation\n---\n# UAT Assessment\n",
+      );
+
+      const ctx = buildDispatchCtx(base, "M001", {
+        phase: "planning",
+        activeSlice: { id: "S02", title: "Second" },
+        activeTask: null,
+      });
+      ctx.prefs = { uat_dispatch: true } as any;
+
+      const result = await getUatVerdictGate().match(ctx);
+      assert.equal(
+        result?.action,
+        "stop",
+        `${status} slices should be treated as closed for UAT verdict gating`,
+      );
+      assert.ok(
+        (result as any).reason?.includes('UAT verdict for S01 is "needs-remediation"'),
+        "stop reason should report normalized ASSESSMENT verdict",
+      );
+    });
+  }
 });
 
 // ─────────────────────────────────────────────────────────────────────────
@@ -1155,7 +1292,7 @@ describe("dispatch guard integration", () => {
     assert.ok(existsSync(validationPath), "VALIDATION file should be written");
     const content = readFileSync(validationPath, "utf-8");
     assert.ok(content.includes("verdict: pass"), "should contain pass verdict");
-    assert.ok(content.includes("skipped by preference"), "should note it was skipped");
+    assert.ok(content.includes("`skip_milestone_validation` preference"), "should note it was skipped via the preference path (#4781)");
   });
 
   test("rewrite-docs circuit breaker: exceeding MAX attempts resolves all overrides", async () => {

package/src/resources/extensions/gsd/tests/integration/state-machine-live-validation.test.ts

@@ -936,9 +936,11 @@ describe("state-machine-live-validation", () => {
       insertMilestone({ id: "M001", title: "Active", status: "active" });
       insertSlice({ id: "S01", milestoneId: "M001", title: "First", status: "in_progress" });
       insertTask({ id: "T01", sliceId: "S01", milestoneId: "M001", status: "pending" });
+      insertTask({ id: "T02", sliceId: "S01", milestoneId: "M001", status: "pending" });
 
       // Complete task + slice
       await handleCompleteTask(makeTaskParams("T01", "S01", "M001") as any, base);
+      await handleCompleteTask(makeTaskParams("T02", "S01", "M001") as any, base);
       await handleCompleteSlice(makeSliceParams("S01", "M001") as any, base);
       assert.ok(isClosedStatus(getSlice("M001", "S01")!.status));
 
@@ -946,9 +948,11 @@ describe("state-machine-live-validation", () => {
       await handleReopenSlice({ milestoneId: "M001", sliceId: "S01" }, base);
       assert.equal(getSlice("M001", "S01")!.status, "in_progress");
       assert.equal(getTask("M001", "S01", "T01")!.status, "pending");
+      assert.equal(getTask("M001", "S01", "T02")!.status, "pending");
 
       // Re-complete task + slice succeeds
       await handleCompleteTask(makeTaskParams("T01", "S01", "M001") as any, base);
+      await handleCompleteTask(makeTaskParams("T02", "S01", "M001") as any, base);
       const r = await handleCompleteSlice(makeSliceParams("S01", "M001") as any, base);
       assert.ok(!("error" in r), `re-complete slice: ${JSON.stringify(r)}`);
       assert.ok(isClosedStatus(getSlice("M001", "S01")!.status));

package/src/resources/extensions/gsd/tests/integration/state-machine-runtime-failures.test.ts

@@ -48,9 +48,7 @@ import type { WindowEntry } from "../../auto/types.ts";
 import {
   AutoSession,
   NEW_SESSION_TIMEOUT_MS,
-  MAX_UNIT_DISPATCHES,
   STUB_RECOVERY_THRESHOLD,
-  MAX_LIFETIME_DISPATCHES,
 } from "../../auto/session.ts";
 
 // ── Auto-loop types ──────────────────────────────────────────────────────
@@ -364,14 +362,6 @@ describe("session management", () => {
     assert.equal(NEW_SESSION_TIMEOUT_MS, 120_000, "session timeout should be 120s");
   });
 
-  test("MAX_UNIT_DISPATCHES limits retries for a single unit", () => {
-    assert.equal(MAX_UNIT_DISPATCHES, 3, "max unit dispatches should be 3");
-  });
-
-  test("MAX_LIFETIME_DISPATCHES is the absolute limit per unit", () => {
-    assert.equal(MAX_LIFETIME_DISPATCHES, 6, "max lifetime dispatches should be 6");
-  });
-
   test("STUB_RECOVERY_THRESHOLD triggers recovery after N stub completions", () => {
     assert.equal(STUB_RECOVERY_THRESHOLD, 2, "stub recovery threshold should be 2");
   });
@@ -392,12 +382,8 @@ describe("session management", () => {
     s.unitDispatchCount.set(unitId, 2);
     assert.equal(s.unitDispatchCount.get(unitId), 2);
 
-    // Exceeding MAX_UNIT_DISPATCHES
-    s.unitDispatchCount.set(unitId, MAX_UNIT_DISPATCHES + 1);
-    assert.ok(
-      s.unitDispatchCount.get(unitId)! > MAX_UNIT_DISPATCHES,
-      "should track count beyond max for detection",
-    );
+    s.unitDispatchCount.set(unitId, 4);
+    assert.equal(s.unitDispatchCount.get(unitId), 4);
   });
 
   test("AutoSession toJSON() provides diagnostic snapshot", () => {

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

@@ -200,6 +200,17 @@ Test
 
 ## Boundary Map
 _None_
+`);
+      writeFileSync(join(msDir, "M001-SUMMARY.md"), `---
+id: M001
+title: "Test Milestone"
+status: complete
+completed_at: 2026-04-18T00:00:00Z
+---
+
+# M001: Test Milestone
+
+Completed.
 `);
       run("git add -A", repo);
       run("git commit -m \"add milestone\"", repo);

package/src/resources/extensions/gsd/tests/interactive-routing-bypass.test.ts

@@ -8,6 +8,7 @@ import assert from "node:assert/strict";
 import { readFileSync } from "node:fs";
 import { join, dirname } from "node:path";
 import { fileURLToPath } from "node:url";
+import { extractSourceRegion } from "./test-helpers.ts";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
@@ -62,7 +63,7 @@ describe("interactive routing bypass (#3962)", () => {
     );
     // The function should check isAutoMode before routing synthesis
     const fnIdx = modelSelectionSrc.indexOf("function resolvePreferredModelConfig");
-    const fnBody = modelSelectionSrc.slice(fnIdx, fnIdx + 600);
+    const fnBody = extractSourceRegion(modelSelectionSrc, "function resolvePreferredModelConfig");
     assert.ok(
       fnBody.includes("isAutoMode"),
       "resolvePreferredModelConfig should accept isAutoMode parameter",
@@ -137,8 +138,13 @@ describe("model downgrade notifications always visible (#3962)", () => {
     const escalatedIdx = modelSelectionSrc.indexOf("if (escalated)");
     assert.ok(escalatedIdx > 0, "escalation block should exist");
 
-    // Get the block from "if (escalated)" to the next closing brace pattern
-    const block = modelSelectionSrc.slice(escalatedIdx, escalatedIdx + 400);
+    // Get the block from "if (escalated)" to the next distinctive marker
+    // (the capability-override loading that immediately follows).
+    const block = extractSourceRegion(
+      modelSelectionSrc,
+      "if (escalated)",
+      "// Load user capability overrides",
+    );
     assert.ok(
       block.includes("Tier escalation:"),
       "escalation block should contain the notification",

package/src/resources/extensions/gsd/tests/interrupted-session-ui.test.ts

@@ -1,6 +1,6 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { mkdirSync, rmSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { randomUUID } from "node:crypto";
@@ -126,11 +126,8 @@ test("guided-flow stale paused-session scenario is suppressed when no resumable
   }
 });
 
-test("guided-flow source uses step-aware resume and clears stale paused metadata without changing discuss handoff semantics", () => {
-  const source = readFileSync(join(import.meta.dirname, "..", "guided-flow.ts"), "utf-8");
-  assert.ok(source.includes('const interrupted = await assessInterruptedSession(basePath);'));
-  assert.ok(source.includes('resumeLabel = interrupted.pausedSession?.stepMode'));
-  assert.ok(source.includes('step: interrupted.pausedSession?.stepMode ?? false'));
-  assert.ok(source.includes('unlinkSync(join(gsdRoot(basePath), "runtime", "paused-session.json"))'));
-  assert.ok(source.includes('pendingAutoStartMap.set(basePath,'));
-});
+// Note: the prior source-grep test that scanned guided-flow.ts for five
+// string literals was removed under #4827. The invariants it encoded
+// (step-aware resume + stale paused-session cleanup + pendingAutoStartMap
+// side effect) should be covered by a runtime drive of guided-flow —
+// tracked as a follow-up.

package/src/resources/extensions/gsd/tests/isolation-none-branch-guard.test.ts

@@ -42,7 +42,7 @@ describe('isolation:none stale branch guard (#3675)', () => {
   });
 
   test('guard is conditional on isolation mode "none"', () => {
-    assert.match(source, /getIsolationMode\(\)\s*===\s*["']none["']/,
+    assert.match(source, /getIsolationMode\([^)]*\)\s*===\s*["']none["']/,
       'guard should only activate when isolation mode is "none"');
   });
 

package/src/resources/extensions/gsd/tests/issue-4540-regressions.test.ts

@@ -0,0 +1,288 @@
+/**
+ * Regression tests for issue #4540:
+ *   Bug 1 — Invalid quality_gates migration bricks gsd.db
+ *   Bug 2 — Artifact retries emit no journal event, look like stuck loops
+ */
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, rmSync, mkdirSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { createRequire } from "node:module";
+
+import {
+  openDatabase,
+  closeDatabase,
+  insertGateRow,
+  getPendingGates,
+  _getAdapter,
+} from "../gsd-db.ts";
+
+import { emitJournalEvent, queryJournal } from "../journal.ts";
+
+const _require = createRequire(import.meta.url);
+
+// ─── helpers ─────────────────────────────────────────────────────────────────
+
+function tmpDb(): { dir: string; dbPath: string } {
+  const dir = mkdtempSync(join(tmpdir(), "gsd-4540-"));
+  return { dir, dbPath: join(dir, "gsd.db") };
+}
+
+function cleanup(dir: string): void {
+  try { rmSync(dir, { recursive: true, force: true }); } catch { /* ignore */ }
+}
+
+/**
+ * Builds a v12 database with the broken quality_gates DDL:
+ * task_id is nullable and there is no proper multi-column PK.
+ * This simulates a DB that was created before the v12 fix was applied.
+ */
+function createBrokenV12Db(dbPath: string): void {
+  const sqlite = _require("node:sqlite");
+  const db = new sqlite.DatabaseSync(dbPath);
+  db.exec("PRAGMA journal_mode=WAL");
+
+  db.exec(`CREATE TABLE schema_version (version INTEGER NOT NULL, applied_at TEXT NOT NULL)`);
+  db.prepare("INSERT INTO schema_version (version, applied_at) VALUES (?, ?)").run(12, "2025-01-01T00:00:00.000Z");
+
+  db.exec(`
+    CREATE TABLE decisions (
+      seq INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL UNIQUE,
+      when_context TEXT NOT NULL DEFAULT '', scope TEXT NOT NULL DEFAULT '',
+      decision TEXT NOT NULL DEFAULT '', choice TEXT NOT NULL DEFAULT '',
+      rationale TEXT NOT NULL DEFAULT '', revisable TEXT NOT NULL DEFAULT '',
+      made_by TEXT NOT NULL DEFAULT 'agent', superseded_by TEXT DEFAULT NULL
+    );
+    CREATE VIEW active_decisions AS SELECT * FROM decisions WHERE superseded_by IS NULL;
+    CREATE TABLE requirements (
+      id TEXT PRIMARY KEY, class TEXT NOT NULL DEFAULT '', status TEXT NOT NULL DEFAULT '',
+      description TEXT NOT NULL DEFAULT '', why TEXT NOT NULL DEFAULT '',
+      source TEXT NOT NULL DEFAULT '', primary_owner TEXT NOT NULL DEFAULT '',
+      supporting_slices TEXT NOT NULL DEFAULT '', validation TEXT NOT NULL DEFAULT '',
+      notes TEXT NOT NULL DEFAULT '', full_content TEXT NOT NULL DEFAULT '',
+      superseded_by TEXT DEFAULT NULL
+    );
+    CREATE TABLE artifacts (
+      path TEXT PRIMARY KEY, artifact_type TEXT NOT NULL DEFAULT '',
+      milestone_id TEXT DEFAULT NULL, slice_id TEXT DEFAULT NULL, task_id TEXT DEFAULT NULL,
+      full_content TEXT NOT NULL DEFAULT '', imported_at TEXT NOT NULL DEFAULT ''
+    );
+    CREATE TABLE memories (
+      seq INTEGER PRIMARY KEY AUTOINCREMENT, id TEXT NOT NULL UNIQUE,
+      category TEXT NOT NULL, content TEXT NOT NULL, confidence REAL NOT NULL DEFAULT 0.8,
+      source_unit_type TEXT, source_unit_id TEXT, created_at TEXT NOT NULL,
+      updated_at TEXT NOT NULL, superseded_by TEXT DEFAULT NULL,
+      hit_count INTEGER NOT NULL DEFAULT 0,
+      scope TEXT NOT NULL DEFAULT 'project', tags TEXT NOT NULL DEFAULT '[]',
+      structured_fields TEXT DEFAULT NULL
+    );
+    CREATE TABLE memory_sources (
+      id TEXT PRIMARY KEY, kind TEXT NOT NULL DEFAULT '', path TEXT DEFAULT NULL,
+      imported_at TEXT NOT NULL DEFAULT '',
+      scope TEXT NOT NULL DEFAULT 'project', tags TEXT NOT NULL DEFAULT '[]'
+    );
+    CREATE TABLE memory_relations (
+      from_id TEXT NOT NULL, to_id TEXT NOT NULL, relation TEXT NOT NULL DEFAULT '',
+      PRIMARY KEY (from_id, to_id)
+    );
+    CREATE TABLE memory_processed_units (
+      unit_key TEXT PRIMARY KEY, activity_file TEXT, processed_at TEXT NOT NULL
+    );
+    CREATE TABLE milestones (
+      id TEXT PRIMARY KEY, title TEXT NOT NULL DEFAULT '', status TEXT NOT NULL DEFAULT 'active',
+      depends_on TEXT NOT NULL DEFAULT '[]', created_at TEXT NOT NULL DEFAULT '',
+      completed_at TEXT DEFAULT NULL, vision TEXT NOT NULL DEFAULT '',
+      success_criteria TEXT NOT NULL DEFAULT '[]', key_risks TEXT NOT NULL DEFAULT '[]',
+      proof_strategy TEXT NOT NULL DEFAULT '[]', verification_contract TEXT NOT NULL DEFAULT '',
+      verification_integration TEXT NOT NULL DEFAULT '',
+      verification_operational TEXT NOT NULL DEFAULT '', verification_uat TEXT NOT NULL DEFAULT '',
+      definition_of_done TEXT NOT NULL DEFAULT '[]', requirement_coverage TEXT NOT NULL DEFAULT '',
+      boundary_map_markdown TEXT NOT NULL DEFAULT ''
+    );
+    CREATE TABLE slices (
+      milestone_id TEXT NOT NULL, id TEXT NOT NULL, title TEXT NOT NULL DEFAULT '',
+      status TEXT NOT NULL DEFAULT 'pending', risk TEXT NOT NULL DEFAULT 'medium',
+      depends TEXT NOT NULL DEFAULT '[]', demo TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT '', completed_at TEXT DEFAULT NULL,
+      full_summary_md TEXT NOT NULL DEFAULT '', full_uat_md TEXT NOT NULL DEFAULT '',
+      goal TEXT NOT NULL DEFAULT '', success_criteria TEXT NOT NULL DEFAULT '',
+      proof_level TEXT NOT NULL DEFAULT '', integration_closure TEXT NOT NULL DEFAULT '',
+      observability_impact TEXT NOT NULL DEFAULT '', sequence INTEGER DEFAULT 0,
+      replan_triggered_at TEXT DEFAULT NULL,
+      is_sketch INTEGER NOT NULL DEFAULT 0, sketch_scope TEXT NOT NULL DEFAULT '',
+      PRIMARY KEY (milestone_id, id), FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+    );
+    CREATE TABLE tasks (
+      milestone_id TEXT NOT NULL, slice_id TEXT NOT NULL, id TEXT NOT NULL,
+      title TEXT NOT NULL DEFAULT '', status TEXT NOT NULL DEFAULT 'pending',
+      one_liner TEXT NOT NULL DEFAULT '', narrative TEXT NOT NULL DEFAULT '',
+      verification_result TEXT NOT NULL DEFAULT '',
+      escalation_pending INTEGER NOT NULL DEFAULT 0,
+      PRIMARY KEY (milestone_id, slice_id, id),
+      FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+    );
+    CREATE TABLE assessments (
+      path TEXT PRIMARY KEY, milestone_id TEXT NOT NULL DEFAULT '',
+      slice_id TEXT DEFAULT NULL, task_id TEXT DEFAULT NULL,
+      status TEXT NOT NULL DEFAULT '', scope TEXT NOT NULL DEFAULT '',
+      full_content TEXT NOT NULL DEFAULT '', created_at TEXT NOT NULL DEFAULT '',
+      FOREIGN KEY (milestone_id) REFERENCES milestones(id)
+    );
+    CREATE TABLE replan_history (
+      id INTEGER PRIMARY KEY AUTOINCREMENT, milestone_id TEXT NOT NULL,
+      slice_id TEXT DEFAULT NULL, task_id TEXT DEFAULT NULL,
+      reason TEXT NOT NULL DEFAULT '', created_at TEXT NOT NULL DEFAULT ''
+    );
+    CREATE TABLE verification_evidence (
+      id INTEGER PRIMARY KEY AUTOINCREMENT, milestone_id TEXT NOT NULL DEFAULT '',
+      slice_id TEXT NOT NULL DEFAULT '', task_id TEXT NOT NULL DEFAULT '',
+      unit_type TEXT NOT NULL DEFAULT '', unit_id TEXT NOT NULL DEFAULT '',
+      evidence_type TEXT NOT NULL DEFAULT '', content TEXT NOT NULL DEFAULT '',
+      created_at TEXT NOT NULL DEFAULT '',
+      command TEXT NOT NULL DEFAULT '', verdict TEXT NOT NULL DEFAULT ''
+    );
+  `);
+
+  // Broken quality_gates: task_id nullable, no multi-column PK
+  db.exec(`
+    CREATE TABLE quality_gates (
+      milestone_id TEXT NOT NULL, slice_id TEXT NOT NULL, gate_id TEXT NOT NULL,
+      scope TEXT NOT NULL DEFAULT 'slice', task_id TEXT DEFAULT NULL,
+      status TEXT NOT NULL DEFAULT 'pending', verdict TEXT NOT NULL DEFAULT '',
+      rationale TEXT NOT NULL DEFAULT '', findings TEXT NOT NULL DEFAULT '',
+      evaluated_at TEXT DEFAULT NULL,
+      FOREIGN KEY (milestone_id, slice_id) REFERENCES slices(milestone_id, id)
+    )
+  `);
+
+  // Parent rows + gate row with NULL task_id
+  db.prepare("INSERT INTO milestones (id, title, status) VALUES (?, ?, ?)").run("M001", "Milestone 1", "active");
+  db.prepare("INSERT INTO slices (milestone_id, id, title, status, risk, depends) VALUES (?, ?, ?, ?, ?, ?)").run("M001", "S01", "Slice 1", "pending", "medium", "[]");
+  db.prepare("INSERT INTO quality_gates (milestone_id, slice_id, gate_id, scope, task_id, status) VALUES (?, ?, ?, ?, ?, ?)").run("M001", "S01", "Q3", "slice", null, "pending");
+
+  db.close();
+}
+
+// ─── Bug 1 tests ─────────────────────────────────────────────────────────────
+
+describe("Bug 1 — quality_gates migration repair (#4540)", () => {
+  let dir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    ({ dir, dbPath } = tmpDb());
+  });
+
+  afterEach(() => {
+    closeDatabase();
+    cleanup(dir);
+  });
+
+  test("fresh DB: quality_gates task_id is NOT NULL with empty-string default", () => {
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const cols = adapter.prepare("PRAGMA table_info(quality_gates)").all() as Array<Record<string, unknown>>;
+    const col = cols.find((c) => c["name"] === "task_id");
+    assert.ok(col, "task_id column must exist");
+    assert.equal(col["notnull"], 1, "task_id must be NOT NULL");
+    assert.equal(col["dflt_value"], "''", "task_id default must be ''");
+  });
+
+  test("fresh DB: insertGateRow with no taskId stores '' and is idempotent", () => {
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    adapter.prepare("INSERT OR IGNORE INTO milestones (id, title, status) VALUES (?, ?, ?)").run("M001", "Test", "active");
+    adapter.prepare("INSERT OR IGNORE INTO slices (milestone_id, id, title, status, risk, depends) VALUES (?, ?, ?, ?, ?, ?)").run("M001", "S01", "Slice", "pending", "medium", "[]");
+
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    insertGateRow({ milestoneId: "M001", sliceId: "S01", gateId: "Q3", scope: "slice" });
+    const rows = getPendingGates("M001", "S01");
+    assert.equal(rows.length, 1);
+    assert.equal(rows[0].task_id, "");
+  });
+
+  test("v22 repair: broken v12 DB opens without error", () => {
+    createBrokenV12Db(dbPath);
+    assert.doesNotThrow(() => openDatabase(dbPath));
+  });
+
+  test("v22 repair: task_id becomes NOT NULL after healing broken v12 DB", () => {
+    createBrokenV12Db(dbPath);
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const cols = adapter.prepare("PRAGMA table_info(quality_gates)").all() as Array<Record<string, unknown>>;
+    const col = cols.find((c) => c["name"] === "task_id");
+    assert.ok(col, "task_id column must exist after repair");
+    assert.equal(col["notnull"], 1, "task_id must be NOT NULL after repair");
+  });
+
+  test("v22 repair: existing NULL task_id row is COALESCE'd to '' during repair", () => {
+    createBrokenV12Db(dbPath);
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const row = adapter.prepare(
+      "SELECT task_id FROM quality_gates WHERE milestone_id = 'M001' AND slice_id = 'S01' AND gate_id = 'Q3'"
+    ).get() as Record<string, unknown> | undefined;
+    assert.ok(row, "original gate row must survive the repair migration");
+    assert.equal(row["task_id"], "", "NULL task_id must be repaired to ''");
+  });
+
+  test("v22 repair: scope column present on quality_gates after open", () => {
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const cols = adapter.prepare("PRAGMA table_info(quality_gates)").all() as Array<Record<string, unknown>>;
+    assert.ok(cols.some((c) => c["name"] === "scope"), "quality_gates.scope must exist");
+  });
+
+  test("v22 repair: scope column present on assessments after open", () => {
+    openDatabase(dbPath);
+    const adapter = _getAdapter()!;
+    const cols = adapter.prepare("PRAGMA table_info(assessments)").all() as Array<Record<string, unknown>>;
+    assert.ok(cols.some((c) => c["name"] === "scope"), "assessments.scope must exist");
+  });
+});
+
+// ─── Bug 2 tests ─────────────────────────────────────────────────────────────
+
+describe("Bug 2 — artifact-verification-retry journal event (#4540)", () => {
+  test("emitJournalEvent accepts artifact-verification-retry event type", () => {
+    const basePath = mkdtempSync(join(tmpdir(), "gsd-journal-4540-"));
+    try {
+      mkdirSync(join(basePath, ".gsd"), { recursive: true });
+      emitJournalEvent(basePath, {
+        ts: new Date().toISOString(),
+        flowId: "flow-4540",
+        seq: 1,
+        eventType: "artifact-verification-retry",
+        data: { unitType: "plan-slice", unitId: "M001/S01", attempt: 1 },
+      });
+      const entries = queryJournal(basePath, { flowId: "flow-4540" });
+      assert.equal(entries.length, 1);
+      assert.equal(entries[0].eventType, "artifact-verification-retry");
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+
+  test("artifact-verification-retry event carries attempt count", () => {
+    const basePath = mkdtempSync(join(tmpdir(), "gsd-journal-4540b-"));
+    try {
+      mkdirSync(join(basePath, ".gsd"), { recursive: true });
+      emitJournalEvent(basePath, {
+        ts: new Date().toISOString(),
+        flowId: "flow-4540b",
+        seq: 1,
+        eventType: "artifact-verification-retry",
+        data: { unitType: "exec-slice", unitId: "M002/S02", attempt: 2 },
+      });
+      const entries = queryJournal(basePath, { flowId: "flow-4540b", eventType: "artifact-verification-retry" });
+      assert.equal(entries.length, 1);
+      const payload = entries[0].data as Record<string, unknown>;
+      assert.equal(payload["attempt"], 2);
+      assert.equal(payload["unitId"], "M002/S02");
+    } finally {
+      rmSync(basePath, { recursive: true, force: true });
+    }
+  });
+});