gsd-pi 2.76.0-dev.82e249f7b → 2.76.0-dev.97807402

package/src/resources/extensions/gsd/tests/gsd-db.test.ts

@@ -3,12 +3,14 @@ import assert from 'node:assert/strict';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import * as os from 'node:os';
+import { createRequire } from 'node:module';
 import {
   openDatabase,
   closeDatabase,
   isDbAvailable,
   wasDbOpenAttempted,
   getDbProvider,
+  getDbStatus,
   insertDecision,
   getDecisionById,
   insertRequirement,
@@ -26,6 +28,8 @@ import {
   checkpointDatabase,
 } from '../gsd-db.ts';
 
+const _require = createRequire(import.meta.url);
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Helper: create a temp file path for file-backed DB tests
 // ═══════════════════════════════════════════════════════════════════════════
@@ -59,6 +63,20 @@ function withPlatform<T>(platform: NodeJS.Platform, fn: () => T): T {
   }
 }
 
+function openRawSqliteForTest(dbPath: string): { exec(sql: string): void; close(): void } {
+  try {
+    const mod = _require('node:sqlite') as { DatabaseSync: new (path: string) => { exec(sql: string): void; close(): void } };
+    return new mod.DatabaseSync(dbPath);
+  } catch {
+    type SqliteCtor = new (path: string) => { exec(sql: string): void; close(): void };
+    const mod = _require('better-sqlite3') as
+      | SqliteCtor
+      | { default: SqliteCtor };
+    const DatabaseCtor: SqliteCtor = typeof mod === 'function' ? mod : mod.default;
+    return new DatabaseCtor(dbPath);
+  }
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // gsd-db tests
 // ═══════════════════════════════════════════════════════════════════════════
@@ -81,7 +99,7 @@ describe('gsd-db', () => {
     // Check schema_version table
     const adapter = _getAdapter()!;
     const version = adapter.prepare('SELECT MAX(version) as version FROM schema_version').get();
-    assert.deepStrictEqual(version?.['version'], 21, 'schema version should be 21');
+    assert.deepStrictEqual(version?.['version'], 22, 'schema version should be 22');
 
     // Check tables exist by querying them
     const dRows = adapter.prepare('SELECT count(*) as cnt FROM decisions').get();
@@ -404,6 +422,53 @@ describe('gsd-db', () => {
     cleanup(dbPath);
   });
 
+  test('gsd-db: legacy DB missing memories.scope opens and bootstraps index columns', () => {
+    const dbPath = tempDbPath();
+    const legacyDb = openRawSqliteForTest(dbPath);
+    legacyDb.exec(`
+      CREATE TABLE schema_version (
+        version INTEGER NOT NULL,
+        applied_at TEXT NOT NULL
+      );
+      INSERT INTO schema_version(version, applied_at) VALUES (17, '2026-04-20T00:00:00.000Z');
+      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
+      );
+      INSERT INTO memories(id, category, content, created_at, updated_at)
+      VALUES ('legacy-memory', 'note', 'legacy row', '2026-04-20T00:00:00.000Z', '2026-04-20T00:00:00.000Z');
+    `);
+    legacyDb.close();
+
+    assert.equal(openDatabase(dbPath), true, 'openDatabase should succeed for legacy DB missing memories.scope');
+
+    const adapter = _getAdapter()!;
+    const columns = adapter.prepare('PRAGMA table_info(memories)').all();
+    const names = columns.map((row) => row['name']);
+    assert.ok(names.includes('scope'), 'memories.scope should be added during bootstrap');
+    assert.ok(names.includes('tags'), 'memories.tags should be added during bootstrap');
+
+    const row = adapter.prepare(`SELECT scope, tags FROM memories WHERE id = 'legacy-memory'`).get();
+    assert.equal(row?.['scope'], 'project', 'legacy rows should receive default scope');
+    assert.equal(row?.['tags'], '[]', 'legacy rows should receive default tags');
+
+    const index = adapter.prepare(
+      "SELECT name FROM sqlite_master WHERE type = 'index' AND name = 'idx_memories_scope'",
+    ).get();
+    assert.equal(index?.['name'], 'idx_memories_scope', 'scope index should be created after bootstrap columns are present');
+
+    cleanup(dbPath);
+  });
+
   test('gsd-db: rowToTask tolerates legacy comma-separated task arrays', () => {
     openDatabase(':memory:');
 
@@ -561,6 +626,92 @@ describe('gsd-db', () => {
     });
   });
 
+  // ─── getDbStatus ───────────────────────────────────────────────────────────
+
+  describe('getDbStatus', () => {
+    test('getDbStatus: initial state before any open', () => {
+      closeDatabase();
+      const status = getDbStatus();
+      assert.strictEqual(status.available, false, 'available false before open');
+      assert.strictEqual(status.attempted, false, 'attempted false before open');
+      assert.strictEqual(status.lastError, null, 'lastError null before open');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase null before open');
+    });
+
+    test('getDbStatus: available after successful open', () => {
+      openDatabase(':memory:');
+      const status = getDbStatus();
+      assert.strictEqual(status.available, true, 'available true after open');
+      assert.strictEqual(status.attempted, true, 'attempted true after open');
+      assert.ok(status.provider !== null, 'provider set after open');
+      assert.strictEqual(status.lastError, null, 'lastError null on success');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase null on success');
+      closeDatabase();
+    });
+
+    test('getDbStatus: resets lastError/lastPhase after closeDatabase', () => {
+      // Simulate a failed open to set error state
+      const corruptPath = path.join(os.tmpdir(), `gsd-corrupt-${Date.now()}.db`);
+      fs.writeFileSync(corruptPath, Buffer.from('not a sqlite file at all!!!!!'));
+      try {
+        openDatabase(corruptPath);
+      } catch {
+        // expected
+      }
+      assert.ok(getDbStatus().lastError !== null, 'lastError set after failed open');
+
+      // closeDatabase should clear it even though no DB was opened
+      closeDatabase();
+      const status = getDbStatus();
+      assert.strictEqual(status.lastError, null, 'lastError cleared by closeDatabase');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase cleared by closeDatabase');
+      assert.strictEqual(status.attempted, false, 'attempted reset by closeDatabase');
+      fs.unlinkSync(corruptPath);
+    });
+
+    test('getDbStatus: captures open-phase error on corrupt file', () => {
+      closeDatabase();
+      const corruptPath = path.join(os.tmpdir(), `gsd-corrupt-${Date.now()}.db`);
+      fs.writeFileSync(corruptPath, Buffer.from('not a sqlite file at all!!!!!'));
+      try {
+        openDatabase(corruptPath);
+      } catch {
+        // expected — both providers should reject a non-SQLite file
+      }
+      const status = getDbStatus();
+      if (!status.available) {
+        // open failed (expected in most environments)
+        assert.strictEqual(status.attempted, true, 'attempted true after failed open');
+        // provider may reject at raw-open level ("open") or at SQL init level ("initSchema")
+        assert.ok(
+          status.lastPhase === 'open' || status.lastPhase === 'initSchema',
+          `lastPhase should be "open" or "initSchema", got: ${status.lastPhase}`,
+        );
+        assert.ok(status.lastError instanceof Error, 'lastError is an Error');
+      }
+      // If somehow it succeeded (unlikely with garbage content), that's also fine
+      closeDatabase();
+      try { fs.unlinkSync(corruptPath); } catch { /* best effort */ }
+    });
+
+    test('getDbStatus: error state resets on next successful open', () => {
+      closeDatabase();
+      const corruptPath = path.join(os.tmpdir(), `gsd-corrupt-${Date.now()}.db`);
+      fs.writeFileSync(corruptPath, Buffer.from('not a sqlite file at all!!!!!'));
+      try { openDatabase(corruptPath); } catch { /* expected */ }
+      assert.ok(!getDbStatus().available, 'DB unavailable after corrupt open');
+
+      // Now open a valid in-memory DB — error state should clear
+      openDatabase(':memory:');
+      const status = getDbStatus();
+      assert.strictEqual(status.available, true, 'available after valid open');
+      assert.strictEqual(status.lastError, null, 'lastError cleared on successful open');
+      assert.strictEqual(status.lastPhase, null, 'lastPhase cleared on successful open');
+      closeDatabase();
+      try { fs.unlinkSync(corruptPath); } catch { /* best effort */ }
+    });
+  });
+
   // ─── Final Report ──────────────────────────────────────────────────────────
 
 });

package/src/resources/extensions/gsd/tests/init-wizard.test.ts

@@ -178,6 +178,33 @@ test("init-wizard: multiple project files detected together", (t) => {
   }
 });
 
