@devflow-tools/database 0.17.8 → 0.18.1

package/__tests__/database.task-runtime.test.ts

@@ -1,73 +0,0 @@
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { DevFlowDatabase } from '../src/database';
-import { stableTaskRuntimeHash, type TaskRuntimeEventRecord, type TaskRuntimeSnapshotRecord } from '../src/task-runtime';
-
-const identity = {
-  projectRoot: '/project', projectId: 'project:1', hostId: 'claude-code',
-  sessionId: 'session:1', turnId: 'turn:1', requestId: 'request:1',
-};
-
-function event(overrides: Partial<TaskRuntimeEventRecord> = {}): TaskRuntimeEventRecord {
-  return {
-    schemaVersion: 'task-runtime-event.v1', producer: 'test', producerVersion: '1.0.0',
-    eventId: 'event:1', sequence: 1, identity, taskSpecHash: 'spec:1',
-    kind: 'task.spec.bound', payload: {}, createdAt: 1, ...overrides,
-  };
-}
-
-function snapshot(lastEventSequence = 1): TaskRuntimeSnapshotRecord {
-  const body = {
-    schemaVersion: 'task-runtime-snapshot.v1' as const,
-    producer: 'test', producerVersion: '1.0.0', identity, taskSpecHash: 'spec:1',
-    lastEventSequence,
-    artifacts: { requiredIdentityIds: [], resolvedIdentityIds: [], ambiguousIdentityIds: [] },
-    channels: {},
-    action: { requirement: 'not_required' as const, state: 'satisfied' as const },
-    verification: { requirement: 'not_required' as const, state: 'satisfied' as const },
-    memory: { requirement: 'required' as const, state: 'satisfied' as const },
-    durableWorkIds: [], terminal: 'completed' as const, runtimeHealth: 'healthy' as const,
-    updatedAt: lastEventSequence,
-  };
-  return { ...body, snapshotHash: stableTaskRuntimeHash(body) };
-}
-
-describe('DevFlowDatabase task runtime persistence', () => {
-  let directory: string;
-  let database: DevFlowDatabase;
-
-  beforeEach(() => {
-    directory = mkdtempSync(join(tmpdir(), 'devflow-task-runtime-'));
-    database = new DevFlowDatabase(directory);
-  });
-
-  afterEach(() => {
-    database.close();
-    rmSync(directory, { recursive: true, force: true });
-  });
-
-  it('makes identical event replay idempotent and rejects conflicting IDs or sequences', () => {
-    const first = database.appendTaskRuntimeEvent(event());
-    expect(database.appendTaskRuntimeEvent(event())).toEqual(first);
-    expect(database.listTaskRuntimeEvents('/project', 'session:1', 'turn:1')).toEqual([first]);
-
-    expect(() => database.appendTaskRuntimeEvent(event({ payload: { changed: true } })))
-      .toThrow('TASK_RUNTIME_EVENT_CONFLICT:event:1');
-    expect(() => database.appendTaskRuntimeEvent(event({ eventId: 'event:2' })))
-      .toThrow('TASK_RUNTIME_SEQUENCE_CONFLICT:1');
-  });
-
-  it('round-trips snapshots, rejects regression, and supports deterministic rebuild deletion', () => {
-    database.appendTaskRuntimeEvent(event());
-    const current = database.putTaskRuntimeSnapshot(snapshot(1));
-    expect(database.getTaskRuntimeSnapshot('/project', 'session:1', 'turn:1')).toEqual(current);
-    expect(() => database.putTaskRuntimeSnapshot(snapshot(0))).toThrow('TASK_RUNTIME_SNAPSHOT_REGRESSION');
-
-    expect(database.deleteTaskRuntimeSnapshot('/project', 'session:1', 'turn:1')).toBe(true);
-    expect(database.getTaskRuntimeSnapshot('/project', 'session:1', 'turn:1')).toBeNull();
-    expect(database.listTaskRuntimeEvents('/project', 'session:1', 'turn:1')).toEqual([event()]);
-    expect(database.putTaskRuntimeSnapshot(snapshot(1))).toEqual(current);
-  });
-});

package/__tests__/database.test.ts

