@mndrk/agx 2.0.36 → 2.0.38

package/cloud-runtime/standalone/lib/queue/sqlite-adapter.ts

@@ -1,4 +1,5 @@
-import Database from "better-sqlite3";
+import { DatabaseSync } from "node:sqlite";
+import { pragmaAll, transaction } from "../sqlite-compat";
 import { v4 as uuidv4 } from "uuid";
 import path from "path";
 import fs from "fs";
@@ -33,7 +34,7 @@ interface SQLiteJobRow {
 }
 
 export class SQLiteQueueAdapter implements QueueAdapter {
-  private db: Database.Database;
+  private db: DatabaseSync;
   private workers: Map<string, { handler: Function; options: WorkerOptions; running: boolean }> = new Map();
   private pollingInterval: NodeJS.Timeout | null = null;
   private writeRateInterval: NodeJS.Timeout | null = null;
@@ -50,7 +51,7 @@ export class SQLiteQueueAdapter implements QueueAdapter {
       fs.mkdirSync(dir, { recursive: true });
     }
 
-    this.db = new Database(finalPath);
+    this.db = new DatabaseSync(finalPath);
 
     // Apply contract PRAGMAs and validate environment
     const errors = validateSQLiteEnvironment(this.db, finalPath);
@@ -93,7 +94,7 @@ export class SQLiteQueueAdapter implements QueueAdapter {
     `);
 
     // Migrate: add columns that may be missing from older schemas
-    const cols = this.db.pragma('table_info(agx_jobs)') as { name: string }[];
+    const cols = pragmaAll(this.db, 'table_info(agx_jobs)') as { name: string }[];
     const colNames = new Set(cols.map(c => c.name));
     if (!colNames.has('failed_at')) {
       this.db.exec(`ALTER TABLE agx_jobs ADD COLUMN failed_at INTEGER`);
@@ -187,7 +188,7 @@ export class SQLiteQueueAdapter implements QueueAdapter {
     const staleBefore = now - getStaleJobTimeoutMs();
 
     // Transactional claim
-    const jobs = this.db.transaction(() => {
+    const jobs = transaction(this.db, () => {
       const reapedJobs = this.reapStaleJobs(queue, now, staleBefore);
       if (reapedJobs.length > 0) {
         writeDebugLog("queue.reap_stale", {
@@ -227,7 +228,7 @@ export class SQLiteQueueAdapter implements QueueAdapter {
         name: queue,
         data: JSON.parse(c.data)
       }));
-    })();
+    });
 
     if (jobs.length > 0) {
       writeDebugLog("queue.claim", {
@@ -271,9 +272,9 @@ export class SQLiteQueueAdapter implements QueueAdapter {
       SET status = 'completed', completed_at = ?, worker_id = NULL
       WHERE id = ?
     `);
-    this.db.transaction(() => {
+    transaction(this.db, () => {
       for (const id of ids) stmt.run(now, id);
-    })();
+    });
   }
 
   private failJobs(ids: string[], error: string) {
@@ -299,9 +300,9 @@ export class SQLiteQueueAdapter implements QueueAdapter {
       WHERE id = ?
     `);
 
-    this.db.transaction(() => {
+    transaction(this.db, () => {
       for (const id of ids) {
-        const job = stmt.get(id) as SQLiteJobRow;
+        const job = stmt.get(id) as unknown as SQLiteJobRow;
         if (job && job.retry_count < job.retry_limit) {
           // Retry
           // Simple backoff: 2s * retry_count
@@ -312,7 +313,7 @@ export class SQLiteQueueAdapter implements QueueAdapter {
           updateFailed.run(now, error, id);
         }
       }
-    })();
+    });
   }
 
   private reapStaleJobs(queue: string, now: number, staleBefore: number): Array<{

package/cloud-runtime/standalone/lib/repo-knowledge.ts

@@ -1,4 +1,5 @@
 import { getSQLiteDb } from "./sqlite-query-adapter";
+import { transaction } from "./sqlite-compat";
 import { getKnowledgeNote } from "./knowledge-notes";
 
 export type RepoKnowledgeProducer = "human" | "system";
@@ -29,7 +30,7 @@ function getRepoRow(repoId: string): RepoRow | null {
          FROM project_repos
          WHERE id = ?`
       )
-      .get(repoId) as RepoRow | undefined) ?? null
+      .get(repoId) as unknown as RepoRow | undefined) ?? null
   );
 }
 
