gsd-pi 2.79.0-dev.ece5fd8ba → 2.80.0-dev.b62439b9f

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

@@ -0,0 +1,135 @@
+// Project/App: GSD-2
+// File Purpose: Tests for decision and requirement database row mappers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  rowToActiveDecision,
+  rowToActiveRequirement,
+  rowToDecision,
+  rowToRequirement,
+  rowsToRequirementCounts,
+} from "../db-decision-requirement-rows.ts";
+
+describe("db-decision-requirement-rows", () => {
+  test("maps persisted decision rows with defaults", () => {
+    const decision = rowToDecision({
+      seq: 7,
+      id: "D007",
+      when_context: "during planning",
+      scope: "M001/S01",
+      decision: "keep SQL writes in gsd-db",
+      choice: "facade wrappers",
+      rationale: "preserve the single-writer invariant",
+      revisable: "after repository split",
+      superseded_by: "D008",
+    });
+
+    assert.deepEqual(decision, {
+      seq: 7,
+      id: "D007",
+      when_context: "during planning",
+      scope: "M001/S01",
+      decision: "keep SQL writes in gsd-db",
+      choice: "facade wrappers",
+      rationale: "preserve the single-writer invariant",
+      revisable: "after repository split",
+      made_by: "agent",
+      source: "discussion",
+      superseded_by: "D008",
+    });
+  });
+
+  test("maps active decision rows as non-superseded", () => {
+    const decision = rowToActiveDecision({
+      seq: 1,
+      id: "D001",
+      when_context: "now",
+      scope: "global",
+      decision: "active only",
+      choice: "view row",
+      rationale: "view filters superseded rows",
+      revisable: "yes",
+      made_by: "human",
+      source: "planning",
+      superseded_by: "ignored",
+    });
+
+    assert.equal(decision.made_by, "human");
+    assert.equal(decision.source, "planning");
+    assert.equal(decision.superseded_by, null);
+  });
+
+  test("maps persisted requirement rows", () => {
+    const requirement = rowToRequirement({
+      id: "R001",
+      class: "functional",
+      status: "active",
+      description: "Persist requirements",
+      why: "planning needs durable context",
+      source: "roadmap",
+      primary_owner: "S01",
+      supporting_slices: "S02",
+      validation: "roundtrip",
+      notes: "important",
+      full_content: "Full requirement text",
+      superseded_by: "R002",
+    });
+
+    assert.deepEqual(requirement, {
+      id: "R001",
+      class: "functional",
+      status: "active",
+      description: "Persist requirements",
+      why: "planning needs durable context",
+      source: "roadmap",
+      primary_owner: "S01",
+      supporting_slices: "S02",
+      validation: "roundtrip",
+      notes: "important",
+      full_content: "Full requirement text",
+      superseded_by: "R002",
+    });
+  });
+
+  test("maps active requirement rows as non-superseded", () => {
+    const requirement = rowToActiveRequirement({
+      id: "R001",
+      class: "functional",
+      status: "validated",
+      description: "Validated requirement",
+      why: "done",
+      source: "roadmap",
+      primary_owner: "S01",
+      supporting_slices: "",
+      validation: "tests",
+      notes: "",
+      full_content: "Full requirement text",
+      superseded_by: "ignored",
+    });
+
+    assert.equal(requirement.status, "validated");
+    assert.equal(requirement.superseded_by, null);
+  });
+
+  test("reduces requirement status rows into stable counts", () => {
+    const counts = rowsToRequirementCounts([
+      { status: "active", count: 2 },
+      { status: "validated", count: 3 },
+      { status: "deferred", count: 5 },
+      { status: "out-of-scope", count: 7 },
+      { status: "out_of_scope", count: 11 },
+      { status: "blocked", count: 13 },
+      { status: "unknown", count: 17 },
+    ]);
+
+    assert.deepEqual(counts, {
+      active: 2,
+      validated: 3,
+      deferred: 5,
+      outOfScope: 18,
+      blocked: 13,
+      total: 58,
+    });
+  });
+});

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