@@ -1,177 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { DevFlowDatabase } from '../src/database';
-import { rmSync, existsSync } from 'fs';
-import { join } from 'path';
-import type { BenchmarkSuiteReport } from '@devflow-tools/sdk';
-
-describe('DevFlowDatabase', () => {
-  const testDir = join(process.cwd(), '.devflow-test');
-  let db: DevFlowDatabase;
-
-  beforeEach(() => {
-    // 清理测试目录
-    if (existsSync(testDir)) {
-      rmSync(testDir, { recursive: true });
-    }
-    db = new DevFlowDatabase(testDir);
-  });
-
-  afterEach(() => {
-    db.close();
-    if (existsSync(testDir)) {
-      rmSync(testDir, { recursive: true });
-    }
-  });
-
-  it('should create .devflow directory and database file', () => {
-    expect(existsSync(join(testDir, '.devflow', 'devflow.db'))).toBe(true);
-  });
-
-  it('should initialize schema with runs table', () => {
-    const runs = db.getRuns();
-    expect(runs).toBeDefined();
-    expect(Array.isArray(runs)).toBe(true);
-  });
-
-  it('should insert and retrieve a run', () => {
-    const run = {
-      id: 'run-123',
-      source: 'mcp',
-      tool: 'test_tool',
-      input: { query: 'test' },
-      status: 'completed',
-      startedAt: Date.now(),
-      finishedAt: Date.now(),
-      tokenUsed: 100,
-      metadata: { projectRoot: testDir }
-    };
-
-    db.insertRun(run);
-    const retrieved = db.getRun('run-123');
-
-    expect(retrieved).toBeDefined();
-    expect(retrieved?.id).toBe('run-123');
-    expect(retrieved?.tool).toBe('test_tool');
-  });
-
-  it('should update a run', () => {
-    const run = {
-      id: 'run-456',
-      source: 'cli',
-      tool: 'test',
-      status: 'active',
-      startedAt: Date.now(),
-      tokenUsed: 0
-    };
-
-    db.insertRun(run);
-    db.updateRun('run-456', { status: 'completed', finishedAt: Date.now(), tokenUsed: 50 });
-
-    const retrieved = db.getRun('run-456');
-    expect(retrieved?.status).toBe('completed');
-    expect(retrieved?.token_used).toBe(50);
-  });
-
-  it('should insert and retrieve run steps', () => {
-    const run = {
-      id: 'run-789',
-      source: 'test',
-      tool: 'test',
-      status: 'active',
-      startedAt: Date.now(),
-      tokenUsed: 0
-    };
-    db.insertRun(run);
-
-    const step = {
-      runId: 'run-789',
-      name: 'step-1',
-      startTime: Date.now(),
-      endTime: Date.now(),
-      duration: 100,
-      status: 'completed',
-      metadata: { tokensUsed: 50 }
-    };
-
-    db.insertRunStep(step);
-    const steps = db.getRunSteps('run-789');
-
-    expect(steps).toHaveLength(1);
-    expect(steps[0].name).toBe('step-1');
-  });
-
-  it('should insert and retrieve telemetry events', () => {
-    // Insert a parent run first (FK constraint)
-    db.insertRun({
-      id: 'run-123',
-      source: 'test',
-      tool: 'test',
-      status: 'active',
-      startedAt: Date.now(),
-      tokenUsed: 0
-    });
-
-    const event = {
-      runId: 'run-123',
-      kind: 'tool_use',
-      timestamp: Date.now(),
-      duration: 100,
-      success: 1,
-      toolName: 'test',
-      pluginName: 'react',
-      metadata: { test: true }
-    };
-
-    db.insertEvent(event);
-    const events = db.getEvents('run-123');
-
-    expect(events).toHaveLength(1);
-    expect(events[0].kind).toBe('tool_use');
-  });
-
-  it('should upsert project stats', () => {
-    const stats = {
-      projectRoot: testDir,
-      totalRuns: 10,
-      successfulRuns: 8,
-      totalTokens: 1000,
-      lastActiveAt: Date.now(),
-      topTools: [{ toolName: 'test', count: 5 }]
-    };
-
-    db.upsertProjectStats(stats);
-    const retrieved = db.getProjectStats(testDir);
-
-    expect(retrieved).toBeDefined();
-    expect(retrieved?.totalRuns).toBe(10);
-  });
-
-  it('should persist and list canonical benchmark reports', () => {
-    const report = {
-      runId: 'benchmark:test',
-      suiteId: 'default',
-      suiteName: 'Default',
-      suiteVersion: '1',
-      projectRoot: testDir,
-      commit: null,
-      createdAt: Date.now(),
-      rounds: 1,
-      status: 'completed',
-      tasks: [],
-      summary: {
-        baseline: { avgTokensUsed: 10, avgFilesTouched: 2, avgCorrectnessScore: 0.5, avgDurationMs: 5 },
-        devflow: { avgTokensUsed: 5, avgFilesTouched: 1, avgCorrectnessScore: 1, avgDurationMs: 4 },
-        delta: { tokenReductionRate: 0.5, fileReductionRate: 0.5, correctnessLift: 0.5, timeSavedRate: 0.2 },
-      },
-      regressions: [],
-    } satisfies BenchmarkSuiteReport;
-
-    db.insertBenchmarkReport(report);
-
-    expect(db.getBenchmarkReport<BenchmarkSuiteReport>(report.runId)).toEqual(report);
-    expect(db.getLatestBenchmarkReport<BenchmarkSuiteReport>('default')).toEqual(report);
-    expect(db.listBenchmarkReports()).toEqual([
-      expect.objectContaining({ runId: report.runId, suiteId: 'default' }),
-    ]);
-  });
-});

