hungry-ghost-hive 0.48.0 → 0.49.0

package/src/agents/senior.ts

@@ -16,14 +16,23 @@ export class SeniorAgent extends BaseAgent {
 
   constructor(context: SeniorContext) {
     super(context);
+  }
+
+  private async init(context: SeniorContext): Promise<void> {
     if (context.teamId) {
-      this.team = getTeamById(this.db, context.teamId) || null;
-      this.assignedStories = getStoriesByTeam(this.db, context.teamId).filter(s =>
+      this.team = (await getTeamById(this.db, context.teamId)) || null;
+      this.assignedStories = (await getStoriesByTeam(this.db, context.teamId)).filter(s =>
         ['planned', 'in_progress', 'review'].includes(s.status)
       );
     }
   }
 
+  static async create(context: SeniorContext): Promise<SeniorAgent> {
+    const agent = new SeniorAgent(context);
+    await agent.init(context);
+    return agent;
+  }
+
   getSystemPrompt(): string {
     const teamInfo = this.team
       ? `Team: ${this.team.name}\nRepository: ${this.team.repo_url}\nPath: ${this.team.repo_path}`
@@ -65,11 +74,11 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
 
   async execute(): Promise<void> {
     if (!this.team) {
-      this.log('CODEBASE_SWEEP_STARTED', 'No team assigned, waiting for assignment');
+      await this.log('CODEBASE_SWEEP_STARTED', 'No team assigned, waiting for assignment');
       return;
     }
 
-    this.log('CODEBASE_SWEEP_STARTED', `Analyzing codebase for ${this.team.name}`);
+    await this.log('CODEBASE_SWEEP_STARTED', `Analyzing codebase for ${this.team.name}`);
 
     // Perform codebase sweep
     await this.analyzeCodebase();
@@ -101,16 +110,16 @@ This will help with story estimation and implementation.`;
     const analysis = await this.chat(prompt);
 
     this.memoryState.context.codebaseNotes = analysis;
-    this.saveMemoryState();
+    await this.saveMemoryState();
 
-    this.log('CODEBASE_SWEEP_COMPLETED', 'Codebase analysis complete', {
+    await this.log('CODEBASE_SWEEP_COMPLETED', 'Codebase analysis complete', {
       summary: analysis.substring(0, 200),
     });
   }
 
   private async processStory(story: StoryRow): Promise<void> {
-    this.setCurrentTask(story.id, 'processing');
-    this.log('STORY_STARTED', `Processing story: ${story.title}`, { storyId: story.id });
+    await this.setCurrentTask(story.id, 'processing');
+    await this.log('STORY_STARTED', `Processing story: ${story.title}`, { storyId: story.id });
 
     // Implement all stories directly - the Scheduler handles routing to appropriate agents
     await this.implementStory(story);
@@ -118,7 +127,7 @@ This will help with story estimation and implementation.`;
 
   private async implementStory(story: StoryRow): Promise<void> {
     // Update assignment
-    updateStory(
+    await updateStory(
       this.db,
       story.id,
       {
@@ -127,7 +136,7 @@ This will help with story estimation and implementation.`;
       },
       this.storiesDir
     );
-    updateAgent(this.db, this.agentId, { currentStoryId: story.id });
+    await updateAgent(this.db, this.agentId, { currentStoryId: story.id });
 
     // Create feature branch
     const branchName = `feature/${story.id.toLowerCase()}-${story.title
@@ -135,7 +144,7 @@ This will help with story estimation and implementation.`;
       .replace(/[^a-z0-9]+/g, '-')
       .substring(0, 30)}`;
 
-    this.log('STORY_STARTED', `Implementing: ${story.title}`, { branchName });
+    await this.log('STORY_STARTED', `Implementing: ${story.title}`, { branchName });
 
     const prompt = `Implement this story:
 
@@ -160,14 +169,14 @@ ${story.acceptance_criteria ? JSON.parse(story.acceptance_criteria).join('\n- ')
 Let me know when you're ready to proceed or if you have questions.`;
 
     const response = await this.chat(prompt);
-    this.updateTaskProgress('Implementation started', []);
+    await this.updateTaskProgress('Implementation started', []);
 
     // Continue the conversation to complete implementation
     // In a real scenario, this would be an iterative process
-    this.log('STORY_PROGRESS_UPDATE', response.substring(0, 200), { storyId: story.id });
+    await this.log('STORY_PROGRESS_UPDATE', response.substring(0, 200), { storyId: story.id });
 
     // Mark for review when done (simplified)
-    updateStory(
+    await updateStory(
       this.db,
       story.id,
       {
@@ -177,7 +186,7 @@ Let me know when you're ready to proceed or if you have questions.`;
       this.storiesDir
     );
 
-    this.log('STORY_COMPLETED', `Implementation complete, ready for review`, {
+    await this.log('STORY_COMPLETED', `Implementation complete, ready for review`, {
       storyId: story.id,
       branchName,
     });
@@ -186,12 +195,16 @@ Let me know when you're ready to proceed or if you have questions.`;
   private async reviewStory(story: StoryRow): Promise<void> {
     if (story.assigned_agent_id === this.agentId) {
       // Self-review, move to QA
-      updateStory(this.db, story.id, { status: 'qa' }, this.storiesDir);
-      this.log('STORY_REVIEW_REQUESTED', 'Self-implemented, moving to QA', { storyId: story.id });
+      await updateStory(this.db, story.id, { status: 'qa' }, this.storiesDir);
+      await this.log('STORY_REVIEW_REQUESTED', 'Self-implemented, moving to QA', {
+        storyId: story.id,
+      });
       return;
     }
 
-    this.log('STORY_REVIEW_REQUESTED', `Reviewing story: ${story.title}`, { storyId: story.id });
+    await this.log('STORY_REVIEW_REQUESTED', `Reviewing story: ${story.title}`, {
+      storyId: story.id,
+    });
 
     const prompt = `Review the code for this story:
 
@@ -217,33 +230,35 @@ If issues found, describe them. If approved, confirm.`;
 
     if (hasIssues) {
       // Send back for fixes
-      updateStory(this.db, story.id, { status: 'in_progress' }, this.storiesDir);
-      this.log('STORY_PROGRESS_UPDATE', 'Review issues found, sent back for fixes', {
+      await updateStory(this.db, story.id, { status: 'in_progress' }, this.storiesDir);
+      await this.log('STORY_PROGRESS_UPDATE', 'Review issues found, sent back for fixes', {
         storyId: story.id,
         review: review.substring(0, 200),
       });
     } else {
       // Approve and move to QA
-      updateStory(this.db, story.id, { status: 'qa' }, this.storiesDir);
-      this.log('STORY_REVIEW_REQUESTED', 'Review passed, moving to QA', { storyId: story.id });
+      await updateStory(this.db, story.id, { status: 'qa' }, this.storiesDir);
+      await this.log('STORY_REVIEW_REQUESTED', 'Review passed, moving to QA', {
+        storyId: story.id,
+      });
     }
   }
 
   async escalateToTechLead(reason: string): Promise<void> {
-    const techLead = getTechLead(this.db);
+    const techLead = await getTechLead(this.db);
 
-    const escalation = createEscalation(this.db, {
+    const escalation = await createEscalation(this.db, {
       storyId: this.memoryState.currentTask?.storyId,
       fromAgentId: this.agentId,
       toAgentId: techLead?.id,
       reason,
     });
 
-    this.log('ESCALATION_CREATED', reason, {
+    await this.log('ESCALATION_CREATED', reason, {
       escalationId: escalation.id,
     });
 
-    this.updateStatus('blocked');
-    this.addBlocker(`Escalated to Tech Lead: ${reason}`);
+    await this.updateStatus('blocked');
+    await this.addBlocker(`Escalated to Tech Lead: ${reason}`);
   }
 }

package/src/agents/tech-lead.ts

@@ -4,7 +4,6 @@ import { getCliRuntimeBuilder, resolveRuntimeModelForCli } from '../cli-runtimes
 import { loadConfig } from '../config/index.js';
 import type { HiveConfig } from '../config/schema.js';
 import { syncRequirementToProvider } from '../connectors/project-management/operations.js';
-import { queryAll } from '../db/client.js';
 import { createAgent, getAgentsByType, updateAgent } from '../db/queries/agents.js';
 import { createEscalation } from '../db/queries/escalations.js';
 import {
@@ -37,13 +36,22 @@ export class TechLeadAgent extends BaseAgent {
   constructor(context: TechLeadContext) {
     super(context);
     this.requirementId = context.requirementId;
-    this.teams = getAllTeams(this.db);
+  }
+
+  private async init(): Promise<void> {
+    this.teams = await getAllTeams(this.db);
 
     if (this.requirementId) {
-      this.requirement = getRequirementById(this.db, this.requirementId);
+      this.requirement = await getRequirementById(this.db, this.requirementId);
     }
   }
 
+  static async create(context: TechLeadContext): Promise<TechLeadAgent> {
+    const agent = new TechLeadAgent(context);
+    await agent.init();
+    return agent;
+  }
+
   getSystemPrompt(): string {
     const teamList = this.teams.map(t => `- ${t.name} (${t.repo_path}): ${t.repo_url}`).join('\n');
 
@@ -88,11 +96,11 @@ ${this.getJiraInstructions()}`;
 
   async execute(): Promise<void> {
     if (!this.requirement) {
-      this.log('PLANNING_STARTED', 'Tech Lead ready, waiting for requirement');
+      await this.log('PLANNING_STARTED', 'Tech Lead ready, waiting for requirement');
       return;
     }
 
-    this.log('PLANNING_STARTED', `Analyzing requirement: ${this.requirement.title}`);
+    await this.log('PLANNING_STARTED', `Analyzing requirement: ${this.requirement.title}`);
 
     // Analyze the requirement
     const analysis = await this.analyzeRequirement();
@@ -113,8 +121,8 @@ ${this.getJiraInstructions()}`;
     await this.coordinateWithSeniors(stories);
 
     // Update requirement status
-    updateRequirement(this.db, this.requirement.id, { status: 'planned' });
-    this.log('PLANNING_COMPLETED', `Created ${stories.length} stories`);
+    await updateRequirement(this.db, this.requirement.id, { status: 'planned' });
+    await this.log('PLANNING_COMPLETED', `Created ${stories.length} stories`);
   }
 
   private async analyzeRequirement(): Promise<{
@@ -202,7 +210,7 @@ Respond in JSON format:
     for (const story of analysis.stories) {
       const team = this.teams.find(t => t.name === story.teamName);
 
-      const storyRow = createStory(
+      const storyRow = await createStory(
         this.db,
         {
           requirementId: this.requirement!.id,
@@ -215,7 +223,7 @@ Respond in JSON format:
       );
 
       // Update with complexity
-      updateStory(
+      await updateStory(
         this.db,
         storyRow.id,
         {
@@ -229,7 +237,7 @@ Respond in JSON format:
       storyIds.push(storyRow.id);
       storyIdMap[story.title] = storyRow.id;
 
-      this.log('STORY_CREATED', story.title, {
+      await this.log('STORY_CREATED', story.title, {
         storyId: storyRow.id,
         teamId: team?.id,
         complexity: story.estimatedComplexity,
@@ -243,7 +251,7 @@ Respond in JSON format:
         for (const depTitle of story.dependencies) {
           const depId = storyIdMap[depTitle];
           if (depId) {
-            addStoryDependency(this.db, storyId, depId);
+            await addStoryDependency(this.db, storyId, depId);
           }
         }
       }
@@ -256,7 +264,7 @@ Respond in JSON format:
     // Get unique teams from stories
     const teamIds = new Set<string>();
     for (const storyId of storyIds) {
-      const story = getStoryById(this.db, storyId);
+      const story = await getStoryById(this.db, storyId);
       if (story?.team_id) {
         teamIds.add(story.team_id);
       }
@@ -268,11 +276,11 @@ Respond in JSON format:
       if (!team) continue;
 
       // Check if Senior already exists for this team
-      let seniors = getAgentsByType(this.db, 'senior').filter(s => s.team_id === teamId);
+      let seniors = (await getAgentsByType(this.db, 'senior')).filter(s => s.team_id === teamId);
 
       if (seniors.length === 0) {
         // Create a new Senior agent
-        const senior = createAgent(this.db, {
+        const senior = await createAgent(this.db, {
           type: 'senior',
           teamId,
         });
@@ -306,19 +314,19 @@ Respond in JSON format:
             commandArgs,
           });
 
-          updateAgent(this.db, senior.id, {
+          await updateAgent(this.db, senior.id, {
             tmuxSession: sessionName,
             status: 'working',
           });
 
-          this.log('AGENT_SPAWNED', `Senior spawned for team ${team.name}`, {
+          await this.log('AGENT_SPAWNED', `Senior spawned for team ${team.name}`, {
             agentId: senior.id,
             teamId,
             tmuxSession: sessionName,
             godmode: this.requirement?.godmode ? true : false,
           });
         } catch (err) {
-          this.log(
+          await this.log(
             'AGENT_SPAWNED',
             `Failed to spawn Senior tmux session: ${err instanceof Error ? err.message : 'Unknown error'}`,
             {
@@ -331,8 +339,7 @@ Respond in JSON format:
       }
 
       // Assign stories to the Senior
-      const teamStories = queryAll<{ id: string }>(
-        this.db,
+      const teamStories = await this.db.queryAll<{ id: string }>(
         `
         SELECT id FROM stories WHERE team_id = ? AND status = 'estimated'
       `,
@@ -340,8 +347,8 @@ Respond in JSON format:
       );
 
       for (const story of teamStories) {
-        updateStory(this.db, story.id, { status: 'planned' });
-        this.log('STORY_ASSIGNED', `Story ${story.id} assigned to team ${team.name}`, {
+        await updateStory(this.db, story.id, { status: 'planned' });
+        await this.log('STORY_ASSIGNED', `Story ${story.id} assigned to team ${team.name}`, {
           storyId: story.id,
           teamId,
         });
@@ -378,13 +385,16 @@ Respond in JSON format:
 
     // Re-fetch requirement from DB to pick up external_epic_key/id that may have
     // been set after this agent was constructed (e.g., by `hive req <epic-url>`).
-    const freshRequirement = getRequirementById(this.db, this.requirement.id);
+    const freshRequirement = await getRequirementById(this.db, this.requirement.id);
     if (!freshRequirement) return;
 
     // Determine team name for labels
     const teamName = this.teams.length > 0 ? this.teams[0].name : undefined;
 
-    this.log('JIRA_SYNC_STARTED', `Syncing requirement ${freshRequirement.id} to PM provider`);
+    await this.log(
+      'JIRA_SYNC_STARTED',
+      `Syncing requirement ${freshRequirement.id} to PM provider`
+    );
 
     try {
       const result = await syncRequirementToProvider(
@@ -396,29 +406,29 @@ Respond in JSON format:
       );
 
       if (result.epicKey) {
-        this.log(
+        await this.log(
           freshRequirement.external_epic_key ? 'JIRA_EPIC_INGESTED' : 'JIRA_EPIC_CREATED',
           `Epic ${result.epicKey} ${freshRequirement.external_epic_key ? 'linked (existing)' : 'created'} for ${freshRequirement.id}`
         );
       }
 
       for (const story of result.stories) {
-        this.log('JIRA_STORY_CREATED', `Issue ${story.key} created for ${story.storyId}`);
+        await this.log('JIRA_STORY_CREATED', `Issue ${story.key} created for ${story.storyId}`);
       }
 
       if (result.errors.length > 0) {
         for (const error of result.errors) {
-          this.log('JIRA_SYNC_WARNING', error);
+          await this.log('JIRA_SYNC_WARNING', error);
         }
       }
 
-      this.log(
+      await this.log(
         'JIRA_SYNC_COMPLETED',
         `Synced ${result.stories.length}/${storyIds.length} stories to PM provider`
       );
     } catch (err) {
       // Jira sync failure should not block the pipeline
-      this.log(
+      await this.log(
         'JIRA_SYNC_WARNING',
         `Jira sync failed: ${err instanceof Error ? err.message : String(err)}`
       );
@@ -426,18 +436,18 @@ Respond in JSON format:
   }
 
   private async escalateToHuman(reason: string): Promise<void> {
-    const escalation = createEscalation(this.db, {
+    const escalation = await createEscalation(this.db, {
       storyId: null,
       fromAgentId: this.agentId,
       toAgentId: null, // null = human
       reason,
     });
 
-    this.log('ESCALATION_CREATED', reason, {
+    await this.log('ESCALATION_CREATED', reason, {
       escalationId: escalation.id,
     });
 
-    this.updateStatus('blocked');
-    this.addBlocker(`Waiting for human input: ${reason}`);
+    await this.updateStatus('blocked');
+    await this.addBlocker(`Waiting for human input: ${reason}`);
   }
 }

package/src/cli/commands/add-repo.test.ts

@@ -15,7 +15,7 @@ vi.mock('../../db/queries/teams.js', () => ({
 
 vi.mock('../../utils/with-hive-context.js', () => ({
   withHiveContext: vi.fn(callback =>
-    callback({ db: { db: {} }, root: '/tmp', paths: { reposDir: '/tmp/repos' } })
+    callback({ db: { db: {}, provider: {} }, root: '/tmp', paths: { reposDir: '/tmp/repos' } })
   ),
 }));
 

package/src/cli/commands/add-repo.ts

@@ -25,7 +25,7 @@ export const addRepoCommand = new Command('add-repo')
 
       try {
         // Check if team already exists
-        const existingTeam = getTeamByName(db.db, options.team);
+        const existingTeam = await getTeamByName(db.provider, options.team);
         if (existingTeam) {
           spinner.fail(chalk.red(`Team "${options.team}" already exists`));
           process.exit(1);
@@ -61,7 +61,7 @@ export const addRepoCommand = new Command('add-repo')
 
         // Create team in database
         spinner.text = 'Creating team...';
-        const team = createTeam(db.db, {
+        const team = await createTeam(db.provider, {
           repoUrl: options.url,
           repoPath: relativeRepoPath,
           name: options.team,

package/src/cli/commands/agents.test.ts

@@ -30,9 +30,9 @@ vi.mock('../../git/worktree.js', () => ({
 const mockSave = vi.fn();
 vi.mock('../../utils/with-hive-context.js', () => ({
   withHiveContext: vi.fn(callback =>
-    callback({ db: { db: {}, save: mockSave }, root: '/tmp/hive' })
+    callback({ db: { db: {}, provider: {}, save: mockSave }, root: '/tmp/hive' })
   ),
-  withReadOnlyHiveContext: vi.fn(callback => callback({ db: { db: {} } })),
+  withReadOnlyHiveContext: vi.fn(callback => callback({ db: { db: {}, provider: {} } })),
 }));
 
 import { getAgentByTmuxSession, updateAgent } from '../../db/queries/agents.js';
@@ -134,7 +134,7 @@ describe('agents command', () => {
     };
 
     it('should terminate agent and clean up worktree', async () => {
-      vi.mocked(getAgentByTmuxSession).mockReturnValue(mockAgent);
+      vi.mocked(getAgentByTmuxSession).mockResolvedValue(mockAgent);
 
       await selfTerminate('hive-auditor-123');
 
@@ -156,7 +156,7 @@ describe('agents command', () => {
     });
 
     it('should skip worktree cleanup when no worktree exists', async () => {
-      vi.mocked(getAgentByTmuxSession).mockReturnValue({
+      vi.mocked(getAgentByTmuxSession).mockResolvedValue({
         ...mockAgent,
         worktree_path: null,
       });
@@ -172,7 +172,7 @@ describe('agents command', () => {
     });
 
     it('should handle already terminated agent gracefully', async () => {
-      vi.mocked(getAgentByTmuxSession).mockReturnValue({
+      vi.mocked(getAgentByTmuxSession).mockResolvedValue({
         ...mockAgent,
         status: 'terminated' as const,
       });
@@ -185,7 +185,7 @@ describe('agents command', () => {
     });
 
     it('should exit with error when agent not found', async () => {
-      vi.mocked(getAgentByTmuxSession).mockReturnValue(undefined);
+      vi.mocked(getAgentByTmuxSession).mockResolvedValue(undefined);
       const mockExit = vi.spyOn(process, 'exit').mockImplementation(() => {
         throw new Error('process.exit');
       });
@@ -198,7 +198,7 @@ describe('agents command', () => {
     });
 
     it('should continue when worktree removal fails', async () => {
-      vi.mocked(getAgentByTmuxSession).mockReturnValue(mockAgent);
+      vi.mocked(getAgentByTmuxSession).mockResolvedValue(mockAgent);
       vi.mocked(removeWorktree).mockReturnValue({
         success: false,
         error: 'worktree not found',

package/src/cli/commands/agents.ts

@@ -26,7 +26,9 @@ agentsCommand
   .option('--json', 'Output as JSON')
   .action(async (options: { active?: boolean; json?: boolean }) => {
     await withReadOnlyHiveContext(async ({ db }) => {
-      const agents = options.active ? getActiveAgents(db.db) : getAllAgents(db.db);
+      const agents = options.active
+        ? await getActiveAgents(db.provider)
+        : await getAllAgents(db.provider);
 
       if (options.json) {
         console.log(JSON.stringify(agents, null, 2));
@@ -67,9 +69,9 @@ agentsCommand
   .option('--json', 'Output as JSON')
   .action(async (agentId: string, options: { limit: string; json?: boolean }) => {
     await withReadOnlyHiveContext(async ({ db }) => {
-      requireAgent(db.db, agentId);
+      await requireAgent(db.provider, agentId);
 
-      const logs = getLogsByAgent(db.db, agentId, parseInt(options.limit, 10));
+      const logs = await getLogsByAgent(db.provider, agentId, parseInt(options.limit, 10));
 
       if (options.json) {
         console.log(JSON.stringify(logs, null, 2));
@@ -108,7 +110,7 @@ agentsCommand
   .description('View detailed agent state')
   .action(async (agentId: string) => {
     await withReadOnlyHiveContext(async ({ db }) => {
-      const agent = requireAgent(db.db, agentId);
+      const agent = await requireAgent(db.provider, agentId);
 
       console.log(chalk.bold(`\nAgent: ${agent.id}\n`));
       console.log(chalk.gray(`Type:          ${agent.type}`));
@@ -131,7 +133,7 @@ agentsCommand
       }
 
       // Show recent logs
-      const logs = getLogsByAgent(db.db, agentId, 5);
+      const logs = await getLogsByAgent(db.provider, agentId, 5);
       if (logs.length > 0) {
         console.log(chalk.bold('\nRecent Activity:'));
         for (const log of logs) {
@@ -150,7 +152,7 @@ agentsCommand
   .option('--dry-run', 'Show what would be deleted without actually deleting')
   .action(async (options: { dryRun?: boolean }) => {
     await withHiveContext(async ({ root, db }) => {
-      const terminatedAgents = getAgentsByStatus(db.db, 'terminated');
+      const terminatedAgents = await getAgentsByStatus(db.provider, 'terminated');
 
       if (terminatedAgents.length === 0) {
         console.log(chalk.green('No terminated agents to clean up.'));
@@ -192,7 +194,7 @@ agentsCommand
             }
           }
 
-          deleteAgent(db.db, agent.id);
+          await deleteAgent(db.provider, agent.id);
           deleted++;
         } catch (err) {
           console.error(
@@ -229,7 +231,7 @@ agentsCommand
 
 export async function selfTerminate(sessionName: string): Promise<void> {
   await withHiveContext(async ({ root, db }) => {
-    const agent = getAgentByTmuxSession(db.db, sessionName);
+    const agent = await getAgentByTmuxSession(db.provider, sessionName);
     if (!agent) {
       console.error(chalk.red(`No agent found for tmux session: ${sessionName}`));
       process.exit(1);
@@ -251,13 +253,13 @@ export async function selfTerminate(sessionName: string): Promise<void> {
     }
 
     // Mark agent as terminated in DB
-    updateAgent(db.db, agent.id, {
+    await updateAgent(db.provider, agent.id, {
       status: 'terminated',
       currentStoryId: null,
     });
 
     // Log the self-termination event
-    createLog(db.db, {
+    await createLog(db.provider, {
       agentId: agent.id,
       eventType: 'AGENT_TERMINATED',
       message: `Agent self-terminated (session: ${sessionName})`,

package/src/cli/commands/approach.ts

@@ -18,10 +18,10 @@ export const approachCommand = new Command('approach')
       const agentName = options.from || 'unknown-agent';
 
       // Look up the story
-      const story = requireStory(db.db, storyId);
+      const story = await requireStory(db.provider, storyId);
 
       // Log approach to agent_logs
-      createLog(db.db, {
+      await createLog(db.provider, {
         agentId: agentName,
         storyId,
         eventType: 'APPROACH_POSTED',

package/src/cli/commands/approvals.test.ts

@@ -61,7 +61,7 @@ describe('approvals command', () => {
       await fn({
         root: '/tmp',
         paths: {} as any,
-        db: { db: {} as any } as any,
+        db: { db: {} as any, provider: {} as any } as any,
       });
     });
   });
@@ -69,7 +69,7 @@ describe('approvals command', () => {
   it('list --json should return pending human approvals', async () => {
     const run = getCommandAction('list');
     const approvals = [sampleEscalation({ id: 'ESC-1' })];
-    vi.mocked(getPendingHumanEscalations).mockReturnValue(approvals);
+    vi.mocked(getPendingHumanEscalations).mockResolvedValue(approvals);
 
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
 
@@ -83,7 +83,7 @@ describe('approvals command', () => {
     const run = getCommandAction('list');
     const humanEsc = sampleEscalation({ id: 'ESC-HUMAN', to_agent_id: null });
     const agentEsc = sampleEscalation({ id: 'ESC-AGENT', to_agent_id: 'hive-senior-alpha' });
-    vi.mocked(getAllEscalations).mockReturnValue([humanEsc, agentEsc]);
+    vi.mocked(getAllEscalations).mockResolvedValue([humanEsc, agentEsc]);
 
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
 
@@ -95,7 +95,7 @@ describe('approvals command', () => {
 
   it('list should print a friendly message when no pending approvals exist', async () => {
     const run = getCommandAction('list');
-    vi.mocked(getPendingHumanEscalations).mockReturnValue([]);
+    vi.mocked(getPendingHumanEscalations).mockResolvedValue([]);
 
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
 
@@ -106,7 +106,7 @@ describe('approvals command', () => {
 
   it('show should exit when escalation is not human-targeted', async () => {
     const run = getCommandAction('show');
-    vi.mocked(getEscalationById).mockReturnValue(
+    vi.mocked(getEscalationById).mockResolvedValue(
       sampleEscalation({ to_agent_id: 'hive-senior-alpha' })
     );
 
@@ -127,7 +127,7 @@ describe('approvals command', () => {
 
   it('approve should resolve escalation with APPROVED prefix', async () => {
     const run = getCommandAction('approve');
-    vi.mocked(getEscalationById).mockReturnValue(sampleEscalation({ id: 'ESC-APPROVE' }));
+    vi.mocked(getEscalationById).mockResolvedValue(sampleEscalation({ id: 'ESC-APPROVE' }));
 
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
 
@@ -143,7 +143,7 @@ describe('approvals command', () => {
 
   it('approve should use default approval message when none is provided', async () => {
     const run = getCommandAction('approve');
-    vi.mocked(getEscalationById).mockReturnValue(sampleEscalation({ id: 'ESC-DEFAULT' }));
+    vi.mocked(getEscalationById).mockResolvedValue(sampleEscalation({ id: 'ESC-DEFAULT' }));
 
     await run('approve', 'ESC-DEFAULT');
 
@@ -156,7 +156,7 @@ describe('approvals command', () => {
 
   it('deny should resolve escalation with DENIED prefix', async () => {
     const run = getCommandAction('deny');
-    vi.mocked(getEscalationById).mockReturnValue(sampleEscalation({ id: 'ESC-DENY' }));
+    vi.mocked(getEscalationById).mockResolvedValue(sampleEscalation({ id: 'ESC-DENY' }));
 
     const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});