@@ -61,7 +62,7 @@ export function listRepoKnowledge(
            WHERE repo_id = ? AND producer = ?
            ORDER BY created_at DESC`
         )
-        .all(repoId, producer) as RepoKnowledgeRow[])
+        .all(repoId, producer) as unknown as RepoKnowledgeRow[])
     : (db
         .prepare(
           `SELECT id, repo_id, content, producer, created_at
@@ -69,7 +70,7 @@ export function listRepoKnowledge(
            WHERE repo_id = ?
            ORDER BY created_at DESC`
         )
-        .all(repoId) as RepoKnowledgeRow[]);
+        .all(repoId) as unknown as RepoKnowledgeRow[]);
 
   if (options?.includeLegacyHumanFallback === false) {
     return rows;
@@ -113,12 +114,12 @@ export function replaceRepoKnowledge(
   const db = getSQLiteDb();
   const trimmed = content.trim();
 
-  db.transaction(() => {
+  transaction(db, () => {
     db.prepare("DELETE FROM repo_knowledge WHERE repo_id = ? AND producer = ?").run(repoId, producer);
     if (trimmed) {
       db.prepare("INSERT INTO repo_knowledge (repo_id, content, producer) VALUES (?, ?, ?)").run(repoId, trimmed, producer);
     }
-  })();
+  });
 
   return listRepoKnowledge(repoId, { producer, includeLegacyHumanFallback: false });
 }

package/cloud-runtime/standalone/lib/sqlite-compat.ts

@@ -0,0 +1,75 @@
+/**
+ * Compatibility helpers for migrating from better-sqlite3 to node:sqlite.
+ *
+ * Provides pragma() and transaction() helpers that match
+ * the better-sqlite3 API surface used throughout agx-cloud.
+ *
+ * For backups, use the module-level `backup()` from "node:sqlite" directly.
+ */
+import { DatabaseSync } from "node:sqlite";
+
+/**
+ * Read a PRAGMA value, returning the value directly (like better-sqlite3's simple mode).
+ * Example: pragmaGet(db, "journal_mode") => "wal"
+ */
+export function pragmaGet(db: DatabaseSync, key: string): unknown {
+  const row = db.prepare(`PRAGMA ${key}`).get() as Record<string, unknown> | undefined;
+  if (!row) return undefined;
+  // Return the first column value regardless of column name.
+  // Some PRAGMAs use a different column name than the key (e.g. busy_timeout → timeout).
+  const values = Object.values(row);
+  return values.length > 0 ? values[0] : undefined;
+}
+
+/**
+ * Read a PRAGMA that returns multiple rows (like table_info, foreign_key_check).
+ * Example: pragmaAll(db, "table_info(agents)") => [{ cid: 0, name: "id", ... }]
+ */
+export function pragmaAll(db: DatabaseSync, key: string): unknown[] {
+  return db.prepare(`PRAGMA ${key}`).all();
+}
+
+/**
+ * Set a PRAGMA value.
+ * Example: pragmaSet(db, "journal_mode = WAL")
+ */
+export function pragmaSet(db: DatabaseSync, pragma: string): void {
+  db.exec(`PRAGMA ${pragma}`);
+}
+
+/**
+ * Run a function inside a transaction. Mimics better-sqlite3's db.transaction() API.
+ * Automatically commits on success, rolls back on error.
+ */
+export function transaction<T>(db: DatabaseSync, fn: () => T): T {
+  db.exec("BEGIN");
+  try {
+    const result = fn();
+    db.exec("COMMIT");
+    return result;
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
+}
+
+/**
+ * Returns a reusable transaction wrapper (like better-sqlite3's db.transaction(fn)).
+ * The returned function accepts args and passes them to fn.
+ */
+export function transactionFn<TArgs extends unknown[], TResult>(
+  db: DatabaseSync,
+  fn: (...args: TArgs) => TResult,
+): (...args: TArgs) => TResult {
+  return (...args: TArgs) => {
+    db.exec("BEGIN");
+    try {
+      const result = fn(...args);
+      db.exec("COMMIT");
+      return result;
+    } catch (err) {
+      db.exec("ROLLBACK");
+      throw err;
+    }
+  };
+}

package/cloud-runtime/standalone/lib/sqlite-query-adapter.ts

@@ -2,7 +2,7 @@
  * SQLite QueryBuilder — drop-in replacement for the Postgres QueryBuilder in db-adapter.ts.
  *
  * Translates the same fluent API (.from().select().eq().single() etc.) into
- * SQLite-compatible SQL executed via better-sqlite3.
+ * SQLite-compatible SQL executed via node:sqlite.
  *
  * Key dialect differences handled:
  *  - Parameterised placeholders: $N → ?
@@ -14,7 +14,8 @@
  *  - RETURNING          → supported in SQLite ≥ 3.35
  */
 
-import Database from "better-sqlite3";
+import { DatabaseSync } from "node:sqlite";
+import { pragmaAll } from "./sqlite-compat";
 import fs from "fs";
 import path from "path";
 import os from "os";
@@ -42,16 +43,16 @@ export function sqlExpr(expr: string): SqlExpression {
 
 // ── Singleton connection ────────────────────────────────────────────────────
 
-let _db: Database.Database | null = null;
+let _db: DatabaseSync | null = null;
 
-export function getSQLiteDb(): Database.Database {
+export function getSQLiteDb(): DatabaseSync {
   if (_db) return _db;
 
   const dbPath =
     process.env.SQLITE_DB_PATH ||
     path.join(AGX_DATA_DIR, "agx-board.db");
 
-  _db = new Database(dbPath);
+  _db = new DatabaseSync(dbPath);
 
   // Validate environment (applies PRAGMAs, checks version/extensions)
   const errors = validateSQLiteEnvironment(_db, dbPath);
@@ -82,7 +83,7 @@ export function getSQLiteDb(): Database.Database {
   return _db;
 }
 
-function initSQLiteSchema(db: Database.Database): void {
+function initSQLiteSchema(db: DatabaseSync): void {
   const ddlPath = path.join(process.cwd(), "db", "sqlite", "001_agx_board_schema.sql");
   if (!fs.existsSync(ddlPath)) {
     console.warn(`[sqlite] DDL not found at ${ddlPath}, skipping schema init`);
@@ -94,7 +95,7 @@ function initSQLiteSchema(db: Database.Database): void {
 
 // ── Runtime migrations (idempotent) ──────────────────────────────────────────
 
-function dropLegacyTeamsTables(db: Database.Database): void {
+function dropLegacyTeamsTables(db: DatabaseSync): void {
   const hasTeams = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='teams'").get();
   if (!hasTeams) return;
 
@@ -112,12 +113,12 @@ function dropLegacyTeamsTables(db: Database.Database): void {
   console.log("[sqlite] dropped legacy teams, team_agents, team_workspaces tables");
 }
 
-function runMigrations(db: Database.Database): void {
+function runMigrations(db: DatabaseSync): void {
   const graphTables = db
     .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='execution_graphs'")
     .all();
   if (graphTables.length > 0) {
-    const columns = db.pragma("table_info(execution_graphs)") as { name: string }[];
+    const columns = pragmaAll(db, "table_info(execution_graphs)") as { name: string }[];
     if (!columns.some((column) => column.name === "schedule")) {
       db.exec("ALTER TABLE execution_graphs ADD COLUMN schedule JSON");
     }
@@ -127,7 +128,7 @@ function runMigrations(db: Database.Database): void {
     .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='project_memory'")
     .all();
   if (projectMemoryTables.length > 0) {
-    const projectMemoryCols = db.pragma("table_info(project_memory)") as { name: string }[];
+    const projectMemoryCols = pragmaAll(db, "table_info(project_memory)") as { name: string }[];
     if (!projectMemoryCols.some((column) => column.name === "producer")) {
       db.exec("ALTER TABLE project_memory ADD COLUMN producer TEXT NOT NULL DEFAULT 'human' CHECK(producer IN ('human', 'system'))");
     }
@@ -137,7 +138,7 @@ function runMigrations(db: Database.Database): void {
   // Add new agent identity columns (voice, seed, model, provider, color)
   const agentTables = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='agents'").all();
   if (agentTables.length > 0) {
-    const agentCols = db.pragma("table_info(agents)") as { name: string }[];
+    const agentCols = pragmaAll(db, "table_info(agents)") as { name: string }[];
     const agentColNames = new Set(agentCols.map((c) => c.name));
     if (!agentColNames.has("voice")) db.exec("ALTER TABLE agents ADD COLUMN voice TEXT");
     if (!agentColNames.has("seed")) db.exec("ALTER TABLE agents ADD COLUMN seed TEXT");
@@ -385,7 +386,7 @@ function runMigrations(db: Database.Database): void {
 
 }
 
-function backfillAgentsFromFilesystem(db: Database.Database): void {
+function backfillAgentsFromFilesystem(db: DatabaseSync): void {
   const upsertAgent = db.prepare(
     `INSERT INTO agents (id, user_id, name, style, description, voice, seed)
      VALUES (?, ?, ?, 'balanced', NULL, ?, ?)
@@ -412,7 +413,7 @@ function backfillAgentsFromFilesystem(db: Database.Database): void {
   }
 }
 
-function backfillAgentSkillsFromLegacyParticipants(db: Database.Database): void {
+function backfillAgentSkillsFromLegacyParticipants(db: DatabaseSync): void {
   const participants = loadParticipants();
   const existingAgents = new Set(
     (db.prepare("SELECT id FROM agents").all() as Array<{ id: string }>).map((row) => row.id)
@@ -434,7 +435,7 @@ function backfillAgentSkillsFromLegacyParticipants(db: Database.Database): void
   }
 }
 
-function ensureRuntimeArtifactsForDbAgents(db: Database.Database): void {
+function ensureRuntimeArtifactsForDbAgents(db: DatabaseSync): void {
   const agents = db
     .prepare("SELECT id, voice, seed FROM agents")
     .all() as Array<{ id: string; voice: string | null; seed: string | null }>;

package/cloud-runtime/standalone/lib/sqlite_writer.ts

@@ -4,7 +4,8 @@
  * Handles type coercion from PG types to SQLite types and
  * writes batches inside transactions for performance.
  */
-import Database from "better-sqlite3";
+import { DatabaseSync } from "node:sqlite";
+import { pragmaSet, pragmaAll, transactionFn } from "./sqlite-compat";
 import * as fs from "fs";
 import * as path from "path";
 
@@ -14,13 +15,13 @@ export interface SqliteWriterOptions {
 }
 
 export class SqliteWriter {
-  db: Database.Database;
+  db: DatabaseSync;
 
   constructor(opts: SqliteWriterOptions) {
-    this.db = new Database(opts.dbPath);
-    this.db.pragma("journal_mode = WAL");
-    this.db.pragma("foreign_keys = OFF"); // off during migration, checked after
-    this.db.pragma("synchronous = NORMAL");
+    this.db = new DatabaseSync(opts.dbPath);
+    pragmaSet(this.db, "journal_mode = WAL");
+    pragmaSet(this.db, "foreign_keys = OFF"); // off during migration, checked after
+    pragmaSet(this.db, "synchronous = NORMAL");
   }
 
   /** Initialize the SQLite schema from the DDL file */
@@ -45,7 +46,7 @@ export class SqliteWriter {
       `INSERT OR IGNORE INTO "${table}" (${quotedCols}) VALUES (${placeholders})`
     );
 
-    const tx = this.db.transaction((batch: Record<string, unknown>[]) => {
+    const tx = transactionFn(this.db, (batch: Record<string, unknown>[]) => {
       for (const row of batch) {
         const values = columns.map((col) =>
           coercePgToSqlite(row[col], pgTypes.get(col) ?? "text")
@@ -130,8 +131,8 @@ export class SqliteWriter {
 
   /** Run PRAGMA foreign_key_check and return violations */
   checkForeignKeys(): { table: string; rowid: number; parent: string; fkid: number }[] {
-    this.db.pragma("foreign_keys = ON");
-    const violations = this.db.pragma("foreign_key_check") as {
+    pragmaSet(this.db, "foreign_keys = ON");
+    const violations = pragmaAll(this.db, "foreign_key_check") as {
       table: string;
       rowid: number;
       parent: string;

package/cloud-runtime/standalone/lib/startup.ts

@@ -5,7 +5,8 @@
  * Import and call `validateSQLiteEnvironment(db)` before any query execution.
  */
 
-import Database from "better-sqlite3";
+import { DatabaseSync, backup as sqliteBackup } from "node:sqlite";
+import { pragmaGet, pragmaSet } from "./sqlite-compat";
 import fs from "fs";
 import os from "os";
 import path from "path";
@@ -108,7 +109,7 @@ function detectFilesystemType(dbPath: string): string | null {
 
 // ── Extension check ─────────────────────────────────────────────────────────
 
-function checkExtension(db: Database.Database, ext: string): boolean {
+function checkExtension(db: DatabaseSync, ext: string): boolean {
   try {
     if (ext === "json1") {
       db.prepare("SELECT json('{}')").get();
@@ -132,7 +133,7 @@ function checkExtension(db: Database.Database, ext: string): boolean {
  * Validate SQLite runtime environment. Returns array of errors (empty = OK).
  * Call this once at startup before serving requests.
  */
-export function validateSQLiteEnvironment(db: Database.Database, dbPath: string): StartupError[] {
+export function validateSQLiteEnvironment(db: DatabaseSync, dbPath: string): StartupError[] {
   const errors: StartupError[] = [];
 
   // 1. Version check
@@ -144,9 +145,7 @@ export function validateSQLiteEnvironment(db: Database.Database, dbPath: string)
       found: version.v,
       required: `>= ${MIN_SQLITE_VERSION}`,
       fix:
-        os.platform() === "darwin"
-          ? "brew install sqlite3 && npm rebuild better-sqlite3"
-          : "apt-get install -y libsqlite3-dev && npm rebuild better-sqlite3",
+        "Ensure Node.js >= 22.16 is installed (node:sqlite is built-in)",
     });
   }
 
@@ -186,20 +185,20 @@ export function validateSQLiteEnvironment(db: Database.Database, dbPath: string)
 
   // 5. Apply PRAGMAs
   try {
-    db.pragma(`journal_mode = ${REQUIRED_PRAGMAS.journal_mode}`);
-    db.pragma(`foreign_keys = ${REQUIRED_PRAGMAS.foreign_keys}`);
-    db.pragma(`busy_timeout = ${REQUIRED_PRAGMAS.busy_timeout}`);
-    db.pragma(`synchronous = ${REQUIRED_PRAGMAS.synchronous}`);
-    db.pragma(`cache_size = ${REQUIRED_PRAGMAS.cache_size}`);
+    pragmaSet(db, `journal_mode = ${REQUIRED_PRAGMAS.journal_mode}`);
+    pragmaSet(db, `foreign_keys = ${REQUIRED_PRAGMAS.foreign_keys}`);
+    pragmaSet(db, `busy_timeout = ${REQUIRED_PRAGMAS.busy_timeout}`);
+    pragmaSet(db, `synchronous = ${REQUIRED_PRAGMAS.synchronous}`);
+    pragmaSet(db, `cache_size = ${REQUIRED_PRAGMAS.cache_size}`);
 
     // Verify journal_mode stuck — WAL preferred, DELETE acceptable (network FS),
     // memory/off are not safe for production.
-    const jm = (db.pragma("journal_mode", { simple: true }) as string).toLowerCase();
+    const jm = (pragmaGet(db, "journal_mode") as string).toLowerCase();
     const ACCEPTABLE_JOURNAL_MODES = new Set(["wal", "delete"]);
     if (!ACCEPTABLE_JOURNAL_MODES.has(jm)) {
       // WAL failed — try DELETE as fallback (works on network filesystems)
-      db.pragma("journal_mode = DELETE");
-      const jm2 = (db.pragma("journal_mode", { simple: true }) as string).toLowerCase();
+      pragmaSet(db, "journal_mode = DELETE");
+      const jm2 = (pragmaGet(db, "journal_mode") as string).toLowerCase();
       if (!ACCEPTABLE_JOURNAL_MODES.has(jm2)) {
         errors.push({
           kind: "pragma_error",
@@ -210,7 +209,7 @@ export function validateSQLiteEnvironment(db: Database.Database, dbPath: string)
         });
       } else {
         // DELETE mode needs synchronous=FULL for durability (WAL is safe with NORMAL)
-        db.pragma("synchronous = FULL");
+        pragmaSet(db, "synchronous = FULL");
         console.warn(`[startup] WAL unavailable, using journal_mode=${jm2} with synchronous=FULL`);
       }
     }
@@ -231,17 +230,17 @@ export function validateSQLiteEnvironment(db: Database.Database, dbPath: string)
  * WAL-safe online backup using SQLite backup API.
  *
  * Contract:
- * - Use `db.backup(destPath)` (better-sqlite3 built-in)
+ * - Use `backup(db, destPath)` from node:sqlite
  * - Checkpoint WAL before backup: PRAGMA wal_checkpoint(TRUNCATE)
  * - Checkpoint policy: auto-checkpoint at 1000 pages (SQLite default)
  * - Restore: stop app → replace DB file → delete WAL/SHM → restart
  * - RTO target: < 5 minutes for databases under 1 GB
  */
-export async function backupDatabase(db: Database.Database, destPath: string): Promise<void> {
+export async function backupDatabase(db: DatabaseSync, destPath: string): Promise<void> {
   // Checkpoint to flush WAL into main DB
-  db.pragma("wal_checkpoint(TRUNCATE)");
+  db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
   // Use the backup API
-  await db.backup(destPath);
+  await sqliteBackup(db, destPath);
 }
 
 /**

package/cloud-runtime/standalone/lib/thread-knowledge-runs.ts

@@ -1,5 +1,6 @@
 import { randomUUID } from "crypto";
 import { getSQLiteDb } from "./sqlite-query-adapter";
+import { transactionFn } from "./sqlite-compat";
 
 export type ThreadKnowledgeScope = "repo" | "project";
 export type ThreadKnowledgeRunStatus = "running" | "completed" | "failed";
@@ -93,7 +94,7 @@ export function startThreadKnowledgeRun(input: {
 }): { run: ThreadKnowledgeRun; reused: boolean } {
   const db = getSQLiteDb();
   const now = new Date().toISOString();
-  const tx = db.transaction((args: {
+  const tx = transactionFn(db, (args: {
     threadId: string;
     rootMessageId: string;
     scopes: ThreadKnowledgeScope[];

package/cloud-runtime/standalone/lib/workspaces-to-projects-migration.ts

@@ -1,4 +1,5 @@
-import type Database from "better-sqlite3";
+import type { DatabaseSync } from "node:sqlite";
+import { transaction } from "./sqlite-compat";
 import { loadParticipants } from "@/lib/participants-store";
 import { LOCAL_USER } from "@/lib/auth-mode";
 
@@ -53,7 +54,7 @@ export interface WorkspacesToProjectsMigrationResult {
   }>;
 }
 
-function ensureMigrationStateTable(db: Database.Database) {
+function ensureMigrationStateTable(db: DatabaseSync) {
   db.exec(`
     CREATE TABLE IF NOT EXISTS app_migrations (
       key TEXT PRIMARY KEY,
@@ -63,7 +64,7 @@ function ensureMigrationStateTable(db: Database.Database) {
   `);
 }
 
-function isMigrationApplied(db: Database.Database, key: string): boolean {
+function isMigrationApplied(db: DatabaseSync, key: string): boolean {
   ensureMigrationStateTable(db);
   const row = db
     .prepare("SELECT 1 FROM app_migrations WHERE key = ? LIMIT 1")
@@ -72,7 +73,7 @@ function isMigrationApplied(db: Database.Database, key: string): boolean {
 }
 
 function markMigrationApplied(
-  db: Database.Database,
+  db: DatabaseSync,
   key: string,
   metadata: Record<string, unknown>
 ) {
@@ -104,22 +105,22 @@ function titleCase(value: string): string {
     .join(" ");
 }
 
-function loadLegacyState(db: Database.Database) {
+function loadLegacyState(db: DatabaseSync) {
   const teams = db
     .prepare("SELECT id, name, user_id, COALESCE(is_default, 0) AS is_default FROM teams ORDER BY name ASC")
-    .all() as LegacyTeamRow[];
+    .all() as unknown as LegacyTeamRow[];
   const teamAgents = db
     .prepare("SELECT team_id, agent_id, routing_order FROM team_agents ORDER BY team_id, routing_order ASC")
-    .all() as LegacyTeamAgentRow[];
+    .all() as unknown as LegacyTeamAgentRow[];
   const teamWorkspaces = db
     .prepare("SELECT team_id, thread_id FROM team_workspaces ORDER BY team_id, thread_id ASC")
-    .all() as LegacyTeamWorkspaceRow[];
+    .all() as unknown as LegacyTeamWorkspaceRow[];
 
   return { teams, teamAgents, teamWorkspaces };
 }
 
 function ensureProject(
-  db: Database.Database,
+  db: DatabaseSync,
   userId: string,
   team: LegacyTeamRow,
   result: WorkspacesToProjectsMigrationResult
@@ -151,7 +152,7 @@ function ensureProject(
 }
 
 function importLegacyParticipants(
-  db: Database.Database,
+  db: DatabaseSync,
   userId: string,
   participants: LegacyParticipant[],
   result: WorkspacesToProjectsMigrationResult
@@ -189,7 +190,7 @@ function importLegacyParticipants(
 }
 
 function migrateProjectResources(
-  db: Database.Database,
+  db: DatabaseSync,
   projectId: string,
   agentIds: string[],
   participantById: Map<string, LegacyParticipant>,
@@ -223,7 +224,7 @@ function migrateProjectResources(
 }
 
 function migrateAgentSkills(
-  db: Database.Database,
+  db: DatabaseSync,
   participants: LegacyParticipant[],
   result: WorkspacesToProjectsMigrationResult
 ) {
@@ -251,7 +252,7 @@ function migrateAgentSkills(
 }
 
 export function migrateLegacyWorkspacesToProjects(
-  inputDb?: Database.Database
+  inputDb?: DatabaseSync
 ): WorkspacesToProjectsMigrationResult {
   if (!inputDb) {
     throw new Error("migrateLegacyWorkspacesToProjects requires an explicit database handle");
@@ -279,7 +280,7 @@ export function migrateLegacyWorkspacesToProjects(
     return result;
   }
 
-  const participants = loadParticipants() as LegacyParticipant[];
+  const participants = loadParticipants() as unknown as LegacyParticipant[];
   const participantById = new Map(participants.map((participant) => [participant.id, participant]));
 
   const { teams, teamAgents, teamWorkspaces } = loadLegacyState(db);
@@ -304,7 +305,7 @@ export function migrateLegacyWorkspacesToProjects(
     workspacesByTeam.set(row.team_id, list);
   }
 
-  const migrateTxn = db.transaction(() => {
+  const migrateTxn = () => transaction(db, () => {
     for (const [userId, userTeams] of teamsByUser.entries()) {
       result.usersProcessed++;
       const effectiveUserId = userId || LOCAL_USER.id;
@@ -363,7 +364,7 @@ export function migrateLegacyWorkspacesToProjects(
       for (const [projectId, threadIds] of intendedThreadsByProject.entries()) {
         for (const threadId of threadIds) {
           const removed = deleteThreadLinksElsewhere.run(threadId, projectId);
-          result.remappedThreadLinks += removed.changes;
+          result.remappedThreadLinks += Number(removed.changes);
           const linked = insertProjectThread.run(projectId, threadId);
           if (linked.changes > 0) result.projectThreadsLinked++;
         }
@@ -376,7 +377,7 @@ export function migrateLegacyWorkspacesToProjects(
 }
 
 export function autoMigrateLegacyWorkspacesToProjects(
-  inputDb?: Database.Database
+  inputDb?: DatabaseSync
 ): WorkspacesToProjectsMigrationResult | null {
   if (!inputDb) {
     throw new Error("autoMigrateLegacyWorkspacesToProjects requires an explicit database handle");
@@ -410,7 +411,7 @@ export function autoMigrateLegacyWorkspacesToProjects(
   return result;
 }
 
-export function getLegacyWorkspaceMigrationStatus(inputDb?: Database.Database): {
+export function getLegacyWorkspaceMigrationStatus(inputDb?: DatabaseSync): {
   applied: boolean;
   appliedAt: string | null;
   metadata: Record<string, unknown> | null;