package/__tests__/database.work-queue.test.ts

@@ -1,274 +0,0 @@
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { DevFlowDatabase } from '../src/database';
-
-describe('DevFlowDatabase durable work queue', () => {
-  let directory: string;
-  let database: DevFlowDatabase;
-  const projectRoot = '/project';
-
-  beforeEach(() => {
-    directory = mkdtempSync(join(tmpdir(), 'devflow-work-queue-'));
-    database = new DevFlowDatabase(directory);
-  });
-
-  afterEach(() => {
-    database.close();
-    rmSync(directory, { recursive: true, force: true });
-  });
-
-  it('returns the existing item for an idempotency conflict without resetting completed work', () => {
-    const first = database.enqueueWork({
-      idempotencyKey: 'memory:session-1:turn-1',
-      kind: 'memory.explicit_commit',
-      projectRoot,
-      sessionId: 'session-1',
-      turnId: 'turn-1',
-      payload: { text: 'remember this' },
-      nextAttemptAt: 10,
-    });
-    const [leased] = database.leaseWork({
-      projectRoot,
-      owner: 'worker-a',
-      limit: 1,
-      leaseMs: 100,
-      now: 10,
-    });
-    expect(leased?.id).toBe(first.id);
-    expect(database.completeWork(first.id, 'worker-a', 20)).toBe(true);
-
-    const duplicate = database.enqueueWork({
-      idempotencyKey: 'memory:session-1:turn-1',
-      kind: 'telemetry.reconcile',
-      projectRoot: '/different-project',
-      payload: { replacement: true },
-      maxAttempts: 1,
-      nextAttemptAt: 999,
-    });
-
-    expect(duplicate).toMatchObject({
-      id: first.id,
-      kind: 'memory.explicit_commit',
-      projectRoot,
-      payload: { text: 'remember this' },
-      state: 'completed',
-      attempts: 1,
-      maxAttempts: 5,
-      completedAt: 20,
-    });
-    expect(database.all('SELECT id FROM devflow_work_items')).toHaveLength(1);
-  });
-
-  it('leases atomically across database connections and requires the lease owner to complete', () => {
-    database.enqueueWork({
-      idempotencyKey: 'session:finalize:1',
-      kind: 'session.finalize',
-      projectRoot,
-      payload: { sessionId: 'session-1' },
-      nextAttemptAt: 100,
-    });
-    const secondConnection = new DevFlowDatabase(directory);
-    try {
-      const firstLease = database.leaseWork({
-        projectRoot,
-        owner: 'worker-a',
-        kinds: ['session.finalize'],
-        limit: 1,
-        leaseMs: 1_000,
-        now: 100,
-      });
-      const competingLease = secondConnection.leaseWork({
-        projectRoot,
-        owner: 'worker-b',
-        limit: 1,
-        leaseMs: 1_000,
-        now: 100,
-      });
-
-      expect(firstLease).toHaveLength(1);
-      expect(firstLease[0]).toMatchObject({
-        state: 'leased',
-        attempts: 1,
-        leaseOwner: 'worker-a',
-        leaseExpiresAt: 1_100,
-      });
-      expect(competingLease).toEqual([]);
-      expect(secondConnection.completeWork(firstLease[0]!.id, 'worker-b', 200)).toBe(false);
-      expect(database.completeWork(firstLease[0]!.id, 'worker-a', 200)).toBe(true);
-      expect(database.completeWork(firstLease[0]!.id, 'worker-a', 201)).toBe(false);
-    } finally {
-      secondConnection.close();
-    }
-  });
-
-  it('applies owner and state predicates to retries and dead letters', () => {
-    const item = database.enqueueWork({
-      idempotencyKey: 'telemetry:reconcile:1',
-      kind: 'telemetry.reconcile',
-      projectRoot,
-      payload: {},
-      nextAttemptAt: 50,
-    });
-    database.leaseWork({
-      projectRoot,
-      owner: 'worker-a',
-      limit: 1,
-      leaseMs: 100,
-      now: 50,
-    });
-
-    expect(database.retryWork(
-      item.id,
-      'worker-b',
-      { category: 'temporary', message: 'try again' },
-      75,
-    )).toBe(false);
-    expect(database.retryWork(
-      item.id,
-      'worker-a',
-      { category: 'temporary', message: 'try again' },
-      75,
-    )).toBe(true);
-    expect(database.getWorkQueueHealth(projectRoot, 75)).toMatchObject({
-      queueDepth: 1,
-      failed: 1,
-      deadLetters: 0,
-    });
-
-    const [retried] = database.leaseWork({
-      projectRoot,
-      owner: 'worker-b',
-      limit: 1,
-      leaseMs: 100,
-      now: 75,
-    });
-    expect(retried).toMatchObject({ attempts: 2, errorCategory: 'temporary' });
-    expect(database.deadLetterWork(
-      item.id,
-      'worker-a',
-      { category: 'invalid_schema', message: 'payload is invalid' },
-    )).toBe(false);
-    expect(database.deadLetterWork(
-      item.id,
-      'worker-b',
-      { category: 'invalid_schema', message: 'payload is invalid' },
-    )).toBe(true);
-    expect(database.deadLetterWork(
-      item.id,
-      'worker-b',
-      { category: 'invalid_schema', message: 'payload is invalid' },
-    )).toBe(false);
-    expect(database.getWorkQueueHealth(projectRoot, 80)).toMatchObject({
-      queueDepth: 0,
-      deadLetters: 1,
-    });
-  });
-
-  it('serializes project mutations, cancels stale work, and preserves dead-letter replay lineage', () => {
-    expect(database.acquireProjectMutationLease({
-      projectRoot, mutationKind: 'knowledge_publish', owner: 'worker-a', leaseMs: 100, now: 10,
-    })).toBe(true);
-    expect(database.acquireProjectMutationLease({
-      projectRoot, mutationKind: 'knowledge_publish', owner: 'worker-b', leaseMs: 100, now: 50,
-    })).toBe(false);
-    expect(database.acquireProjectMutationLease({
-      projectRoot, mutationKind: 'knowledge_publish', owner: 'worker-b', leaseMs: 100, now: 111,
-    })).toBe(true);
-
-    const stale = database.enqueueWork({
-      idempotencyKey: 'knowledge:stale', kind: 'knowledge.ingest', projectRoot,
-      sourceHash: 'source:v1', taskSpecHash: 'spec:v1', payload: {}, nextAttemptAt: 200,
-    });
-    expect(stale.maxAttempts).toBe(3);
-    database.leaseWork({ projectRoot, owner: 'worker-b', workItemIds: [stale.id], limit: 1, leaseMs: 100, now: 200 });
-    expect(database.cancelStaleWork({
-      id: stale.id, owner: 'worker-b', sourceHash: 'source:v2', taskSpecHash: 'spec:v1', now: 210,
-    })).toBe(true);
-    expect(database.getWorkById(stale.id)).toMatchObject({ state: 'cancelled', sourceHash: 'source:v1' });
-
-    const failed = database.enqueueWork({
-      idempotencyKey: 'knowledge:dead', kind: 'knowledge.ingest', projectRoot,
-      sourceHash: 'source:dead', payload: {}, maxAttempts: 1, nextAttemptAt: 300,
-    });
-    database.leaseWork({ projectRoot, owner: 'worker-b', workItemIds: [failed.id], limit: 1, leaseMs: 100, now: 300 });
-    database.retryWork(failed.id, 'worker-b', { category: 'semantic_invalid', message: 'empty' }, 310);
-    const replay = database.replayDeadLetterWork(failed.id, {
-      idempotencyKey: 'knowledge:dead:replay:1', sourceHash: 'source:fixed', now: 320,
-    });
-    expect(replay).toMatchObject({ state: 'pending', replayOfId: failed.id, replayCount: 1, sourceHash: 'source:fixed' });
-  });
-
-  it('recovers expired leases and dead-letters exhausted work', () => {
-    database.enqueueWork({
-      idempotencyKey: 'memory:distill:retryable',
-      kind: 'memory.turn_distill',
-      projectRoot,
-      payload: {},
-      maxAttempts: 2,
-      nextAttemptAt: 100,
-    });
-    database.enqueueWork({
-      idempotencyKey: 'memory:vector:exhausted',
-      kind: 'memory.vector_backfill',
-      projectRoot,
-      payload: {},
-      maxAttempts: 1,
-      nextAttemptAt: 100,
-    });
-    database.leaseWork({
-      projectRoot,
-      owner: 'worker-a',
-      limit: 2,
-      leaseMs: 10,
-      now: 100,
-    });
-
-    expect(database.getWorkQueueHealth(projectRoot, 110)).toMatchObject({
-      queueDepth: 2,
-      leased: 2,
-      expiredLeases: 2,
-    });
-    expect(database.recoverExpiredWork(projectRoot, 110)).toBe(2);
-    expect(database.getWorkQueueHealth(projectRoot, 110)).toMatchObject({
-      queueDepth: 1,
-      leased: 0,
-      failed: 1,
-      expiredLeases: 0,
-      deadLetters: 1,
-    });
-
-    const recovered = database.leaseWork({
-      projectRoot,
-      owner: 'worker-b',
-      limit: 2,
-      leaseMs: 20,
-      now: 110,
-    });
-    expect(recovered).toHaveLength(1);
-    expect(recovered[0]).toMatchObject({
-      idempotencyKey: 'memory:distill:retryable',
-      state: 'leased',
-      attempts: 2,
-      leaseOwner: 'worker-b',
-      errorCategory: 'lease_expired',
-    });
-
-    const revived = database.enqueueWork({
-      idempotencyKey: 'memory:vector:exhausted',
-      kind: 'memory.vector_backfill',
-      projectRoot,
-      payload: {},
-      maxAttempts: 20,
-      nextAttemptAt: 120,
-    });
-    expect(revived).toMatchObject({
-      state: 'failed',
-      attempts: 1,
-      maxAttempts: 20,
-      nextAttemptAt: 120,
-      errorCategory: undefined,
-    });
-  });
-});

