@proletariat/cli 0.3.82 → 0.3.83

package/dist/lib/database/index.js

@@ -1,33 +1,81 @@
 import Database from 'better-sqlite3';
+import { eq, and, or, isNull, sql, asc, desc, like } from 'drizzle-orm';
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { getThemePersistentDir, isEphemeralAgentName } from '../themes.js';
 import { throwIfNativeBindingError } from './native-validation.js';
 import { runDrizzleMigrations } from './migrator.js';
 import { ALL_MIGRATIONS } from './migrations/index.js';
+import { createDrizzleConnection } from './drizzle.js';
+import { workspace as workspaceTable, repositories as repositoriesTable, agents as agentsTable, agentThemes as agentThemesTable, agentThemeNames as agentThemeNamesTable, agentWorktrees as agentWorktreesTable, workspaceSettings as workspaceSettingsTable, mediaItems as mediaItemsTable, } from './drizzle-schema.js';
 // Re-export CREATE_TABLES_SQL from its canonical location
 export { CREATE_TABLES_SQL } from './workspace-schema.js';
-// CREATE_TABLES_SQL is now in workspace-schema.ts and re-exported above
+// =============================================================================
+// Internal helpers
+// =============================================================================
 /**
- * Ensure ephemeral agents are correctly typed based on their worktree path or naming pattern
+ * Open the workspace database, wrap it with Drizzle, run a function,
+ * and close the connection. Handles the open/close lifecycle.
+ */
+function withDrizzle(workspacePath, fn) {
+    const sqliteDb = openWorkspaceDatabase(workspacePath);
+    const ddb = createDrizzleConnection(sqliteDb);
+    try {
+        return fn(ddb, sqliteDb);
+    }
+    finally {
+        sqliteDb.close();
+    }
+}
+/**
+ * Map a Drizzle agent row to the Agent interface.
+ * Handles default values for backwards compatibility with old databases.
+ */
+function toAgent(row) {
+    return {
+        name: row.name,
+        type: (row.type || 'persistent'),
+        status: (row.status || 'active'),
+        base_name: row.baseName,
+        theme_id: row.themeId,
+        worktree_path: row.worktreePath,
+        mount_mode: (row.mountMode || 'worktree'),
+        created_at: row.createdAt,
+        cleaned_at: row.cleanedAt,
+    };
+}
+/**
+ * Map a Drizzle theme row to the AgentTheme interface.
+ */
+function toAgentTheme(row) {
+    return {
+        id: row.id,
+        name: row.name,
+        display_name: row.displayName,
+        description: row.description,
+        builtin: Boolean(row.builtin),
+        created_at: row.createdAt,
+    };
+}
+/**
+ * Ensure ephemeral agents are correctly typed based on their worktree path or naming pattern.
+ * Uses raw SQL because it relies on SQLite-specific GLOB operator and sqlite_master introspection.
  */
 function ensureEphemeralAgentTypes(db) {
-    // Check if agents table exists
+    // Check if agents table exists (sqlite_master introspection — no Drizzle equivalent)
     const tableExists = db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='agents'").get();
     if (!tableExists) {
         return;
     }
     // Agents in temp directory should be ephemeral
     db.exec("UPDATE agents SET type = 'ephemeral' WHERE worktree_path LIKE 'agents/temp/%' AND type != 'ephemeral'");
-    // Detect ephemeral agents by naming pattern: adjective-name-number (e.g., blue-khosla-1)
-    // Staff agents are single names like 'lecun', 'musk', 'gates'
+    // Detect ephemeral agents by naming pattern using SQLite GLOB (no Drizzle equivalent)
     db.exec(`
     UPDATE agents SET type = 'ephemeral'
     WHERE type != 'ephemeral'
     AND name GLOB '*-*-[0-9]*'
   `);
     // Also detect numberless ephemeral names (e.g., bold-bezos) using isEphemeralAgentName()
-    // This catches agents that match the adjective-name pattern but don't have a number suffix
     const potentialEphemeral = db.prepare(`
     SELECT name FROM agents
     WHERE type != 'ephemeral'
@@ -73,7 +121,7 @@ export function openWorkspaceDatabase(workspacePath) {
     db.pragma('busy_timeout = 5000'); // Wait up to 5 seconds if database is locked
     // Run Drizzle migrations (creates tracking table, applies pending migrations)
     runDrizzleMigrations(db, ALL_MIGRATIONS);
-    // Ensure ephemeral agents are correctly typed
+    // Ensure ephemeral agents are correctly typed (raw SQL — uses SQLite GLOB)
     ensureEphemeralAgentTypes(db);
     return db;
 }
@@ -107,11 +155,15 @@ export function createWorkspaceDatabase(workspacePath, type, workspaceName, hasP
     db.pragma('foreign_keys = ON');
     // Run all migrations (baseline creates core workspace + PMO tables)
     runDrizzleMigrations(db, ALL_MIGRATIONS);
-    // Insert workspace data (convert boolean to number for SQLite)
-    db.prepare(`
-    INSERT INTO workspace (id, type, workspace_name, has_pmo, created_at)
-    VALUES (1, ?, ?, ?, ?)
-  `).run(type, workspaceName, hasPMO ? 1 : 0, new Date().toISOString());
+    // Insert workspace data using Drizzle
+    const ddb = createDrizzleConnection(db);
+    ddb.insert(workspaceTable).values({
+        id: 1,
+        type,
+        workspaceName,
+        hasPmo: hasPMO,
+        createdAt: new Date().toISOString(),
+    }).run();
     return db;
 }
 /**
@@ -119,10 +171,19 @@ export function createWorkspaceDatabase(workspacePath, type, workspaceName, hasP
  */
 export function getWorkspaceConfig(workspacePath) {
     try {
-        const db = openWorkspaceDatabase(workspacePath);
-        const config = db.prepare('SELECT * FROM workspace LIMIT 1').get();
-        db.close();
-        return config || null;
+        return withDrizzle(workspacePath, (ddb) => {
+            const row = ddb.select().from(workspaceTable).limit(1).get();
+            if (!row)
+                return null;
+            return {
+                id: row.id ?? 1,
+                type: row.type,
+                workspace_name: row.workspaceName,
+                has_pmo: Boolean(row.hasPmo),
+                active_theme_id: row.activeThemeId,
+                created_at: row.createdAt,
+            };
+        });
     }
     catch {
         return null;
@@ -139,12 +200,12 @@ export function getActiveTheme(workspacePath) {
         return getTheme(workspacePath, config.active_theme_id);
     }
     // Auto-detect from existing agents
-    const agents = getWorkspaceAgents(workspacePath);
-    if (agents.length === 0) {
+    const agentList = getWorkspaceAgents(workspacePath);
+    if (agentList.length === 0) {
         return null;
     }
     // Check if any agent has a theme_id set
-    const themedAgent = agents.find(a => a.theme_id);
+    const themedAgent = agentList.find(a => a.theme_id);
     if (themedAgent?.theme_id) {
         const theme = getTheme(workspacePath, themedAgent.theme_id);
         if (theme) {
@@ -159,7 +220,7 @@ export function getActiveTheme(workspacePath) {
         const themeNames = getThemeNames(workspacePath, theme.id);
         const themeNameSet = new Set(themeNames.map(n => n.name.toLowerCase()));
         // If any existing agent matches this theme's names
-        const matchingAgent = agents.find(a => themeNameSet.has(a.name.toLowerCase()));
+        const matchingAgent = agentList.find(a => themeNameSet.has(a.name.toLowerCase()));
         if (matchingAgent) {
             // Auto-set it for future use
             setActiveTheme(workspacePath, theme.id);
@@ -172,82 +233,125 @@ export function getActiveTheme(workspacePath) {
  * Set the active theme for a workspace
  */
 export function setActiveTheme(workspacePath, themeId) {
-    const db = openWorkspaceDatabase(workspacePath);
-    if (themeId) {
-        // Validate theme exists
-        const theme = db.prepare('SELECT id FROM agent_themes WHERE id = ?').get(themeId);
-        if (!theme) {
-            db.close();
-            throw new Error(`Theme "${themeId}" not found`);
+    withDrizzle(workspacePath, (ddb) => {
+        if (themeId) {
+            // Validate theme exists
+            const theme = ddb.select({ id: agentThemesTable.id })
+                .from(agentThemesTable)
+                .where(eq(agentThemesTable.id, themeId))
+                .get();
+            if (!theme) {
+                throw new Error(`Theme "${themeId}" not found`);
+            }
         }
-    }
-    db.prepare('UPDATE workspace SET active_theme_id = ? WHERE id = 1').run(themeId);
-    db.close();
+        ddb.update(workspaceTable)
+            .set({ activeThemeId: themeId })
+            .where(eq(workspaceTable.id, 1))
+            .run();
+    });
 }
 /**
  * Add repositories to database
  */
 export function addRepositoriesToDatabase(workspacePath, repos) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const insertRepo = db.prepare(`
-    INSERT OR REPLACE INTO repositories (name, path, type, source_url, action, added_at)
-    VALUES (?, ?, ?, ?, ?, ?)
-  `);
-    const transaction = db.transaction(() => {
+    withDrizzle(workspacePath, (ddb) => {
         for (const repo of repos) {
-            insertRepo.run(repo.name, repo.path, 'main', repo.source_url || null, repo.action || null, new Date().toISOString());
+            ddb.insert(repositoriesTable)
+                .values({
+                name: repo.name,
+                path: repo.path,
+                type: 'main',
+                sourceUrl: repo.source_url || null,
+                action: repo.action || null,
+                addedAt: new Date().toISOString(),
+            })
+                .onConflictDoUpdate({
+                target: repositoriesTable.name,
+                set: {
+                    path: repo.path,
+                    type: 'main',
+                    sourceUrl: repo.source_url || null,
+                    action: repo.action || null,
+                    addedAt: new Date().toISOString(),
+                },
+            })
+                .run();
         }
     });
-    transaction();
-    db.close();
 }
 /**
  * Add agents to database (case-insensitive uniqueness)
  */
 export function addAgentsToDatabase(workspacePath, agentNames, themeId, mountMode = 'worktree') {
-    const db = openWorkspaceDatabase(workspacePath);
-    // Check for existing agents (case-insensitive)
-    const checkExisting = db.prepare('SELECT name FROM agents WHERE LOWER(name) = LOWER(?)');
-    const insertAgent = db.prepare(`
-    INSERT OR REPLACE INTO agents (name, type, base_name, theme_id, worktree_path, mount_mode, created_at)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-  `);
-    const insertWorktree = db.prepare(`
-    INSERT OR REPLACE INTO agent_worktrees (agent_name, repo_name, worktree_path, branch, created_at)
-    VALUES (?, ?, ?, ?, ?)
-  `);
-    // Get workspace config to determine paths
-    const workspace = db.prepare('SELECT * FROM workspace').get();
-    // Get all repos for this workspace
-    const repos = db.prepare('SELECT name FROM repositories').all();
-    // Determine the effective theme ID (provided or active theme)
-    const effectiveThemeId = themeId || workspace.active_theme_id || undefined;
-    const persistentDir = getThemePersistentDir(effectiveThemeId);
-    const transaction = db.transaction(() => {
-        for (const agentName of agentNames) {
-            // Skip if agent already exists (case-insensitive check)
-            const existing = checkExisting.get(agentName);
-            if (existing) {
-                continue; // Agent already exists with same name (different case)
-            }
-            const now = new Date().toISOString();
-            // Determine worktree path for the agent
-            const agentWorktreePath = workspace.type === 'hq'
-                ? `agents/${persistentDir}/${agentName}`
-                : agentName;
-            // Add agent (persistent type for manually added agents)
-            insertAgent.run(agentName, 'persistent', null, effectiveThemeId || null, agentWorktreePath, mountMode, now);
-            // Add worktrees for all repos
-            for (const repo of repos) {
-                const worktreePath = workspace.type === 'hq'
-                    ? `agents/${persistentDir}/${agentName}/${repo.name}`
-                    : `${agentName}/${repo.name}`;
-                insertWorktree.run(agentName, repo.name, worktreePath, `agent-${agentName}`, now);
+    withDrizzle(workspacePath, (ddb, sqliteDb) => {
+        // Get workspace config to determine paths
+        const wsRow = ddb.select().from(workspaceTable).get();
+        if (!wsRow)
+            throw new Error('No workspace config found');
+        // Get all repos for this workspace
+        const repos = ddb.select({ name: repositoriesTable.name }).from(repositoriesTable).all();
+        // Determine the effective theme ID (provided or active theme)
+        const effectiveThemeId = themeId || wsRow.activeThemeId || undefined;
+        const persistentDir = getThemePersistentDir(effectiveThemeId);
+        const transaction = sqliteDb.transaction(() => {
+            for (const agentName of agentNames) {
+                // Check for existing agents (case-insensitive) via Drizzle sql
+                const existing = ddb.select({ name: agentsTable.name })
+                    .from(agentsTable)
+                    .where(sql `LOWER(${agentsTable.name}) = LOWER(${agentName})`)
+                    .get();
+                if (existing) {
+                    continue; // Agent already exists with same name (different case)
+                }
+                const now = new Date().toISOString();
+                // Determine worktree path for the agent
+                const agentWorktreePath = wsRow.type === 'hq'
+                    ? `agents/${persistentDir}/${agentName}`
+                    : agentName;
+                // Add agent (persistent type for manually added agents)
+                ddb.insert(agentsTable).values({
+                    name: agentName,
+                    type: 'persistent',
+                    baseName: null,
+                    themeId: effectiveThemeId || null,
+                    worktreePath: agentWorktreePath,
+                    mountMode,
+                    createdAt: now,
+                }).onConflictDoUpdate({
+                    target: agentsTable.name,
+                    set: {
+                        type: 'persistent',
+                        baseName: null,
+                        themeId: effectiveThemeId || null,
+                        worktreePath: agentWorktreePath,
+                        mountMode,
+                        createdAt: now,
+                    },
+                }).run();
+                // Add worktrees for all repos
+                for (const repo of repos) {
+                    const worktreePath = wsRow.type === 'hq'
+                        ? `agents/${persistentDir}/${agentName}/${repo.name}`
+                        : `${agentName}/${repo.name}`;
+                    ddb.insert(agentWorktreesTable).values({
+                        agentName,
+                        repoName: repo.name,
+                        worktreePath,
+                        branch: `agent-${agentName}`,
+                        createdAt: now,
+                    }).onConflictDoUpdate({
+                        target: [agentWorktreesTable.agentName, agentWorktreesTable.repoName],
+                        set: {
+                            worktreePath,
+                            branch: `agent-${agentName}`,
+                            createdAt: now,
+                        },
+                    }).run();
+                }
             }
-        }
+        });
+        transaction();
     });
-    transaction();
-    db.close();
 }
 /**
  * Add an ephemeral agent to the database.
@@ -269,26 +373,27 @@ export function addEphemeralAgentToDatabase(workspacePath, agentName, baseName,
  * simply gets null and can retry with a different name.
  */
 export function tryAddEphemeralAgentToDatabase(workspacePath, agentName, baseName, themeId, mountMode = 'worktree') {
-    const db = openWorkspaceDatabase(workspacePath);
+    const sqliteDb = openWorkspaceDatabase(workspacePath);
+    const ddb = createDrizzleConnection(sqliteDb);
     try {
         const now = new Date().toISOString();
         const worktreePath = `agents/temp/${agentName}`;
-        db.prepare(`
-      INSERT INTO agents (name, type, status, base_name, theme_id, worktree_path, mount_mode, created_at)
-      VALUES (?, ?, ?, ?, ?, ?, ?, ?)
-    `).run(agentName, 'ephemeral', 'active', baseName, themeId || null, worktreePath, mountMode, now);
-        const agent = db.prepare('SELECT * FROM agents WHERE name = ?').get(agentName);
-        return {
-            name: agent.name,
-            type: agent.type,
-            status: agent.status,
-            base_name: agent.base_name,
-            theme_id: agent.theme_id,
-            worktree_path: agent.worktree_path,
-            mount_mode: (agent.mount_mode || 'clone'),
-            created_at: agent.created_at,
-            cleaned_at: agent.cleaned_at,
-        };
+        ddb.insert(agentsTable).values({
+            name: agentName,
+            type: 'ephemeral',
+            status: 'active',
+            baseName,
+            themeId: themeId || null,
+            worktreePath,
+            mountMode,
+            createdAt: now,
+        }).run();
+        const agent = ddb.select().from(agentsTable)
+            .where(eq(agentsTable.name, agentName))
+            .get();
+        if (!agent)
+            return null;
+        return toAgent(agent);
     }
     catch (err) {
         const sqliteErr = err;
@@ -298,48 +403,50 @@ export function tryAddEphemeralAgentToDatabase(workspacePath, agentName, baseNam
         throw err;
     }
     finally {
-        db.close();
+        sqliteDb.close();
     }
 }
 /**
  * Get all ephemeral agent names from the database
  */
 export function getEphemeralAgentNames(workspacePath) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const agents = db.prepare("SELECT name FROM agents WHERE type = 'ephemeral'").all();
-    db.close();
-    return new Set(agents.map(a => a.name.toLowerCase()));
+    return withDrizzle(workspacePath, (ddb) => {
+        const rows = ddb.select({ name: agentsTable.name })
+            .from(agentsTable)
+            .where(eq(agentsTable.type, 'ephemeral'))
+            .all();
+        return new Set(rows.map(a => a.name.toLowerCase()));
+    });
 }
 /**
  * Remove an ephemeral agent from the database
  */
 export function removeEphemeralAgent(workspacePath, agentName) {
-    const db = openWorkspaceDatabase(workspacePath);
-    db.prepare("DELETE FROM agents WHERE name = ? AND type = 'ephemeral'").run(agentName);
-    db.close();
+    withDrizzle(workspacePath, (ddb) => {
+        ddb.delete(agentsTable)
+            .where(and(eq(agentsTable.name, agentName), eq(agentsTable.type, 'ephemeral')))
+            .run();
+    });
 }
 /**
  * Get all agents in workspace
  */
 export function getWorkspaceAgents(workspacePath, includeCleanedUp = false) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const query = includeCleanedUp
-        ? 'SELECT * FROM agents ORDER BY created_at'
-        : "SELECT * FROM agents WHERE status = 'active' OR status IS NULL ORDER BY created_at";
-    const rows = db.prepare(query).all();
-    db.close();
-    // Map rows to Agent type, handling missing columns in old databases
-    return rows.map(row => ({
-        name: row.name,
-        type: (row.type || 'persistent'),
-        status: (row.status || 'active'),
-        base_name: row.base_name,
-        theme_id: row.theme_id,
-        worktree_path: row.worktree_path,
-        mount_mode: (row.mount_mode || 'worktree'),
-        created_at: row.created_at,
-        cleaned_at: row.cleaned_at,
-    }));
+    return withDrizzle(workspacePath, (ddb) => {
+        let rows;
+        if (includeCleanedUp) {
+            rows = ddb.select().from(agentsTable)
+                .orderBy(asc(agentsTable.createdAt))
+                .all();
+        }
+        else {
+            rows = ddb.select().from(agentsTable)
+                .where(or(eq(agentsTable.status, 'active'), isNull(agentsTable.status)))
+                .orderBy(asc(agentsTable.createdAt))
+                .all();
+        }
+        return rows.map(toAgent);
+    });
 }
 /**
  * Get an agent by directory path.
@@ -356,38 +463,31 @@ export function getAgentByPath(workspacePath, absolutePath) {
     }
     // Get relative path from workspace root
     const relativePath = path.relative(normalizedWorkspace, normalizedPath);
-    const db = openWorkspaceDatabase(workspacePath);
-    const agents = db.prepare("SELECT * FROM agents WHERE status = 'active' OR status IS NULL").all();
-    db.close();
-    // Find agent whose worktree_path matches or contains the relative path
-    for (const row of agents) {
-        if (row.worktree_path) {
-            // Check if relativePath starts with or equals the agent's worktree_path
-            if (relativePath === row.worktree_path || relativePath.startsWith(row.worktree_path + '/')) {
-                return {
-                    name: row.name,
-                    type: (row.type || 'persistent'),
-                    status: (row.status || 'active'),
-                    base_name: row.base_name,
-                    theme_id: row.theme_id,
-                    worktree_path: row.worktree_path,
-                    mount_mode: (row.mount_mode || 'worktree'),
-                    created_at: row.created_at,
-                    cleaned_at: row.cleaned_at,
-                };
+    return withDrizzle(workspacePath, (ddb) => {
+        const rows = ddb.select().from(agentsTable)
+            .where(or(eq(agentsTable.status, 'active'), isNull(agentsTable.status)))
+            .all();
+        // Find agent whose worktree_path matches or contains the relative path
+        for (const row of rows) {
+            if (row.worktreePath) {
+                if (relativePath === row.worktreePath || relativePath.startsWith(row.worktreePath + '/')) {
+                    return toAgent(row);
+                }
             }
         }
-    }
-    return null;
+        return null;
+    });
 }
 /**
  * Mark an agent as cleaned up (keeps the record for history)
  */
 export function markAgentCleaned(workspacePath, agentName) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const now = new Date().toISOString();
-    db.prepare("UPDATE agents SET status = 'cleaned', cleaned_at = ? WHERE name = ?").run(now, agentName);
-    db.close();
+    withDrizzle(workspacePath, (ddb) => {
+        ddb.update(agentsTable)
+            .set({ status: 'cleaned', cleanedAt: new Date().toISOString() })
+            .where(eq(agentsTable.name, agentName))
+            .run();
+    });
 }
 /**
  * Sync agents in database with what exists on disk.
@@ -395,9 +495,9 @@ export function markAgentCleaned(workspacePath, agentName) {
  * Returns list of agents that were cleaned up.
  */
 export function syncAgentsWithDisk(workspacePath) {
-    const agents = getWorkspaceAgents(workspacePath, false); // Only active agents
+    const agentList = getWorkspaceAgents(workspacePath, false); // Only active agents
     const cleanedAgents = [];
-    for (const agent of agents) {
+    for (const agent of agentList) {
         // Determine expected directory path
         let agentDir;
         if (agent.worktree_path) {
@@ -431,9 +531,8 @@ export function discoverAgentsOnDisk(workspacePath) {
     const activeNames = new Set(activeAgents.map(a => a.name.toLowerCase()));
     // Get ALL agents including cleaned (for reactivation)
     const allAgents = getWorkspaceAgents(workspacePath, true);
-    const cleanedAgents = new Map(allAgents.filter(a => a.status === 'cleaned').map(a => [a.name.toLowerCase(), a]));
-    const db = openWorkspaceDatabase(workspacePath);
-    try {
+    const cleanedAgentsMap = new Map(allAgents.filter(a => a.status === 'cleaned').map(a => [a.name.toLowerCase(), a]));
+    withDrizzle(workspacePath, (ddb) => {
         // Scan staff directory
         const staffDir = path.join(workspacePath, 'agents', 'staff');
         if (fs.existsSync(staffDir)) {
@@ -444,21 +543,24 @@ export function discoverAgentsOnDisk(workspacePath) {
                     if (!activeNames.has(nameLower)) {
                         const worktreePath = `agents/staff/${entry.name}`;
                         const now = new Date().toISOString();
-                        // Check if this is a cleaned agent that should be reactivated
-                        const cleanedAgent = cleanedAgents.get(nameLower);
+                        const cleanedAgent = cleanedAgentsMap.get(nameLower);
                         if (cleanedAgent) {
                             // Reactivate the cleaned agent
-                            db.prepare(`
-                UPDATE agents SET status = 'active', cleaned_at = NULL, worktree_path = ?
-                WHERE LOWER(name) = LOWER(?)
-              `).run(worktreePath, entry.name);
+                            ddb.update(agentsTable)
+                                .set({ status: 'active', cleanedAt: null, worktreePath })
+                                .where(sql `LOWER(${agentsTable.name}) = LOWER(${entry.name})`)
+                                .run();
                         }
                         else {
-                            // Register new agent - discovered agents default to 'worktree' mode (legacy behavior)
-                            db.prepare(`
-                INSERT INTO agents (name, type, status, worktree_path, mount_mode, created_at)
-                VALUES (?, 'persistent', 'active', ?, 'worktree', ?)
-              `).run(entry.name, worktreePath, now);
+                            // Register new agent
+                            ddb.insert(agentsTable).values({
+                                name: entry.name,
+                                type: 'persistent',
+                                status: 'active',
+                                worktreePath,
+                                mountMode: 'worktree',
+                                createdAt: now,
+                            }).run();
                         }
                         result.discovered.push({ name: entry.name, type: 'persistent', path: worktreePath });
                         activeNames.add(nameLower);
@@ -476,21 +578,24 @@ export function discoverAgentsOnDisk(workspacePath) {
                     if (!activeNames.has(nameLower)) {
                         const worktreePath = `agents/temp/${entry.name}`;
                         const now = new Date().toISOString();
-                        // Check if this is a cleaned agent that should be reactivated
-                        const cleanedAgent = cleanedAgents.get(nameLower);
+                        const cleanedAgent = cleanedAgentsMap.get(nameLower);
                         if (cleanedAgent) {
                             // Reactivate the cleaned agent
-                            db.prepare(`
-                UPDATE agents SET status = 'active', cleaned_at = NULL, worktree_path = ?
-                WHERE LOWER(name) = LOWER(?)
-              `).run(worktreePath, entry.name);
+                            ddb.update(agentsTable)
+                                .set({ status: 'active', cleanedAt: null, worktreePath })
+                                .where(sql `LOWER(${agentsTable.name}) = LOWER(${entry.name})`)
+                                .run();
                         }
                         else {
-                            // Register new agent - discovered agents default to 'worktree' mode (legacy behavior)
-                            db.prepare(`
-                INSERT INTO agents (name, type, status, worktree_path, mount_mode, created_at)
-                VALUES (?, 'ephemeral', 'active', ?, 'worktree', ?)
-              `).run(entry.name, worktreePath, now);
+                            // Register new agent
+                            ddb.insert(agentsTable).values({
+                                name: entry.name,
+                                type: 'ephemeral',
+                                status: 'active',
+                                worktreePath,
+                                mountMode: 'worktree',
+                                createdAt: now,
+                            }).run();
                         }
                         result.discovered.push({ name: entry.name, type: 'ephemeral', path: worktreePath });
                         activeNames.add(nameLower);
@@ -498,79 +603,123 @@ export function discoverAgentsOnDisk(workspacePath) {
                 }
             }
         }
-    }
-    finally {
-        db.close();
-    }
+    });
     return result;
 }
 /**
  * Get all repositories in workspace
  */
 export function getWorkspaceRepositories(workspacePath) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const repos = db.prepare('SELECT * FROM repositories ORDER BY added_at').all();
-    db.close();
-    return repos;
+    return withDrizzle(workspacePath, (ddb) => {
+        const rows = ddb.select().from(repositoriesTable)
+            .orderBy(asc(repositoriesTable.addedAt))
+            .all();
+        return rows.map(row => ({
+            name: row.name,
+            path: row.path,
+            type: (row.type || 'main'),
+            source_url: row.sourceUrl ?? undefined,
+            action: (row.action ?? undefined),
+            added_at: row.addedAt,
+        }));
+    });
 }
 /**
  * Get worktrees for a specific agent
  */
 export function getAgentWorktrees(workspacePath, agentName) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const worktrees = db.prepare('SELECT * FROM agent_worktrees WHERE agent_name = ?').all(agentName);
-    db.close();
-    return worktrees;
+    return withDrizzle(workspacePath, (ddb) => {
+        const rows = ddb.select().from(agentWorktreesTable)
+            .where(eq(agentWorktreesTable.agentName, agentName))
+            .all();
+        return rows.map(row => ({
+            agent_name: row.agentName,
+            repo_name: row.repoName,
+            worktree_path: row.worktreePath,
+            branch: row.branch,
+            created_at: row.createdAt,
+            last_commit_hash: row.lastCommitHash ?? undefined,
+            commits_ahead: row.commitsAhead,
+            is_clean: Boolean(row.isClean),
+            last_checked: row.lastChecked ?? undefined,
+        }));
+    });
 }
 /**
  * Find agent worktrees matching a branch pattern (case-insensitive LIKE).
  */
 export function findWorktreesByBranch(workspacePath, branchPattern) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const worktrees = db.prepare('SELECT * FROM agent_worktrees WHERE LOWER(branch) LIKE ?').all(branchPattern);
-    db.close();
-    return worktrees;
+    return withDrizzle(workspacePath, (ddb) => {
+        const rows = ddb.select().from(agentWorktreesTable)
+            .where(like(sql `LOWER(${agentWorktreesTable.branch})`, branchPattern))
+            .all();
+        return rows.map(row => ({
+            agent_name: row.agentName,
+            repo_name: row.repoName,
+            worktree_path: row.worktreePath,
+            branch: row.branch,
+            created_at: row.createdAt,
+            last_commit_hash: row.lastCommitHash ?? undefined,
+            commits_ahead: row.commitsAhead,
+            is_clean: Boolean(row.isClean),
+            last_checked: row.lastChecked ?? undefined,
+        }));
+    });
 }
 /**
  * Get agent worktrees for a specific repository.
  */
 export function getWorktreesForRepo(workspacePath, repoName) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const worktrees = db.prepare('SELECT agent_name, is_clean, commits_ahead, branch FROM agent_worktrees WHERE repo_name = ?').all(repoName);
-    db.close();
-    return worktrees;
+    return withDrizzle(workspacePath, (ddb) => {
+        const rows = ddb.select({
+            agent_name: agentWorktreesTable.agentName,
+            is_clean: sql `${agentWorktreesTable.isClean}`,
+            commits_ahead: agentWorktreesTable.commitsAhead,
+            branch: agentWorktreesTable.branch,
+        }).from(agentWorktreesTable)
+            .where(eq(agentWorktreesTable.repoName, repoName))
+            .all();
+        return rows;
+    });
 }
 /**
  * Upsert a workspace setting (key-value pair).
  */
 export function upsertWorkspaceSetting(db, key, value) {
-    db.prepare(`
-    INSERT INTO workspace_settings (key, value)
-    VALUES (?, ?)
-    ON CONFLICT(key) DO UPDATE SET value = excluded.value
-  `).run(key, value);
+    const ddb = createDrizzleConnection(db);
+    ddb.insert(workspaceSettingsTable)
+        .values({ key, value })
+        .onConflictDoUpdate({
+        target: workspaceSettingsTable.key,
+        set: { value },
+    })
+        .run();
 }
 /**
  * Remove agents from database
  */
 export function removeAgentsFromDatabase(workspacePath, agentNames) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const deleteAgent = db.prepare('DELETE FROM agents WHERE name = ?');
-    // Note: agent_worktrees will be deleted automatically due to CASCADE
-    const transaction = db.transaction(() => {
-        for (const agentName of agentNames) {
-            deleteAgent.run(agentName);
-        }
+    withDrizzle(workspacePath, (ddb, sqliteDb) => {
+        // Note: agent_worktrees will be deleted automatically due to CASCADE
+        const transaction = sqliteDb.transaction(() => {
+            for (const agentName of agentNames) {
+                ddb.delete(agentsTable)
+                    .where(eq(agentsTable.name, agentName))
+                    .run();
+            }
+        });
+        transaction();
     });
-    transaction();
-    db.close();
 }
 // =============================================================================
 // PMO Bootstrapping Operations
+// Raw SQL is required here because these operate before migrations run
+// or perform DDL operations that Drizzle doesn't support.
 // =============================================================================
 /**
  * Check if PMO tables exist and get basic stats.
  * Used by pmo init to detect existing PMO before storage layer is available.
+ * Raw SQL: uses sqlite_master introspection (pre-migration bootstrap).
  */
 export function checkPMOExists(dbPath) {
     let db;
@@ -601,6 +750,7 @@ export function checkPMOExists(dbPath) {
 /**
  * Get a PMO setting from the pmo_settings table.
  * Used for bootstrapping queries before storage layer is available.
+ * Raw SQL: pre-migration bootstrap query.
  */
 export function getPMOSetting(dbPath, key) {
     let db;
@@ -625,6 +775,7 @@ export function getPMOSetting(dbPath, key) {
 /**
  * Drop PMO tables from the database.
  * Used during PMO reinitialization.
+ * Raw SQL: DDL operations (DROP TABLE) are not supported by Drizzle.
  */
 export function dropPMOTables(dbPath, tables) {
     let db;
@@ -656,61 +807,79 @@ export function dropPMOTables(dbPath, tables) {
  * Get all themes
  */
 export function getThemes(workspacePath) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const themes = db.prepare('SELECT * FROM agent_themes ORDER BY builtin DESC, name').all();
-    db.close();
-    return themes;
+    return withDrizzle(workspacePath, (ddb) => {
+        const rows = ddb.select().from(agentThemesTable)
+            .orderBy(desc(agentThemesTable.builtin), asc(agentThemesTable.name))
+            .all();
+        return rows.map(toAgentTheme);
+    });
 }
 /**
  * Get a theme by ID
  */
 export function getTheme(workspacePath, themeId) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const theme = db.prepare('SELECT * FROM agent_themes WHERE id = ?').get(themeId);
-    db.close();
-    return theme || null;
+    return withDrizzle(workspacePath, (ddb) => {
+        const row = ddb.select().from(agentThemesTable)
+            .where(eq(agentThemesTable.id, themeId))
+            .get();
+        return row ? toAgentTheme(row) : null;
+    });
 }
 /**
  * Create a new theme
  */
 export function createTheme(workspacePath, theme) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const now = new Date().toISOString();
-    db.prepare(`
-    INSERT INTO agent_themes (id, name, display_name, description, builtin, created_at)
-    VALUES (?, ?, ?, ?, ?, ?)
-  `).run(theme.id, theme.name, theme.displayName, theme.description || null, theme.builtin ? 1 : 0, now);
-    const created = db.prepare('SELECT * FROM agent_themes WHERE id = ?').get(theme.id);
-    db.close();
-    return created;
+    return withDrizzle(workspacePath, (ddb) => {
+        const now = new Date().toISOString();
+        ddb.insert(agentThemesTable).values({
+            id: theme.id,
+            name: theme.name,
+            displayName: theme.displayName,
+            description: theme.description || null,
+            builtin: theme.builtin || false,
+            createdAt: now,
+        }).run();
+        const created = ddb.select().from(agentThemesTable)
+            .where(eq(agentThemesTable.id, theme.id))
+            .get();
+        return toAgentTheme(created);
+    });
 }
 /**
  * Delete a theme (cannot delete builtin themes)
  */
 export function deleteTheme(workspacePath, themeId) {
-    const db = openWorkspaceDatabase(workspacePath);
-    // Check if builtin
-    const theme = db.prepare('SELECT builtin FROM agent_themes WHERE id = ?').get(themeId);
-    if (!theme) {
-        db.close();
-        return false;
-    }
-    if (theme.builtin) {
-        db.close();
-        throw new Error('Cannot delete built-in themes');
-    }
-    db.prepare('DELETE FROM agent_themes WHERE id = ?').run(themeId);
-    db.close();
-    return true;
+    return withDrizzle(workspacePath, (ddb) => {
+        const theme = ddb.select({ builtin: agentThemesTable.builtin })
+            .from(agentThemesTable)
+            .where(eq(agentThemesTable.id, themeId))
+            .get();
+        if (!theme) {
+            return false;
+        }
+        if (theme.builtin) {
+            throw new Error('Cannot delete built-in themes');
+        }
+        ddb.delete(agentThemesTable)
+            .where(eq(agentThemesTable.id, themeId))
+            .run();
+        return true;
+    });
 }
 /**
  * Get names for a theme
  */
 export function getThemeNames(workspacePath, themeId) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const names = db.prepare('SELECT * FROM agent_theme_names WHERE theme_id = ? ORDER BY name').all(themeId);
-    db.close();
-    return names;
+    return withDrizzle(workspacePath, (ddb) => {
+        const rows = ddb.select().from(agentThemeNamesTable)
+            .where(eq(agentThemeNamesTable.themeId, themeId))
+            .orderBy(asc(agentThemeNamesTable.name))
+            .all();
+        return rows.map(row => ({
+            theme_id: row.themeId,
+            name: row.name,
+        }));
+    });
 }
 /**
  * Get available names for a theme.
@@ -719,141 +888,183 @@ export function getThemeNames(workspacePath, themeId) {
  * 2. The agent exists but its worktree directory is missing (manually deleted)
  */
 export function getAvailableThemeNames(workspacePath, themeId) {
-    const db = openWorkspaceDatabase(workspacePath);
-    // Get all theme names
-    const names = db.prepare('SELECT name FROM agent_theme_names WHERE theme_id = ? ORDER BY name').all(themeId);
-    // Get existing staff agents with their worktree paths (persistent type only)
-    const existingAgents = db.prepare(`
-    SELECT LOWER(name) as name, worktree_path
-    FROM agents
-    WHERE type = 'persistent' AND (status = 'active' OR status IS NULL)
-  `).all();
-    db.close();
-    // Build a set of names that are truly in use (agent exists AND worktree exists)
-    const inUseNames = new Set();
-    for (const agent of existingAgents) {
-        if (agent.worktree_path) {
-            const fullPath = path.join(workspacePath, agent.worktree_path);
-            if (fs.existsSync(fullPath)) {
+    return withDrizzle(workspacePath, (ddb) => {
+        // Get all theme names
+        const names = ddb.select({ name: agentThemeNamesTable.name })
+            .from(agentThemeNamesTable)
+            .where(eq(agentThemeNamesTable.themeId, themeId))
+            .orderBy(asc(agentThemeNamesTable.name))
+            .all();
+        // Get existing staff agents with their worktree paths (persistent type only)
+        const existingAgents = ddb.select({
+            name: sql `LOWER(${agentsTable.name})`,
+            worktreePath: agentsTable.worktreePath,
+        })
+            .from(agentsTable)
+            .where(and(eq(agentsTable.type, 'persistent'), or(eq(agentsTable.status, 'active'), isNull(agentsTable.status))))
+            .all();
+        // Build a set of names that are truly in use (agent exists AND worktree exists)
+        const inUseNames = new Set();
+        for (const agent of existingAgents) {
+            if (agent.worktreePath) {
+                const fullPath = path.join(workspacePath, agent.worktreePath);
+                if (fs.existsSync(fullPath)) {
+                    inUseNames.add(agent.name);
+                }
+            }
+            else {
+                // No worktree path means we can't verify - treat as in use to be safe
                 inUseNames.add(agent.name);
             }
         }
-        else {
-            // No worktree path means we can't verify - treat as in use to be safe
-            inUseNames.add(agent.name);
-        }
-    }
-    // Filter out names that are truly in use
-    return names
-        .map(n => n.name)
-        .filter(name => !inUseNames.has(name.toLowerCase()));
+        // Filter out names that are truly in use
+        return names
+            .map(n => n.name)
+            .filter(name => !inUseNames.has(name.toLowerCase()));
+    });
 }
 /**
  * Add names to a theme (case-insensitive uniqueness)
  */
 export function addThemeNames(workspacePath, themeId, names) {
-    const db = openWorkspaceDatabase(workspacePath);
-    // Check for existing name (case-insensitive)
-    const checkExisting = db.prepare('SELECT name FROM agent_theme_names WHERE theme_id = ? AND LOWER(name) = LOWER(?)');
-    const insertName = db.prepare(`
-    INSERT INTO agent_theme_names (theme_id, name)
-    VALUES (?, ?)
-  `);
-    const transaction = db.transaction(() => {
-        for (const name of names) {
-            // Skip if name already exists (case-insensitive)
-            const existing = checkExisting.get(themeId, name);
-            if (existing) {
-                continue;
+    withDrizzle(workspacePath, (ddb, sqliteDb) => {
+        const transaction = sqliteDb.transaction(() => {
+            for (const name of names) {
+                // Check for existing name (case-insensitive)
+                const existing = ddb.select({ name: agentThemeNamesTable.name })
+                    .from(agentThemeNamesTable)
+                    .where(and(eq(agentThemeNamesTable.themeId, themeId), sql `LOWER(${agentThemeNamesTable.name}) = LOWER(${name})`))
+                    .get();
+                if (existing) {
+                    continue;
+                }
+                ddb.insert(agentThemeNamesTable).values({
+                    themeId,
+                    name,
+                }).run();
             }
-            insertName.run(themeId, name);
-        }
+        });
+        transaction();
     });
-    transaction();
-    db.close();
 }
 /**
  * Add a media item to the database
  */
 export function addMediaItemToDatabase(workspacePath, item) {
-    const db = openWorkspaceDatabase(workspacePath);
-    db.prepare(`
-    INSERT OR REPLACE INTO media_items (name, path, source_path, media_type, frame_interval, added_at)
-    VALUES (?, ?, ?, ?, ?, ?)
-  `).run(item.name, item.path, item.source_path || null, item.media_type, item.frame_interval || 30, new Date().toISOString());
-    db.close();
+    withDrizzle(workspacePath, (ddb) => {
+        const now = new Date().toISOString();
+        ddb.insert(mediaItemsTable)
+            .values({
+            name: item.name,
+            path: item.path,
+            sourcePath: item.source_path || null,
+            mediaType: item.media_type,
+            frameInterval: item.frame_interval || 30,
+            addedAt: now,
+        })
+            .onConflictDoUpdate({
+            target: mediaItemsTable.name,
+            set: {
+                path: item.path,
+                sourcePath: item.source_path || null,
+                mediaType: item.media_type,
+                frameInterval: item.frame_interval || 30,
+                addedAt: now,
+            },
+        })
+            .run();
+    });
 }
 /**
  * Update media item after preprocessing
  */
 export function updateMediaItemStatus(workspacePath, name, updates) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const sets = ['status = ?'];
-    const values = [updates.status];
-    if (updates.duration_seconds !== undefined) {
-        sets.push('duration_seconds = ?');
-        values.push(updates.duration_seconds);
-    }
-    if (updates.resolution !== undefined) {
-        sets.push('resolution = ?');
-        values.push(updates.resolution);
-    }
-    if (updates.frame_count !== undefined) {
-        sets.push('frame_count = ?');
-        values.push(updates.frame_count);
-    }
-    if (updates.has_transcript !== undefined) {
-        sets.push('has_transcript = ?');
-        values.push(updates.has_transcript ? 1 : 0);
-    }
-    if (updates.error_message !== undefined) {
-        sets.push('error_message = ?');
-        values.push(updates.error_message);
-    }
-    if (updates.status === 'ready' || updates.status === 'error') {
-        sets.push('processed_at = ?');
-        values.push(new Date().toISOString());
-    }
-    values.push(name);
-    db.prepare(`UPDATE media_items SET ${sets.join(', ')} WHERE name = ?`).run(...values);
-    db.close();
+    withDrizzle(workspacePath, (ddb) => {
+        const setValues = { status: updates.status };
+        if (updates.duration_seconds !== undefined) {
+            setValues.durationSeconds = updates.duration_seconds;
+        }
+        if (updates.resolution !== undefined) {
+            setValues.resolution = updates.resolution;
+        }
+        if (updates.frame_count !== undefined) {
+            setValues.frameCount = updates.frame_count;
+        }
+        if (updates.has_transcript !== undefined) {
+            setValues.hasTranscript = updates.has_transcript;
+        }
+        if (updates.error_message !== undefined) {
+            setValues.errorMessage = updates.error_message;
+        }
+        if (updates.status === 'ready' || updates.status === 'error') {
+            setValues.processedAt = new Date().toISOString();
+        }
+        ddb.update(mediaItemsTable)
+            .set(setValues)
+            .where(eq(mediaItemsTable.name, name))
+            .run();
+    });
 }
 /**
  * Get all media items in workspace
  */
 export function getWorkspaceMediaItems(workspacePath) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const rows = db.prepare('SELECT * FROM media_items ORDER BY added_at').all();
-    db.close();
-    return rows.map(row => ({
-        ...row,
-        media_type: row.media_type,
-        has_transcript: Boolean(row.has_transcript),
-        status: row.status,
-    }));
+    return withDrizzle(workspacePath, (ddb) => {
+        const rows = ddb.select().from(mediaItemsTable)
+            .orderBy(asc(mediaItemsTable.addedAt))
+            .all();
+        return rows.map(row => ({
+            name: row.name,
+            path: row.path,
+            source_path: row.sourcePath,
+            media_type: row.mediaType,
+            duration_seconds: row.durationSeconds,
+            resolution: row.resolution,
+            frame_count: row.frameCount,
+            has_transcript: Boolean(row.hasTranscript),
+            frame_interval: row.frameInterval,
+            status: row.status,
+            error_message: row.errorMessage,
+            added_at: row.addedAt,
+            processed_at: row.processedAt,
+        }));
+    });
 }
 /**
  * Get a single media item by name
  */
 export function getMediaItem(workspacePath, name) {
-    const db = openWorkspaceDatabase(workspacePath);
-    const row = db.prepare('SELECT * FROM media_items WHERE name = ?').get(name);
-    db.close();
-    if (!row)
-        return null;
-    return {
-        ...row,
-        media_type: row.media_type,
-        has_transcript: Boolean(row.has_transcript),
-        status: row.status,
-    };
+    return withDrizzle(workspacePath, (ddb) => {
+        const row = ddb.select().from(mediaItemsTable)
+            .where(eq(mediaItemsTable.name, name))
+            .get();
+        if (!row)
+            return null;
+        return {
+            name: row.name,
+            path: row.path,
+            source_path: row.sourcePath,
+            media_type: row.mediaType,
+            duration_seconds: row.durationSeconds,
+            resolution: row.resolution,
+            frame_count: row.frameCount,
+            has_transcript: Boolean(row.hasTranscript),
+            frame_interval: row.frameInterval,
+            status: row.status,
+            error_message: row.errorMessage,
+            added_at: row.addedAt,
+            processed_at: row.processedAt,
+        };
+    });
 }
 /**
  * Remove a media item from the database
  */
 export function removeMediaItemFromDatabase(workspacePath, name) {
-    const db = openWorkspaceDatabase(workspacePath);
-    db.prepare('DELETE FROM media_items WHERE name = ?').run(name);
-    db.close();
+    withDrizzle(workspacePath, (ddb) => {
+        ddb.delete(mediaItemsTable)
+            .where(eq(mediaItemsTable.name, name))
+            .run();
+    });
 }
 //# sourceMappingURL=index.js.map