@@ -0,0 +1,53 @@
+// Project/App: GSD-2
+// File Purpose: Tests for quality gate database row mapper.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { rowToGate } from "../db-gate-rows.ts";
+
+describe("db-gate-rows", () => {
+  test("rowToGate clears verdict for pending gates", () => {
+    const gate = rowToGate({
+      milestone_id: "M001",
+      slice_id: "S01",
+      gate_id: "Q3",
+      scope: "slice",
+      status: "pending",
+      verdict: "pass",
+    });
+
+    assert.equal(gate.task_id, "");
+    assert.equal(gate.verdict, null);
+    assert.equal(gate.rationale, "");
+    assert.equal(gate.findings, "");
+    assert.equal(gate.evaluated_at, null);
+  });
+
+  test("rowToGate preserves completed gate verdict and details", () => {
+    const gate = rowToGate({
+      milestone_id: "M001",
+      slice_id: "S01",
+      gate_id: "Q4",
+      scope: "task",
+      task_id: "T01",
+      status: "complete",
+      verdict: "flag",
+      rationale: "needs review",
+      findings: "minor risk",
+      evaluated_at: "2026-05-04T00:00:00.000Z",
+    });
+
+    assert.deepEqual(gate, {
+      milestone_id: "M001",
+      slice_id: "S01",
+      gate_id: "Q4",
+      scope: "task",
+      task_id: "T01",
+      status: "complete",
+      verdict: "flag",
+      rationale: "needs review",
+      findings: "minor risk",
+      evaluated_at: "2026-05-04T00:00:00.000Z",
+    });
+  });
+});

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

@@ -0,0 +1,45 @@
+// Project/App: GSD-2
+// File Purpose: Tests for lightweight DB query row mappers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  emptyTaskStatusCounts,
+  rowToActiveTaskSummary,
+  rowToIdStatusSummary,
+  rowToTaskStatusCounts,
+  rowsToStringColumn,
+} from "../db-lightweight-query-rows.ts";
+
+describe("db-lightweight-query-rows", () => {
+  test("maps id and status summaries", () => {
+    assert.deepEqual(rowToIdStatusSummary({ id: "M001", status: "active" }), {
+      id: "M001",
+      status: "active",
+    });
+  });
+
+  test("maps active task summaries", () => {
+    assert.deepEqual(rowToActiveTaskSummary({ id: "T01", status: "pending", title: "Plan task" }), {
+      id: "T01",
+      status: "pending",
+      title: "Plan task",
+    });
+  });
+
+  test("maps task status counts with stable empty defaults", () => {
+    assert.deepEqual(rowToTaskStatusCounts({ total: 3, done: 1, pending: 2 }), {
+      total: 3,
+      done: 1,
+      pending: 2,
+    });
+    assert.deepEqual(rowToTaskStatusCounts(undefined), emptyTaskStatusCounts());
+  });
+
+  test("extracts string columns from rows", () => {
+    assert.deepEqual(rowsToStringColumn([{ slice_id: "S01" }, { slice_id: "S02" }], "slice_id"), [
+      "S01",
+      "S02",
+    ]);
+  });
+});

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

