hungry-ghost-hive 0.48.0 → 0.49.0

package/src/cli/commands/manager/handoff-recovery.ts

@@ -2,8 +2,7 @@
 
 import chalk from 'chalk';
 import { syncStatusForStory } from '../../../connectors/project-management/operations.js';
-import type { DatabaseClient, StoryRow } from '../../../db/client.js';
-import { queryAll, withTransaction } from '../../../db/client.js';
+import type { StoryRow } from '../../../db/client.js';
 import { getTechLead } from '../../../db/queries/agents.js';
 import { createEscalation } from '../../../db/queries/escalations.js';
 import { createLog } from '../../../db/queries/logs.js';
@@ -49,15 +48,14 @@ function getLatestStoryUpdateMs(stories: StoryRow[]): number {
   return latestMs;
 }
 
-function getActivePipelineCountForRequirement(
-  db: DatabaseClient['db'],
+async function getActivePipelineCountForRequirement(
+  db: import('../../../db/provider.js').DatabaseProvider,
   requirementId: string | null
-): number {
+): Promise<number> {
   const statuses = `'planned', 'in_progress', 'review', 'qa', 'qa_failed', 'pr_submitted'`;
 
   if (requirementId) {
-    const result = queryAll<{ count: number }>(
-      db,
+    const result = await db.queryAll<{ count: number }>(
       `
       SELECT COUNT(*) as count
       FROM stories
@@ -69,8 +67,7 @@ function getActivePipelineCountForRequirement(
     return result[0]?.count || 0;
   }
 
-  const result = queryAll<{ count: number }>(
-    db,
+  const result = await db.queryAll<{ count: number }>(
     `
     SELECT COUNT(*) as count
     FROM stories
@@ -89,7 +86,7 @@ async function nudgeTechLeadForStalledHandoff(
   // Brief lock for DB read
   const fallbackSession = getTechLeadSessionName(ctx.paths.hiveDir);
   const techLeadInfo = await ctx.withDb(async db => {
-    const techLead = getTechLead(db.db);
+    const techLead = await getTechLead(db.provider);
     return techLead
       ? {
           sessionName: techLead.tmux_session || fallbackSession,
@@ -144,7 +141,7 @@ async function nudgeTechLeadForStalledHandoff(
 
   // Brief lock for log write
   await ctx.withDb(async db => {
-    createLog(db.db, {
+    await createLog(db.provider, {
       agentId: 'manager',
       eventType: 'STORY_PROGRESS_UPDATE',
       message: `Nudged Tech Lead to unblock stalled planning handoff for ${requirementLabel}`,
@@ -164,17 +161,17 @@ async function promoteEstimatedStoriesToPlanned(
   const promoted = await ctx.withDb(async db => {
     let count = 0;
 
-    await withTransaction(db.db, () => {
+    await db.provider.withTransaction(async () => {
       for (const story of stories) {
-        updateStory(db.db, story.id, { status: 'planned' });
+        await updateStory(db.provider, story.id, { status: 'planned' });
         count++;
       }
 
       if (requirementId) {
-        updateRequirement(db.db, requirementId, { status: 'planned' });
+        await updateRequirement(db.provider, requirementId, { status: 'planned' });
       }
 
-      createLog(db.db, {
+      await createLog(db.provider, {
         agentId: 'manager',
         eventType: 'PLANNING_COMPLETED',
         message: `Auto-promoted ${count} estimated story/ies to planned (${reason})`,
@@ -186,7 +183,7 @@ async function promoteEstimatedStoriesToPlanned(
 
     // Sync status changes to Jira
     for (const story of stories) {
-      await syncStatusForStory(ctx.root, db.db, story.id, 'planned');
+      await syncStatusForStory(ctx.root, db.provider, story.id, 'planned');
     }
 
     return count;
@@ -216,8 +213,8 @@ async function runAutoAssignmentAfterHandoff(ctx: ManagerCheckContext): Promise<
 
     if (result.errors.length > 0) {
       const reason = `Manager auto-handoff recovered planning but assignment still has errors: ${result.errors.join('; ')}`;
-      createEscalation(db.db, { reason });
-      createLog(db.db, {
+      await createEscalation(db.provider, { reason });
+      await createLog(db.provider, {
         agentId: 'manager',
         eventType: 'ESCALATION_CREATED',
         status: 'error',
@@ -234,7 +231,7 @@ async function runAutoAssignmentAfterHandoff(ctx: ManagerCheckContext): Promise<
 export async function handleStalledPlanningHandoff(ctx: ManagerCheckContext): Promise<void> {
   // Phase 1: Read estimated stories and evaluate handoff state (brief lock)
   const { groupedStories, estimatedCount } = await ctx.withDb(async db => {
-    const estimatedStories = getStoriesByStatus(db.db, 'estimated');
+    const estimatedStories = await getStoriesByStatus(db.provider, 'estimated');
     verboseLog(ctx, `handoff: estimatedStories=${estimatedStories.length}`);
 
     const grouped = new Map<string, { requirementId: string | null; stories: StoryRow[] }>();
@@ -258,7 +255,10 @@ export async function handleStalledPlanningHandoff(ctx: ManagerCheckContext): Pr
     }> = [];
 
     for (const [key, group] of grouped) {
-      const activePipelineCount = getActivePipelineCountForRequirement(db.db, group.requirementId);
+      const activePipelineCount = await getActivePipelineCountForRequirement(
+        db.provider,
+        group.requirementId
+      );
       const latestUpdateMs = getLatestStoryUpdateMs(group.stories);
       groupsWithPipeline.push({
         key,

package/src/cli/commands/manager/index.test.ts

@@ -1,7 +1,7 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
-import type { Database } from 'sql.js';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import type { DatabaseProvider } from '../../../db/provider.js';
 import { getApprovedPullRequests, updatePullRequest } from '../../../db/queries/pull-requests.js';
 
 // Mock the functions we're testing with
@@ -30,12 +30,12 @@ describe('Auto-merge PRs', () => {
     vi.clearAllMocks();
   });
 
-  it('should return 0 when no approved PRs exist', () => {
+  it('should return 0 when no approved PRs exist', async () => {
     // Mock empty approved PRs
-    vi.mocked(getApprovedPullRequests).mockReturnValue([]);
+    vi.mocked(getApprovedPullRequests).mockResolvedValue([]);
 
     // This is a basic test to ensure the function handles empty PR lists
-    const approvedPRs = getApprovedPullRequests({} as Database);
+    const approvedPRs = await getApprovedPullRequests({} as DatabaseProvider);
     expect(approvedPRs).toEqual([]);
   });
 

package/src/cli/commands/manager/index.ts

@@ -8,9 +8,8 @@ import { loadConfig } from '../../../config/loader.js';
 import type { HiveConfig } from '../../../config/schema.js';
 import { syncFromProvider } from '../../../connectors/project-management/operations.js';
 import type { StoryRow } from '../../../db/client.js';
-import { queryAll, queryOne, withTransaction } from '../../../db/client.js';
 import { acquireLock } from '../../../db/lock.js';
-import { getAgentById, getAllAgents } from '../../../db/queries/agents.js';
+import { getAgentById, getAllAgents, type AgentRow } from '../../../db/queries/agents.js';
 import { getPendingEscalations, updateEscalation } from '../../../db/queries/escalations.js';
 import { createLog } from '../../../db/queries/logs.js';
 import {
@@ -442,7 +441,7 @@ managerCommand
           return;
         }
       }
-      const scheduler = new Scheduler(db.db, {
+      const scheduler = new Scheduler(db.provider, {
         scaling: config.scaling,
         models: config.models,
         qa: config.qa,
@@ -511,7 +510,7 @@ managerCommand
   .option('-m, --message <msg>', 'Custom message to send')
   .action(async (session: string, options: { message?: string }) => {
     await withHiveContext(async ({ root, db }) => {
-      const agent = getAgentById(db.db, session.replace('hive-', ''));
+      const agent = await getAgentById(db.provider, session.replace('hive-', ''));
       const cliTool = (agent?.cli_tool || 'claude') as CLITool;
       await nudgeAgent(root, session, options.message, undefined, undefined, cliTool);
       console.log(chalk.green(`Nudged ${session}`));
@@ -584,7 +583,7 @@ async function managerCheck(
     fn: (db: import('../../../db/client.js').DatabaseClient, scheduler: Scheduler) => Promise<T> | T
   ): Promise<T> => {
     return withHiveContext(async ({ db }) => {
-      const scheduler = new Scheduler(db.db, {
+      const scheduler = new Scheduler(db.provider, {
         scaling: resolvedConfig.scaling,
         models: resolvedConfig.models,
         qa: resolvedConfig.qa,
@@ -706,7 +705,7 @@ async function managerCheck(
 
 async function backfillPRNumbers(ctx: ManagerCheckContext): Promise<void> {
   await ctx.withDb(async db => {
-    const backfilled = backfillGithubPrNumbers(db.db);
+    const backfilled = await backfillGithubPrNumbers(db.provider);
     verboseLogCtx(ctx, `backfillPRNumbers: backfilled=${backfilled}`);
     if (backfilled > 0) {
       console.log(chalk.yellow(`  Backfilled ${backfilled} PR(s) with github_pr_number from URL`));
@@ -798,7 +797,7 @@ async function runAutoMerge(ctx: ManagerCheckContext): Promise<void> {
 
 async function syncJiraStatuses(ctx: ManagerCheckContext): Promise<void> {
   await ctx.withDb(async db => {
-    const syncedStories = await syncFromProvider(ctx.root, db.db);
+    const syncedStories = await syncFromProvider(ctx.root, db.provider);
     verboseLogCtx(ctx, `syncJiraStatuses: synced=${syncedStories}`);
     if (syncedStories > 0) {
       ctx.counters.jiraSynced = syncedStories;
@@ -812,13 +811,13 @@ async function syncJiraStatuses(ctx: ManagerCheckContext): Promise<void> {
 async function prepareSessionData(ctx: ManagerCheckContext): Promise<void> {
   await ctx.withDb(async db => {
     // Pre-populate escalation dedup set
-    const existingEscalations = getPendingEscalations(db.db);
+    const existingEscalations = await getPendingEscalations(db.provider);
     ctx.escalatedSessions = new Set(
       existingEscalations.filter(e => e.from_agent_id).map(e => e.from_agent_id)
     );
 
     // Batch fetch all agents and index by session name
-    const allAgents = getAllAgents(db.db);
+    const allAgents = await getAllAgents(db.provider);
     const bySessionName = new Map<string, (typeof allAgents)[number]>();
     for (const agent of allAgents) {
       bySessionName.set(`hive-${agent.id}`, agent);
@@ -841,14 +840,14 @@ async function resolveStaleEscalations(ctx: ManagerCheckContext): Promise<void>
       ctx.config.manager.nudge_cooldown_ms,
       ctx.config.manager.stuck_threshold_ms
     );
-    const pendingEscalations = getPendingEscalations(db.db);
+    const pendingEscalations = await getPendingEscalations(db.provider);
     verboseLogCtx(
       ctx,
       `resolveStaleEscalations: pending=${pendingEscalations.length}, staleAfterMs=${staleAfterMs}`
     );
     if (pendingEscalations.length === 0) return;
 
-    const uniqueAgents = new Map<string, ReturnType<typeof getAllAgents>[number]>();
+    const uniqueAgents = new Map<string, AgentRow>();
     for (const agent of ctx.agentsBySessionName.values()) {
       uniqueAgents.set(agent.id, agent);
     }
@@ -864,40 +863,37 @@ async function resolveStaleEscalations(ctx: ManagerCheckContext): Promise<void>
     if (staleEscalations.length === 0) return;
     verboseLogCtx(ctx, `resolveStaleEscalations: stale=${staleEscalations.length}`);
 
-    withTransaction(
-      db.db,
-      () => {
-        for (const stale of staleEscalations) {
-          updateEscalation(db.db, stale.escalation.id, {
-            status: 'resolved',
-            resolution: `Manager auto-resolved stale escalation: ${stale.reason}`,
-          });
-          if (stale.escalation.from_agent_id) {
-            ctx.escalatedSessions.delete(stale.escalation.from_agent_id);
-          }
-          ctx.counters.escalationsResolved++;
-          createLog(db.db, {
-            agentId: 'manager',
-            storyId: stale.escalation.story_id || undefined,
-            eventType: 'ESCALATION_RESOLVED',
-            message: `Auto-resolved stale escalation ${stale.escalation.id}`,
-            metadata: {
-              escalation_id: stale.escalation.id,
-              from_agent_id: stale.escalation.from_agent_id,
-              reason: stale.reason,
-            },
-          });
+    await db.provider.withTransaction(async () => {
+      for (const stale of staleEscalations) {
+        await updateEscalation(db.provider, stale.escalation.id, {
+          status: 'resolved',
+          resolution: `Manager auto-resolved stale escalation: ${stale.reason}`,
+        });
+        if (stale.escalation.from_agent_id) {
+          ctx.escalatedSessions.delete(stale.escalation.from_agent_id);
         }
-      },
-      () => db.save()
-    );
+        ctx.counters.escalationsResolved++;
+        await createLog(db.provider, {
+          agentId: 'manager',
+          storyId: stale.escalation.story_id || undefined,
+          eventType: 'ESCALATION_RESOLVED',
+          message: `Auto-resolved stale escalation ${stale.escalation.id}`,
+          metadata: {
+            escalation_id: stale.escalation.id,
+            from_agent_id: stale.escalation.from_agent_id,
+            reason: stale.reason,
+          },
+        });
+      }
+    });
+    db.save();
     console.log(chalk.yellow(`  Auto-cleared ${staleEscalations.length} stale escalation(s)`));
   });
 }
 
 async function resolveOrphanedSessionEscalations(ctx: ManagerCheckContext): Promise<void> {
   const resolvedCount = await ctx.withDb(async db => {
-    const pendingEscalations = getPendingEscalations(db.db);
+    const pendingEscalations = await getPendingEscalations(db.provider);
     verboseLogCtx(ctx, `resolveOrphanedSessionEscalations: pending=${pendingEscalations.length}`);
     if (pendingEscalations.length === 0) {
       return 0;
@@ -905,7 +901,7 @@ async function resolveOrphanedSessionEscalations(ctx: ManagerCheckContext): Prom
 
     const activeSessionNames = new Set(ctx.hiveSessions.map(session => session.name));
     const agentStatusBySessionName = new Map<string, string>();
-    for (const agent of getAllAgents(db.db)) {
+    for (const agent of await getAllAgents(db.provider)) {
       if (agent.tmux_session) {
         agentStatusBySessionName.set(agent.tmux_session, agent.status);
       }
@@ -924,11 +920,11 @@ async function resolveOrphanedSessionEscalations(ctx: ManagerCheckContext): Prom
         continue;
       }
 
-      updateEscalation(db.db, escalation.id, {
+      await updateEscalation(db.provider, escalation.id, {
         status: 'resolved',
         resolution: `Manager auto-resolved stale escalation from inactive session ${fromSession}`,
       });
-      createLog(db.db, {
+      await createLog(db.provider, {
         agentId: 'manager',
         storyId: escalation.story_id || undefined,
         eventType: 'ESCALATION_RESOLVED',
@@ -959,7 +955,7 @@ async function resolveOrphanedSessionEscalations(ctx: ManagerCheckContext): Prom
 
 async function scanAgentSessions(ctx: ManagerCheckContext): Promise<void> {
   // Phase 1: Batch fetch pending messages (brief lock)
-  const allPendingMessages = await ctx.withDb(async db => getAllPendingMessages(db.db));
+  const allPendingMessages = await ctx.withDb(async db => getAllPendingMessages(db.provider));
   const messagesBySessionName = new Map<string, MessageRow[]>();
   const activeSessionNames = new Set<string>();
   const maxStuckNudgesPerStory = getMaxStuckNudgesPerStory(ctx.config);
@@ -1080,7 +1076,7 @@ async function scanAgentSessions(ctx: ManagerCheckContext): Promise<void> {
         verboseLogCtx(ctx, `Agent ${session.name}: full-ai skipped (no current story)`);
       } else {
         // Brief lock for story lookup
-        const story = await ctx.withDb(async db => getStoryById(db.db, storyId));
+        const story = await ctx.withDb(async db => getStoryById(db.provider, storyId));
         if (!story || ['merged', 'completed'].includes(story.status)) {
           verboseLogCtx(
             ctx,
@@ -1181,7 +1177,7 @@ async function scanAgentSessions(ctx: ManagerCheckContext): Promise<void> {
             }
             // Brief lock for log write
             await ctx.withDb(async db => {
-              createLog(db.db, {
+              createLog(db.provider, {
                 agentId: 'manager',
                 storyId,
                 eventType: 'STORY_PROGRESS_UPDATE',
@@ -1222,7 +1218,7 @@ async function batchMarkMessagesRead(ctx: ManagerCheckContext): Promise<void> {
   verboseLogCtx(ctx, `batchMarkMessagesRead: count=${ctx.messagesToMarkRead.length}`);
   if (ctx.messagesToMarkRead.length > 0) {
     await ctx.withDb(async db => {
-      markMessagesRead(db.db, ctx.messagesToMarkRead);
+      markMessagesRead(db.provider, ctx.messagesToMarkRead);
       db.save();
     });
   }
@@ -1237,8 +1233,7 @@ async function batchMarkMessagesRead(ctx: ManagerCheckContext): Promise<void> {
 async function notifyUnassignedStories(ctx: ManagerCheckContext): Promise<void> {
   // Phase 1: Read planned unassigned stories (brief lock)
   const plannedCount = await ctx.withDb(async db => {
-    const plannedStories = queryAll<StoryRow>(
-      db.db,
+    const plannedStories = await db.provider.queryAll<StoryRow>(
       "SELECT * FROM stories WHERE status = 'planned' AND assigned_agent_id IS NULL"
     );
     return plannedStories.length;
@@ -1334,24 +1329,28 @@ async function printSummary(ctx: ManagerCheckContext): Promise<void> {
 
   const noActionSnapshot = await ctx.withDb(async db => {
     const pendingEscalations =
-      queryOne<{ count: number }>(
-        db.db,
-        "SELECT COUNT(*) AS count FROM escalations WHERE status = 'pending'"
+      (
+        await db.provider.queryOne<{ count: number }>(
+          "SELECT COUNT(*) AS count FROM escalations WHERE status = 'pending'"
+        )
       )?.count ?? 0;
     const pendingActionableStories =
-      queryOne<{ count: number }>(
-        db.db,
-        "SELECT COUNT(*) AS count FROM stories WHERE status IN ('planned', 'in_progress', 'review', 'qa', 'qa_failed', 'pr_submitted')"
+      (
+        await db.provider.queryOne<{ count: number }>(
+          "SELECT COUNT(*) AS count FROM stories WHERE status IN ('planned', 'in_progress', 'review', 'qa', 'qa_failed', 'pr_submitted')"
+        )
       )?.count ?? 0;
     const activeWorkerAgents =
-      queryOne<{ count: number }>(
-        db.db,
-        "SELECT COUNT(*) AS count FROM agents WHERE type != 'tech_lead' AND status != 'terminated'"
+      (
+        await db.provider.queryOne<{ count: number }>(
+          "SELECT COUNT(*) AS count FROM agents WHERE type != 'tech_lead' AND status != 'terminated'"
+        )
       )?.count ?? 0;
     const workingWorkerAgents =
-      queryOne<{ count: number }>(
-        db.db,
-        "SELECT COUNT(*) AS count FROM agents WHERE type != 'tech_lead' AND status = 'working'"
+      (
+        await db.provider.queryOne<{ count: number }>(
+          "SELECT COUNT(*) AS count FROM agents WHERE type != 'tech_lead' AND status = 'working'"
+        )
       )?.count ?? 0;
 
     return {

package/src/cli/commands/manager/merged-story-cleanup.test.ts

@@ -2,12 +2,13 @@
 
 import { describe, expect, it } from 'vitest';
 import { run } from '../../../db/client.js';
+import { SqliteProvider } from '../../../db/provider.js';
 import { createAgent, getAgentById, updateAgent } from '../../../db/queries/agents.js';
 import { createTestDatabase } from '../../../db/queries/test-helpers.js';
 import { cleanupAgentsReferencingMergedStory } from './merged-story-cleanup.js';
 
 function insertStoryRow(
-  db: Awaited<ReturnType<typeof createTestDatabase>>,
+  db: SqliteProvider,
   input: {
     id: string;
     status: string;
@@ -16,7 +17,7 @@ function insertStoryRow(
 ): void {
   const now = new Date().toISOString();
   run(
-    db,
+    db.db,
     `
       INSERT INTO stories (id, title, description, status, assigned_agent_id, created_at, updated_at)
       VALUES (?, ?, ?, ?, ?, ?, ?)
@@ -35,15 +36,22 @@ function insertStoryRow(
 
 describe('cleanupAgentsReferencingMergedStory', () => {
   it('clears stale merged-story pointers and reassigns to another active assigned story', async () => {
-    const db = await createTestDatabase();
+    const rawDb = await createTestDatabase();
+    const db = new SqliteProvider(rawDb);
 
-    const seniorA = createAgent(db, { type: 'senior', tmuxSession: 'hive-senior-a' });
-    const seniorB = createAgent(db, { type: 'senior', tmuxSession: 'hive-senior-b' });
-    const seniorTerminated = createAgent(db, { type: 'senior', tmuxSession: 'hive-senior-c' });
+    const seniorA = await createAgent(db, { type: 'senior', tmuxSession: 'hive-senior-a' });
+    const seniorB = await createAgent(db, { type: 'senior', tmuxSession: 'hive-senior-b' });
+    const seniorTerminated = await createAgent(db, {
+      type: 'senior',
+      tmuxSession: 'hive-senior-c',
+    });
 
-    updateAgent(db, seniorA.id, { status: 'working', currentStoryId: 'STORY-MERGED' });
-    updateAgent(db, seniorB.id, { status: 'working', currentStoryId: 'STORY-MERGED' });
-    updateAgent(db, seniorTerminated.id, { status: 'terminated', currentStoryId: 'STORY-MERGED' });
+    await updateAgent(db, seniorA.id, { status: 'working', currentStoryId: 'STORY-MERGED' });
+    await updateAgent(db, seniorB.id, { status: 'working', currentStoryId: 'STORY-MERGED' });
+    await updateAgent(db, seniorTerminated.id, {
+      status: 'terminated',
+      currentStoryId: 'STORY-MERGED',
+    });
 
     insertStoryRow(db, { id: 'STORY-MERGED', status: 'merged' });
     insertStoryRow(db, {
@@ -57,25 +65,26 @@ describe('cleanupAgentsReferencingMergedStory', () => {
       assignedAgentId: seniorA.id,
     });
 
-    const result = cleanupAgentsReferencingMergedStory(db, 'STORY-MERGED');
+    const result = await cleanupAgentsReferencingMergedStory(db, 'STORY-MERGED');
 
     expect(result).toEqual({ cleared: 2, reassigned: 1 });
-    expect(getAgentById(db, seniorA.id)?.current_story_id).toBe('STORY-REVIEW');
-    expect(getAgentById(db, seniorA.id)?.status).toBe('working');
-    expect(getAgentById(db, seniorB.id)?.current_story_id).toBeNull();
-    expect(getAgentById(db, seniorB.id)?.status).toBe('idle');
-    expect(getAgentById(db, seniorTerminated.id)?.current_story_id).toBe('STORY-MERGED');
+    expect((await getAgentById(db, seniorA.id))?.current_story_id).toBe('STORY-REVIEW');
+    expect((await getAgentById(db, seniorA.id))?.status).toBe('working');
+    expect((await getAgentById(db, seniorB.id))?.current_story_id).toBeNull();
+    expect((await getAgentById(db, seniorB.id))?.status).toBe('idle');
+    expect((await getAgentById(db, seniorTerminated.id))?.current_story_id).toBe('STORY-MERGED');
 
-    db.close();
+    await db.close();
   });
 
   it('is a no-op when no non-terminated agent references the merged story', async () => {
-    const db = await createTestDatabase();
+    const rawDb = await createTestDatabase();
+    const db = new SqliteProvider(rawDb);
     insertStoryRow(db, { id: 'STORY-MERGED', status: 'merged' });
 
-    const result = cleanupAgentsReferencingMergedStory(db, 'STORY-MERGED');
+    const result = await cleanupAgentsReferencingMergedStory(db, 'STORY-MERGED');
 
     expect(result).toEqual({ cleared: 0, reassigned: 0 });
-    db.close();
+    await db.close();
   });
 });

package/src/cli/commands/manager/merged-story-cleanup.ts

@@ -1,7 +1,6 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
-import type { Database } from 'sql.js';
-import { queryAll, queryOne } from '../../../db/client.js';
+import type { DatabaseProvider } from '../../../db/provider.js';
 import { updateAgent } from '../../../db/queries/agents.js';
 
 const ACTIVE_STORY_STATUS_ORDER: ReadonlyArray<{
@@ -24,14 +23,13 @@ function buildActiveStatusPriorityCase(): string {
   return `CASE status ${clauses} ELSE 99 END`;
 }
 
-function getNextAssignedActiveStoryId(
-  db: Database,
+async function getNextAssignedActiveStoryId(
+  db: DatabaseProvider,
   agentId: string,
   mergedStoryId: string
-): string | null {
+): Promise<string | null> {
   const statusPriorityCase = buildActiveStatusPriorityCase();
-  const row = queryOne<{ id: string }>(
-    db,
+  const row = await db.queryOne<{ id: string }>(
     `
       SELECT id
       FROM stories
@@ -51,12 +49,11 @@ export interface MergedStoryCleanupResult {
   reassigned: number;
 }
 
-export function cleanupAgentsReferencingMergedStory(
-  db: Database,
+export async function cleanupAgentsReferencingMergedStory(
+  db: DatabaseProvider,
   mergedStoryId: string
-): MergedStoryCleanupResult {
-  const staleAgents = queryAll<{ id: string }>(
-    db,
+): Promise<MergedStoryCleanupResult> {
+  const staleAgents = await db.queryAll<{ id: string }>(
     `
       SELECT id
       FROM agents
@@ -70,8 +67,8 @@ export function cleanupAgentsReferencingMergedStory(
   let reassigned = 0;
 
   for (const agent of staleAgents) {
-    const nextStoryId = getNextAssignedActiveStoryId(db, agent.id, mergedStoryId);
-    updateAgent(db, agent.id, {
+    const nextStoryId = await getNextAssignedActiveStoryId(db, agent.id, mergedStoryId);
+    await updateAgent(db, agent.id, {
       currentStoryId: nextStoryId,
       status: nextStoryId ? 'working' : 'idle',
     });