package/__tests__/database.workflow-workers.test.ts

@@ -1,60 +0,0 @@
-import { mkdtempSync, rmSync } from 'node:fs';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { DevFlowDatabase } from '../src/database.js';
-
-const roots: string[] = [];
-
-function open(): { db: DevFlowDatabase; root: string } {
-  const root = mkdtempSync(join(tmpdir(), 'devflow-workers-'));
-  roots.push(root);
-  return { db: new DevFlowDatabase(root), root };
-}
-
-afterEach(() => {
-  for (const root of roots.splice(0)) rmSync(root, { recursive: true, force: true });
-});
-
-describe('workflow worker persistence', () => {
-  it('persists legal transitions and refuses terminal mutation', () => {
-    const { db, root } = open();
-    const worker = db.createWorkflowWorker({
-      runId: 'run-1', stepId: 'step-1', projectRoot: root,
-      branch: 'devflow/run-1/step-1', worktreePath: join(root, '.worker'),
-      host: 'codex', contextReceipt: 'receipt-1', baseRevision: 'a'.repeat(40),
-    });
-    db.leaseWorkflowWorker(root, worker.workerId, 'owner', 1_000, 100);
-    db.transitionWorkflowWorker({ projectRoot: root, workerId: worker.workerId, target: 'starting', leaseOwner: 'owner', now: 110 });
-    db.transitionWorkflowWorker({ projectRoot: root, workerId: worker.workerId, target: 'running', leaseOwner: 'owner', now: 120 });
-    db.transitionWorkflowWorker({ projectRoot: root, workerId: worker.workerId, target: 'failed', leaseOwner: 'owner', reason: 'test', now: 130 });
-    expect(() => db.transitionWorkflowWorker({ projectRoot: root, workerId: worker.workerId, target: 'hold' }))
-      .toThrow(/TERMINAL_CONFLICT/);
-    expect(db.listWorkflowWorkerEvents(root, worker.workerId)).toHaveLength(5);
-    db.close();
-  });
-
-  it('recovers expired leases to hold without retrying the worktree', () => {
-    const { db, root } = open();
-    const worker = db.createWorkflowWorker({
-      runId: 'run-2', stepId: 'step-2', projectRoot: root,
-      branch: 'devflow/run-2/step-2', worktreePath: join(root, '.worker-2'),
-      host: 'claude-code', contextReceipt: 'receipt-2', baseRevision: 'b'.repeat(40),
-    });
-    db.leaseWorkflowWorker(root, worker.workerId, 'owner', 10, 100);
-    expect(db.recoverExpiredWorkflowWorkers(root, 111)[0]?.state).toBe('hold');
-    db.close();
-  });
-
-  it('keeps merge queue insertion idempotent', () => {
-    const { db, root } = open();
-    const input = {
-      workerId: 'worker-3', projectRoot: root, baseRevision: 'a', parentRevision: 'b',
-      candidateRevision: 'c', graderReceipts: ['grader:1'], simulationHash: 'sha256:1',
-    };
-    const first = db.enqueueWorkflowMerge(input);
-    expect(db.enqueueWorkflowMerge(input).mergeId).toBe(first.mergeId);
-    expect(db.transitionWorkflowMerge(root, first.mergeId, 'ready').state).toBe('ready');
-    db.close();
-  });
-});