@@ -0,0 +1,86 @@
+// Project/App: GSD-2
+// File Purpose: Tests for memory FTS5 schema helpers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import {
+  isMemoriesFtsAvailableSchema,
+  tryCreateMemoriesFtsSchema,
+} from "../db-memory-fts-schema.ts";
+import type { DbAdapter, DbStatement } from "../db-adapter.ts";
+
+class FakeStatement implements DbStatement {
+  private readonly row: Record<string, unknown> | undefined;
+
+  constructor(row: Record<string, unknown> | undefined) {
+    this.row = row;
+  }
+
+  run(): unknown {
+    return undefined;
+  }
+
+  get(): Record<string, unknown> | undefined {
+    return this.row;
+  }
+
+  all(): Record<string, unknown>[] {
+    return [];
+  }
+}
+
+class FakeAdapter implements DbAdapter {
+  readonly execCalls: string[] = [];
+  hasFts = false;
+  failExec = false;
+
+  exec(sql: string): void {
+    this.execCalls.push(sql);
+    if (this.failExec) throw new Error("fts unavailable");
+  }
+
+  prepare(): DbStatement {
+    return new FakeStatement(this.hasFts ? { name: "memories_fts" } : undefined);
+  }
+
+  close(): void {}
+}
+
+describe("db-memory-fts-schema", () => {
+  test("creates memories_fts and insert/delete/update triggers", () => {
+    const db = new FakeAdapter();
+
+    const ok = tryCreateMemoriesFtsSchema(db);
+
+    assert.equal(ok, true);
+    assert.equal(db.execCalls.length, 4);
+    assert.match(db.execCalls[0], /CREATE VIRTUAL TABLE IF NOT EXISTS memories_fts/);
+    assert.match(db.execCalls[1], /CREATE TRIGGER IF NOT EXISTS memories_ai/);
+    assert.match(db.execCalls[2], /CREATE TRIGGER IF NOT EXISTS memories_ad/);
+    assert.match(db.execCalls[3], /CREATE TRIGGER IF NOT EXISTS memories_au/);
+  });
+
+  test("reports unavailable FTS5 without throwing", () => {
+    const db = new FakeAdapter();
+    const messages: string[] = [];
+    db.failExec = true;
+
+    const ok = tryCreateMemoriesFtsSchema(db, {
+      onUnavailable: (message) => messages.push(message),
+    });
+
+    assert.equal(ok, false);
+    assert.equal(messages.length, 1);
+    assert.match(messages[0], /FTS5 unavailable/);
+    assert.match(messages[0], /fts unavailable/);
+  });
+
+  test("checks whether the memories_fts table exists", () => {
+    const db = new FakeAdapter();
+
+    assert.equal(isMemoriesFtsAvailableSchema(db), false);
+
+    db.hasFts = true;
+    assert.equal(isMemoriesFtsAvailableSchema(db), true);
+  });
+});

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