+// ─── Git init + initial commit regression (#4530) ───────────────────────────
+
+import { execFileSync } from "node:child_process";
+import { nativeInit, nativeAddAll, nativeCommit } from "../native-git-bridge.ts";
+
+test("init-wizard: nativeInit + nativeAddAll + nativeCommit produces a reachable HEAD (#4530)", (t) => {
+  // Regression: showProjectInit called nativeInit but never committed, leaving
+  // the branch unborn. git log and git worktree add both fail on zero-commit repos.
+  const dir = makeTempDir("git-init-commit");
+  t.after(() => { cleanup(dir); });
+
+  nativeInit(dir, "main");
+  execFileSync("git", ["config", "user.email", "test@test.com"], { cwd: dir });
+  execFileSync("git", ["config", "user.name", "Test"], { cwd: dir });
+  writeFileSync(join(dir, ".gitignore"), "*.log\n", "utf-8");
+
+  nativeAddAll(dir);
+  nativeCommit(dir, "chore: init project");
+
+  // git log must succeed (was: fatal: your current branch 'main' does not have any commits yet)
+  const subject = execFileSync("git", ["log", "-1", "--format=%s"], {
+    cwd: dir,
+    encoding: "utf-8",
+  }).trim();
+  assert.equal(subject, "chore: init project");
+});
+
 test("init-wizard: v1 with both .planning/ and .gsd/ prioritizes v2", (t) => {
   const dir = makeTempDir("both-v1-v2");
   try {

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

package/src/resources/extensions/gsd/tests/key-manager.test.ts

@@ -143,6 +143,13 @@ test("PROVIDER_REGISTRY includes all major LLM providers", () => {
   assert.ok(ids.includes("groq"));
 });
 
+test("PROVIDER_REGISTRY includes claude-code as a first-class LLM provider (#4541)", () => {
+  const entry = PROVIDER_REGISTRY.find((p) => p.id === "claude-code");
+  assert.ok(entry, "claude-code must be in PROVIDER_REGISTRY");
+  assert.equal(entry!.category, "llm");
+  assert.ok(entry!.hasOAuth, "claude-code uses OAuth (CLI auth)");
+});
+
 test("PROVIDER_REGISTRY includes all tool/search providers", () => {
   const ids = PROVIDER_REGISTRY.map((p) => p.id);
   assert.ok(ids.includes("tavily"));

package/src/resources/extensions/gsd/tests/md-importer.test.ts

@@ -363,7 +363,7 @@ test('md-importer: schema v1→v2 migration', () => {
   openDatabase(':memory:');
   const adapter = _getAdapter();
   const version = adapter?.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.v, 21, 'new DB should be at schema version 21');
+  assert.deepStrictEqual(version?.v, 22, 'new DB should be at schema version 22');
 
   // Artifacts table should exist
   const tableCheck = adapter?.prepare("SELECT count(*) as c FROM sqlite_master WHERE type='table' AND name='artifacts'").get();

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

@@ -323,9 +323,9 @@ test('memory-store: schema includes memories table', () => {
   const viewCount = adapter.prepare('SELECT count(*) as cnt FROM active_memories').get();
   assert.deepStrictEqual(viewCount?.['cnt'], 0, 'active_memories view should exist');
 
-  // Verify schema version is 21 (ADR-013 structured_fields column included)
+  // Verify schema version is 22 (v22 quality_gates DDL fix included)
   const version = adapter.prepare('SELECT MAX(version) as v FROM schema_version').get();
-  assert.deepStrictEqual(version?.["v"], 21, 'schema version should be 21');
+  assert.deepStrictEqual(version?.["v"], 22, 'schema version should be 22');
 
   closeDatabase();
 });

package/src/resources/extensions/gsd/tests/parallel-research-dispatch.test.ts

@@ -110,6 +110,25 @@ test("template: parallel-research-slices.md has required variables", () => {
   assert.ok(templateSrc.includes("{{subagentPrompts}}"), "template should use subagentPrompts");
 });
 
+test("#4068: template: parallel-research-slices retry cap prevents infinite subagent loop", () => {
+  // The template must cap retries at 1 ("retry it once") and instruct the
+  // agent to write a BLOCKER note on the second failure rather than looping.
+  // Without this, a timing-out subagent causes the orchestrating agent to
+  // retry indefinitely (issue #4068 / #4355).
+  assert.ok(
+    templateSrc.includes("once") || templateSrc.includes("one retry") || templateSrc.match(/retry.{0,20}once/),
+    "template should cap subagent retries at one",
+  );
+  assert.ok(
+    templateSrc.toLowerCase().includes("blocker"),
+    "template should instruct writing a BLOCKER note instead of infinite retries",
+  );
+  assert.ok(
+    !templateSrc.match(/re-run it individually\s*\n/),
+    "template must not have unbounded re-run instruction without a retry cap",
+  );
+});
+
 // ─── Validate milestone prompt ────────────────────────────────────────────
 
 test("template: validate-milestone uses parallel reviewers", () => {

package/src/resources/extensions/gsd/tests/pre-exec-backtick-strip.test.ts

@@ -30,6 +30,20 @@ describe('normalizeFilePath backtick stripping (#3649)', () => {
     assert.equal(normalizeFilePath('``src/foo.ts`` (current state)'), 'src/foo.ts')
   })
 
+  it('strips stray backticks from dash-annotated bare paths (#4550)', () => {
+    assert.equal(
+      normalizeFilePath('.gsd/KNOWLEDGE.md` — append-only S05 lessons section'),
+      '.gsd/KNOWLEDGE.md',
+    )
+  })
+
+  it('prefers a backticked path inside a dash-annotated prefix (#4550)', () => {
+    assert.equal(
+      normalizeFilePath('Input `src/foo.ts` — current state'),
+      'src/foo.ts',
+    )
+  })
+
   it('strips backticks even when mixed with other normalization', () => {
     assert.equal(normalizeFilePath('`./src//bar.ts`'), 'src/bar.ts')
   })