package/__tests__/node-sqlite.test.ts

@@ -1,68 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { NodeSqliteDatabase } from '../src/node-sqlite';
-import { unlinkSync, existsSync } from 'fs';
-
-describe('NodeSqliteDatabase', () => {
-  let db: NodeSqliteDatabase;
-  const testDbPath = '/tmp/test-node-sqlite.db';
-
-  beforeEach(() => {
-    if (existsSync(testDbPath)) {
-      unlinkSync(testDbPath);
-    }
-    db = new NodeSqliteDatabase(testDbPath);
-  });
-
-  afterEach(() => {
-    db.close();
-    if (existsSync(testDbPath)) {
-      unlinkSync(testDbPath);
-    }
-  });
-
-  it('should create database and execute SQL', () => {
-    db.exec(`
-      CREATE TABLE test (
-        id INTEGER PRIMARY KEY,
-        name TEXT
-      )
-    `);
-
-    const stmt = db.prepare('INSERT INTO test (name) VALUES (?)');
-    const result = stmt.run('test');
-
-    expect(result.changes).toBe(1);
-  });
-
-  it('should query data', () => {
-    db.exec('CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)');
-    db.prepare('INSERT INTO test (name) VALUES (?)').run('Alice');
-    db.prepare('INSERT INTO test (name) VALUES (?)').run('Bob');
-
-    const row = db.prepare('SELECT * FROM test WHERE name = ?').get('Alice');
-    expect(row.name).toBe('Alice');
-
-    const rows = db.prepare('SELECT * FROM test').all();
-    expect(rows).toHaveLength(2);
-  });
-
-  it('normalizes boolean bind parameters for node:sqlite', () => {
-    db.exec('CREATE TABLE test (success INTEGER NOT NULL)');
-    db.prepare('INSERT INTO test (success) VALUES (?)').run(true);
-
-    expect(db.prepare('SELECT success FROM test WHERE success = ?').get(true))
-      .toMatchObject({ success: 1 });
-  });
-
-  it('should support transactions', () => {
-    db.exec('CREATE TABLE test (id INTEGER PRIMARY KEY, name TEXT)');
-
-    db.transaction(() => {
-      db.prepare('INSERT INTO test (name) VALUES (?)').run('Alice');
-      db.prepare('INSERT INTO test (name) VALUES (?)').run('Bob');
-    });
-
-    const rows = db.prepare('SELECT * FROM test').all();
-    expect(rows).toHaveLength(2);
-  });
-});