@@ -0,0 +1,105 @@
+// Project/App: GSD-2
+// File Purpose: Tests for pre-migration database backup helper.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { backupDatabaseBeforeMigration } from "../db-migration-backup.ts";
+import type { DbAdapter, DbStatement } from "../db-adapter.ts";
+
+class FakeStatement implements DbStatement {
+  run(): unknown {
+    return undefined;
+  }
+
+  get(): Record<string, unknown> | undefined {
+    return undefined;
+  }
+
+  all(): Record<string, unknown>[] {
+    return [];
+  }
+}
+
+class FakeAdapter implements DbAdapter {
+  readonly execCalls: string[] = [];
+  failCheckpoint = false;
+
+  exec(sql: string): void {
+    this.execCalls.push(sql);
+    if (this.failCheckpoint) throw new Error("checkpoint failed");
+  }
+
+  prepare(): DbStatement {
+    return new FakeStatement();
+  }
+
+  close(): void {}
+}
+
+describe("db-migration-backup", () => {
+  test("skips missing, memory, and already-backed-up databases", () => {
+    const db = new FakeAdapter();
+    const copies: Array<[string, string]> = [];
+    const warnings: string[] = [];
+
+    backupDatabaseBeforeMigration(db, null, 7, {
+      existsSync: () => true,
+      copyFileSync: (src, dest) => copies.push([src, dest]),
+      logWarning: (_scope, message) => warnings.push(message),
+    });
+    backupDatabaseBeforeMigration(db, ":memory:", 7, {
+      existsSync: () => true,
+      copyFileSync: (src, dest) => copies.push([src, dest]),
+      logWarning: (_scope, message) => warnings.push(message),
+    });
+    backupDatabaseBeforeMigration(db, "/tmp/gsd.db", 7, {
+      existsSync: (path) => path.endsWith(".backup-v7"),
+      copyFileSync: (src, dest) => copies.push([src, dest]),
+      logWarning: (_scope, message) => warnings.push(message),
+    });
+
+    assert.deepEqual(copies, []);
+    assert.deepEqual(warnings, []);
+    assert.deepEqual(db.execCalls, []);
+  });
+
+  test("checkpoints before copying a file-backed database", () => {
+    const db = new FakeAdapter();
+    const copies: Array<[string, string]> = [];
+
+    backupDatabaseBeforeMigration(db, "/tmp/gsd.db", 12, {
+      existsSync: (path) => path === "/tmp/gsd.db",
+      copyFileSync: (src, dest) => copies.push([src, dest]),
+      logWarning: () => assert.fail("should not warn"),
+    });
+
+    assert.deepEqual(db.execCalls, ["PRAGMA wal_checkpoint(TRUNCATE)"]);
+    assert.deepEqual(copies, [["/tmp/gsd.db", "/tmp/gsd.db.backup-v12"]]);
+  });
+
+  test("continues copying when checkpoint fails and warns when copy fails", () => {
+    const db = new FakeAdapter();
+    db.failCheckpoint = true;
+    const copies: Array<[string, string]> = [];
+    const warnings: string[] = [];
+
+    backupDatabaseBeforeMigration(db, "/tmp/gsd.db", 12, {
+      existsSync: (path) => path === "/tmp/gsd.db",
+      copyFileSync: (src, dest) => copies.push([src, dest]),
+      logWarning: (_scope, message) => warnings.push(message),
+    });
+
+    assert.deepEqual(copies, [["/tmp/gsd.db", "/tmp/gsd.db.backup-v12"]]);
+
+    backupDatabaseBeforeMigration(db, "/tmp/fail.db", 13, {
+      existsSync: (path) => path === "/tmp/fail.db",
+      copyFileSync: () => {
+        throw new Error("read only");
+      },
+      logWarning: (_scope, message) => warnings.push(message),
+    });
+
+    assert.equal(warnings.length, 1);
+    assert.match(warnings[0], /Pre-migration backup failed: read only/);
+  });
+});

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

@@ -0,0 +1,159 @@
+// Project/App: GSD-2
+// File Purpose: Tests for extracted GSD database migration DDL steps.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import type { DbAdapter, DbStatement } from "../db-adapter.ts";
+import {
+  applyMigrationV2Artifacts,
+  applyMigrationV3Memories,
+  applyMigrationV4DecisionMadeBy,
+  applyMigrationV5HierarchyTables,
+  applyMigrationV8PlanningFields,
+  applyMigrationV11TaskPlanning,
+  applyMigrationV13HotPathIndexes,
+  applyMigrationV15AuditTables,
+  applyMigrationV17TaskEscalation,
+  applyMigrationV18MemorySources,
+  applyMigrationV19MemoryFts,
+  applyMigrationV20MemoryRelations,
+  applyMigrationV22QualityGateRepair,
+} from "../db-migration-steps.ts";
+
+class FakeStatement implements DbStatement {
+  private readonly rows: Record<string, unknown>[];
+
+  constructor(rows: Record<string, unknown>[] = []) {
+    this.rows = rows;
+  }
+
+  run(): unknown {
+    return undefined;
+  }
+
+  get(): Record<string, unknown> | undefined {
+    return undefined;
+  }
+
+  all(): Record<string, unknown>[] {
+    return this.rows;
+  }
+}
+
+class FakeAdapter implements DbAdapter {
+  readonly execCalls: string[] = [];
+  tableInfoRows: Record<string, unknown>[] = [];
+
+  exec(sql: string): void {
+    this.execCalls.push(sql);
+  }
+
+  prepare(): DbStatement {
+    return new FakeStatement(this.tableInfoRows);
+  }
+
+  close(): void {}
+}
+
+describe("db-migration-steps", () => {
+  test("early migrations create artifact, memory, hierarchy, and active decision structures", () => {
+    const db = new FakeAdapter();
+
+    applyMigrationV2Artifacts(db);
+    applyMigrationV3Memories(db);
+    applyMigrationV4DecisionMadeBy(db);
+    applyMigrationV5HierarchyTables(db);
+
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS artifacts")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS memories")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE VIEW active_memories")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE decisions ADD COLUMN made_by")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE VIEW active_decisions")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS milestones")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS tasks")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS verification_evidence")));
+  });
+
+  test("planning migration adds planning columns and support tables", () => {
+    const db = new FakeAdapter();
+
+    applyMigrationV8PlanningFields(db);
+
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE milestones ADD COLUMN vision")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE slices ADD COLUMN goal")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE tasks ADD COLUMN description")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS replan_history")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS assessments")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE INDEX IF NOT EXISTS idx_replan_history_milestone")));
+  });
+
+  test("mid migrations add task planning, hot-path indexes, and audit tables", () => {
+    const db = new FakeAdapter();
+    let dedupeCalls = 0;
+
+    applyMigrationV11TaskPlanning(db);
+    applyMigrationV13HotPathIndexes(db, () => {
+      dedupeCalls += 1;
+    });
+    applyMigrationV15AuditTables(db);
+
+    assert.equal(dedupeCalls, 1);
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE tasks ADD COLUMN full_plan_md")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE UNIQUE INDEX IF NOT EXISTS idx_replan_history_unique")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE INDEX IF NOT EXISTS idx_tasks_active")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS gate_runs")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS audit_events")));
+  });
+
+  test("late DDL migrations add escalation and memory structures", () => {
+    const db = new FakeAdapter();
+
+    applyMigrationV17TaskEscalation(db);
+    applyMigrationV18MemorySources(db);
+    applyMigrationV20MemoryRelations(db);
+
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE tasks ADD COLUMN escalation_pending")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE INDEX IF NOT EXISTS idx_tasks_escalation_pending")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS memory_sources")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE INDEX IF NOT EXISTS idx_memory_sources_scope")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS memory_relations")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE INDEX IF NOT EXISTS idx_memory_relations_from")));
+  });
+
+  test("memory FTS migration delegates data-copy backfill to caller-owned write callback", () => {
+    const db = new FakeAdapter();
+    let backfillCalls = 0;
+    const warnings: string[] = [];
+
+    applyMigrationV19MemoryFts(db, {
+      tryCreateMemoriesFts: () => true,
+      isMemoriesFtsAvailable: () => true,
+      backfillMemoriesFts: () => {
+        backfillCalls += 1;
+      },
+      logWarning: (_scope, message) => warnings.push(message),
+    });
+
+    assert.equal(backfillCalls, 1);
+    assert.deepEqual(warnings, []);
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE IF NOT EXISTS memory_embeddings")));
+  });
+
+  test("quality gate repair delegates row copy to caller-owned write callback", () => {
+    const db = new FakeAdapter();
+    db.tableInfoRows = [{ name: "task_id", notnull: 0 }];
+    let copyCalls = 0;
+
+    applyMigrationV22QualityGateRepair(db, {
+      copyQualityGateRowsToRepairedTable: () => {
+        copyCalls += 1;
+      },
+    });
+
+    assert.equal(copyCalls, 1);
+    assert.ok(db.execCalls.some((sql) => sql.includes("CREATE TABLE quality_gates_new")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE quality_gates_new RENAME TO quality_gates")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE quality_gates ADD COLUMN scope")));
+    assert.ok(db.execCalls.some((sql) => sql.includes("ALTER TABLE assessments ADD COLUMN scope")));
+  });
+});

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

@@ -0,0 +1,53 @@
+// Project/App: GSD-2
+// File Purpose: Tests for milestone and artifact database row mappers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { rowToArtifact, rowToMilestone } from "../db-milestone-artifact-rows.ts";
+
+describe("db-milestone-artifact-rows", () => {
+  test("rowToMilestone maps JSON planning fields and defaults optional strings", () => {
+    const milestone = rowToMilestone({
+      id: "M001",
+      title: "Refactor DB",
+      status: "active",
+      depends_on: '["M000"]',
+      created_at: "2026-05-04T00:00:00.000Z",
+      success_criteria: '["tests pass"]',
+      key_risks: '[{"risk":"drift","whyItMatters":"behavior"}]',
+      proof_strategy: '[{"riskOrUnknown":"queries","retireIn":"tests","whatWillBeProven":"same rows"}]',
+      definition_of_done: '["committed"]',
+    });
+
+    assert.deepEqual(milestone.depends_on, ["M000"]);
+    assert.deepEqual(milestone.success_criteria, ["tests pass"]);
+    assert.deepEqual(milestone.key_risks, [{ risk: "drift", whyItMatters: "behavior" }]);
+    assert.deepEqual(milestone.proof_strategy, [
+      { riskOrUnknown: "queries", retireIn: "tests", whatWillBeProven: "same rows" },
+    ]);
+    assert.deepEqual(milestone.definition_of_done, ["committed"]);
+    assert.equal(milestone.completed_at, null);
+    assert.equal(milestone.vision, "");
+    assert.equal(milestone.sequence, 0);
+  });
+
+  test("rowToArtifact maps nullable ownership columns", () => {
+    const artifact = rowToArtifact({
+      path: "docs/report.md",
+      artifact_type: "report",
+      milestone_id: "M001",
+      full_content: "content",
+      imported_at: "2026-05-04T00:00:00.000Z",
+    });
+
+    assert.deepEqual(artifact, {
+      path: "docs/report.md",
+      artifact_type: "report",
+      milestone_id: "M001",
+      slice_id: null,
+      task_id: null,
+      full_content: "content",
+      imported_at: "2026-05-04T00:00:00.000Z",
+    });
+  });
+});

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

@@ -0,0 +1,56 @@
+// Project/App: GSD-2
+// File Purpose: Tests for database open attempt and error state tracking.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { createDbOpenState } from "../db-open-state.ts";
+
+describe("db-open-state", () => {
+  test("starts with no attempt or error", () => {
+    const state = createDbOpenState();
+
+    assert.deepEqual(state.snapshot(), {
+      attempted: false,
+      lastError: null,
+      lastPhase: null,
+    });
+  });
+
+  test("tracks attempts and open errors", () => {
+    const state = createDbOpenState();
+    const error = new Error("cannot open");
+
+    state.markAttempted();
+    state.recordError("open", error);
+
+    assert.equal(state.snapshot().attempted, true);
+    assert.equal(state.snapshot().lastError, error);
+    assert.equal(state.snapshot().lastPhase, "open");
+  });
+
+  test("normalizes non-Error values and clears errors without clearing attempts", () => {
+    const state = createDbOpenState();
+
+    state.markAttempted();
+    state.recordError("initSchema", "schema failed");
+    state.clearError();
+
+    assert.equal(state.snapshot().attempted, true);
+    assert.equal(state.snapshot().lastError, null);
+    assert.equal(state.snapshot().lastPhase, null);
+  });
+
+  test("reset clears attempt and error state", () => {
+    const state = createDbOpenState();
+
+    state.markAttempted();
+    state.recordError("vacuum-recovery", "vacuum failed");
+    state.reset();
+
+    assert.deepEqual(state.snapshot(), {
+      attempted: false,
+      lastError: null,
+      lastPhase: null,
+    });
+  });
+});