hungry-ghost-hive 0.48.0 → 0.49.0

package/src/agents/base-agent.ts

@@ -1,6 +1,6 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
-import type { Database } from 'sql.js';
+import type { DatabaseProvider } from '../db/provider.js';
 import {
   updateAgent,
   type AgentRow,
@@ -32,7 +32,7 @@ export interface MemoryState {
 }
 
 export interface AgentContext {
-  db: Database;
+  db: DatabaseProvider;
   provider: LLMProvider;
   agentRow: AgentRow;
   workDir: string;
@@ -46,7 +46,7 @@ export interface AgentContext {
 }
 
 export abstract class BaseAgent {
-  protected db: Database;
+  protected db: DatabaseProvider;
   protected provider: LLMProvider;
   protected agentId: string;
   protected agentType: AgentType;
@@ -112,9 +112,9 @@ export abstract class BaseAgent {
     }, HEARTBEAT_INTERVAL_MS);
   }
 
-  private sendHeartbeat(): void {
+  private async sendHeartbeat(): Promise<void> {
     try {
-      updateAgentHeartbeat(this.db, this.agentId);
+      await updateAgentHeartbeat(this.db, this.agentId);
     } catch (err) {
       // Heartbeat failure shouldn't crash the agent
       console.error(`Heartbeat failed for ${this.agentId}:`, err);
@@ -128,8 +128,12 @@ export abstract class BaseAgent {
     }
   }
 
-  protected log(eventType: EventType, message?: string, metadata?: Record<string, unknown>): void {
-    createLog(this.db, {
+  protected async log(
+    eventType: EventType,
+    message?: string,
+    metadata?: Record<string, unknown>
+  ): Promise<void> {
+    await createLog(this.db, {
       agentId: this.agentId,
       storyId: this.memoryState.currentTask?.storyId,
       eventType,
@@ -138,13 +142,13 @@ export abstract class BaseAgent {
     });
   }
 
-  protected updateStatus(status: AgentStatus): void {
-    updateAgent(this.db, this.agentId, { status });
+  protected async updateStatus(status: AgentStatus): Promise<void> {
+    await updateAgent(this.db, this.agentId, { status });
   }
 
-  protected saveMemoryState(): void {
+  protected async saveMemoryState(): Promise<void> {
     this.memoryState.checkpointTokens = this.totalTokens;
-    updateAgent(this.db, this.agentId, {
+    await updateAgent(this.db, this.agentId, {
       memoryState: JSON.stringify(this.memoryState),
     });
   }
@@ -169,7 +173,7 @@ export abstract class BaseAgent {
       return result.content;
     } catch (err) {
       // Log timeout/error event
-      this.log(
+      await this.log(
         'AGENT_TERMINATED',
         `LLM call failed: ${err instanceof Error ? err.message : String(err)}`,
         {
@@ -195,9 +199,9 @@ Keep it under 500 words.`;
     const summaryResult = await this.provider.complete(this.messages);
 
     this.memoryState.conversationSummary = summaryResult.content;
-    this.saveMemoryState();
+    await this.saveMemoryState();
 
-    this.log('AGENT_CHECKPOINT', 'Checkpoint saved', {
+    await this.log('AGENT_CHECKPOINT', 'Checkpoint saved', {
       totalTokens: this.totalTokens,
     });
 
@@ -212,52 +216,52 @@ Keep it under 500 words.`;
     this.totalTokens = 0;
   }
 
-  protected addDecision(decision: string): void {
+  protected async addDecision(decision: string): Promise<void> {
     this.memoryState.context.decisionsMade.push(decision);
-    this.saveMemoryState();
+    await this.saveMemoryState();
   }
 
-  protected addBlocker(blocker: string): void {
+  protected async addBlocker(blocker: string): Promise<void> {
     this.memoryState.context.blockers.push(blocker);
-    this.saveMemoryState();
+    await this.saveMemoryState();
   }
 
-  protected removeBlocker(blocker: string): void {
+  protected async removeBlocker(blocker: string): Promise<void> {
     this.memoryState.context.blockers = this.memoryState.context.blockers.filter(
       b => b !== blocker
     );
-    this.saveMemoryState();
+    await this.saveMemoryState();
   }
 
-  protected setCurrentTask(storyId: string, phase: string): void {
+  protected async setCurrentTask(storyId: string, phase: string): Promise<void> {
     this.memoryState.currentTask = {
       storyId,
       phase,
       filesModified: [],
       lastAction: '',
     };
-    this.saveMemoryState();
+    await this.saveMemoryState();
   }
 
-  protected updateTaskProgress(lastAction: string, filesModified?: string[]): void {
+  protected async updateTaskProgress(lastAction: string, filesModified?: string[]): Promise<void> {
     if (this.memoryState.currentTask) {
       this.memoryState.currentTask.lastAction = lastAction;
       if (filesModified) {
         this.memoryState.currentTask.filesModified.push(...filesModified);
       }
-      this.saveMemoryState();
+      await this.saveMemoryState();
     }
   }
 
   async run(): Promise<void> {
-    this.updateStatus('working');
-    this.log('AGENT_SPAWNED', `${this.agentType} agent started`);
+    await this.updateStatus('working');
+    await this.log('AGENT_SPAWNED', `${this.agentType} agent started`);
 
     try {
       await this.execute();
     } catch (err) {
-      this.updateStatus('blocked');
-      this.log(
+      await this.updateStatus('blocked');
+      await this.log(
         'AGENT_TERMINATED',
         `Error: ${err instanceof Error ? err.message : 'Unknown error'}`,
         {

package/src/agents/intermediate.ts

@@ -17,16 +17,25 @@ export class IntermediateAgent extends BaseAgent {
 
   constructor(context: IntermediateContext) {
     super(context);
+  }
+
+  private async init(context: IntermediateContext): Promise<void> {
     if (context.agentRow.team_id) {
-      this.team = getTeamById(this.db, context.agentRow.team_id) || null;
+      this.team = (await getTeamById(this.db, context.agentRow.team_id)) || null;
     }
     if (context.storyId) {
-      this.story = getStoryById(this.db, context.storyId) || null;
+      this.story = (await getStoryById(this.db, context.storyId)) || null;
     } else if (context.agentRow.current_story_id) {
-      this.story = getStoryById(this.db, context.agentRow.current_story_id) || null;
+      this.story = (await getStoryById(this.db, context.agentRow.current_story_id)) || null;
     }
   }
 
+  static async create(context: IntermediateContext): Promise<IntermediateAgent> {
+    const agent = new IntermediateAgent(context);
+    await agent.init(context);
+    return agent;
+  }
+
   getSystemPrompt(): string {
     const teamInfo = this.team
       ? `Team: ${this.team.name}\nRepository: ${this.team.repo_path}`
@@ -65,12 +74,12 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
 
   async execute(): Promise<void> {
     if (!this.story) {
-      this.log('STORY_PROGRESS_UPDATE', 'No story assigned, waiting');
+      await this.log('STORY_PROGRESS_UPDATE', 'No story assigned, waiting');
       return;
     }
 
-    this.setCurrentTask(this.story.id, 'implementation');
-    this.log('STORY_STARTED', `Working on: ${this.story.title}`, { storyId: this.story.id });
+    await this.setCurrentTask(this.story.id, 'implementation');
+    await this.log('STORY_STARTED', `Working on: ${this.story.title}`, { storyId: this.story.id });
 
     try {
       await this.implementStory();
@@ -81,7 +90,7 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
           `Failed after ${this.retryCount} attempts: ${err instanceof Error ? err.message : 'Unknown error'}`
         );
       } else {
-        this.log(
+        await this.log(
           'STORY_PROGRESS_UPDATE',
           `Retry ${this.retryCount}: ${err instanceof Error ? err.message : 'Unknown error'}`,
           {
@@ -106,7 +115,7 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
 
     // Update story with branch name if not set
     if (!this.story.branch_name) {
-      updateStory(this.db, this.story.id, { branchName }, this.storiesDir);
+      await updateStory(this.db, this.story.id, { branchName }, this.storiesDir);
     }
 
     const prompt = `Implement this story:
@@ -134,18 +143,18 @@ ${this.story.acceptance_criteria ? JSON.parse(this.story.acceptance_criteria).jo
 Begin implementation.`;
 
     const response = await this.chat(prompt);
-    this.updateTaskProgress('Implementation in progress', []);
-    this.log('STORY_PROGRESS_UPDATE', response.substring(0, 200), { storyId: this.story.id });
+    await this.updateTaskProgress('Implementation in progress', []);
+    await this.log('STORY_PROGRESS_UPDATE', response.substring(0, 200), { storyId: this.story.id });
 
     // Continue implementation (simplified - in reality this would be iterative)
     const continuePrompt =
       'Continue with the implementation. Show me the code changes you would make.';
     await this.chat(continuePrompt);
-    this.log('STORY_PROGRESS_UPDATE', 'Code changes proposed', { storyId: this.story.id });
+    await this.log('STORY_PROGRESS_UPDATE', 'Code changes proposed', { storyId: this.story.id });
 
     // Mark as complete
-    updateStory(this.db, this.story.id, { status: 'review' }, this.storiesDir);
-    this.log('STORY_COMPLETED', 'Implementation complete, ready for review', {
+    await updateStory(this.db, this.story.id, { status: 'review' }, this.storiesDir);
+    await this.log('STORY_COMPLETED', 'Implementation complete, ready for review', {
       storyId: this.story.id,
       branchName,
     });
@@ -153,25 +162,25 @@ Begin implementation.`;
 
   private async escalateToSenior(reason: string): Promise<void> {
     // Find Senior for this team
-    const seniors = getAgentsByTeam(this.db, this.teamId!).filter(
+    const seniors = (await getAgentsByTeam(this.db, this.teamId!)).filter(
       a => a.type === 'senior' && a.status !== 'terminated'
     );
 
     const seniorId = seniors[0]?.id;
 
-    const escalation = createEscalation(this.db, {
+    const escalation = await createEscalation(this.db, {
       storyId: this.story?.id,
       fromAgentId: this.agentId,
       toAgentId: seniorId,
       reason,
     });
 
-    this.log('ESCALATION_CREATED', reason, {
+    await this.log('ESCALATION_CREATED', reason, {
       escalationId: escalation.id,
       toAgent: seniorId,
     });
 
-    this.updateStatus('blocked');
-    this.addBlocker(`Escalated to Senior: ${reason}`);
+    await this.updateStatus('blocked');
+    await this.addBlocker(`Escalated to Senior: ${reason}`);
   }
 }

package/src/agents/junior.ts

@@ -17,16 +17,25 @@ export class JuniorAgent extends BaseAgent {
 
   constructor(context: JuniorContext) {
     super(context);
+  }
+
+  private async init(context: JuniorContext): Promise<void> {
     if (context.agentRow.team_id) {
-      this.team = getTeamById(this.db, context.agentRow.team_id) || null;
+      this.team = (await getTeamById(this.db, context.agentRow.team_id)) || null;
     }
     if (context.storyId) {
-      this.story = getStoryById(this.db, context.storyId) || null;
+      this.story = (await getStoryById(this.db, context.storyId)) || null;
     } else if (context.agentRow.current_story_id) {
-      this.story = getStoryById(this.db, context.agentRow.current_story_id) || null;
+      this.story = (await getStoryById(this.db, context.agentRow.current_story_id)) || null;
     }
   }
 
+  static async create(context: JuniorContext): Promise<JuniorAgent> {
+    const agent = new JuniorAgent(context);
+    await agent.init(context);
+    return agent;
+  }
+
   getSystemPrompt(): string {
     const teamInfo = this.team
       ? `Team: ${this.team.name}\nRepository: ${this.team.repo_path}`
@@ -71,12 +80,12 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
 
   async execute(): Promise<void> {
     if (!this.story) {
-      this.log('STORY_PROGRESS_UPDATE', 'No story assigned, waiting');
+      await this.log('STORY_PROGRESS_UPDATE', 'No story assigned, waiting');
       return;
     }
 
-    this.setCurrentTask(this.story.id, 'implementation');
-    this.log('STORY_STARTED', `Working on: ${this.story.title}`, { storyId: this.story.id });
+    await this.setCurrentTask(this.story.id, 'implementation');
+    await this.log('STORY_STARTED', `Working on: ${this.story.title}`, { storyId: this.story.id });
 
     try {
       await this.implementStory();
@@ -88,7 +97,7 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
           `Encountered error: ${err instanceof Error ? err.message : 'Unknown error'}`
         );
       } else {
-        this.log(
+        await this.log(
           'STORY_PROGRESS_UPDATE',
           `Error: ${err instanceof Error ? err.message : 'Unknown error'}`,
           {
@@ -111,7 +120,7 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
         .substring(0, 30)}`;
 
     if (!this.story.branch_name) {
-      updateStory(this.db, this.story.id, { branchName }, this.storiesDir);
+      await updateStory(this.db, this.story.id, { branchName }, this.storiesDir);
     }
 
     const prompt = `I need to implement this simple story:
@@ -140,42 +149,42 @@ This is a simple task (complexity ${this.story.complexity_score || 1}-3).
 Please help me identify which files I need to read and modify.`;
 
     await this.chat(prompt);
-    this.updateTaskProgress('Analyzing task', []);
-    this.log('STORY_PROGRESS_UPDATE', 'Analyzing requirements', { storyId: this.story.id });
+    await this.updateTaskProgress('Analyzing task', []);
+    await this.log('STORY_PROGRESS_UPDATE', 'Analyzing requirements', { storyId: this.story.id });
 
     // Get guidance and implement
     const implementPrompt = `Based on the analysis, show me the exact code changes to make. Keep it simple and minimal.`;
     await this.chat(implementPrompt);
-    this.log('STORY_PROGRESS_UPDATE', 'Making code changes', { storyId: this.story.id });
+    await this.log('STORY_PROGRESS_UPDATE', 'Making code changes', { storyId: this.story.id });
 
     // Complete
-    updateStory(this.db, this.story.id, { status: 'review' }, this.storiesDir);
-    this.log('STORY_COMPLETED', 'Implementation complete, ready for review', {
+    await updateStory(this.db, this.story.id, { status: 'review' }, this.storiesDir);
+    await this.log('STORY_COMPLETED', 'Implementation complete, ready for review', {
       storyId: this.story.id,
       branchName,
     });
   }
 
   private async escalateToSenior(reason: string): Promise<void> {
-    const seniors = getAgentsByTeam(this.db, this.teamId!).filter(
+    const seniors = (await getAgentsByTeam(this.db, this.teamId!)).filter(
       a => a.type === 'senior' && a.status !== 'terminated'
     );
 
     const seniorId = seniors[0]?.id;
 
-    const escalation = createEscalation(this.db, {
+    const escalation = await createEscalation(this.db, {
       storyId: this.story?.id,
       fromAgentId: this.agentId,
       toAgentId: seniorId,
       reason,
     });
 
-    this.log('ESCALATION_CREATED', reason, {
+    await this.log('ESCALATION_CREATED', reason, {
       escalationId: escalation.id,
       toAgent: seniorId,
     });
 
-    this.updateStatus('blocked');
-    this.addBlocker(`Escalated to Senior: ${reason}`);
+    await this.updateStatus('blocked');
+    await this.addBlocker(`Escalated to Senior: ${reason}`);
   }
 }

package/src/agents/qa.ts

@@ -25,15 +25,23 @@ export class QAAgent extends BaseAgent {
   constructor(context: QAContext) {
     super(context);
     this.qaConfig = context.qaConfig;
+  }
 
+  private async init(context: QAContext): Promise<void> {
     if (context.agentRow.team_id) {
-      this.team = getTeamById(this.db, context.agentRow.team_id) || null;
-      this.pendingStories = getStoriesByStatus(this.db, 'qa').filter(
+      this.team = (await getTeamById(this.db, context.agentRow.team_id)) || null;
+      this.pendingStories = (await getStoriesByStatus(this.db, 'qa')).filter(
         s => s.team_id === context.agentRow.team_id
       );
     }
   }
 
+  static async create(context: QAContext): Promise<QAAgent> {
+    const agent = new QAAgent(context);
+    await agent.init(context);
+    return agent;
+  }
+
   getSystemPrompt(): string {
     const teamInfo = this.team
       ? `Team: ${this.team.name}\nRepository: ${this.team.repo_path}`
@@ -73,7 +81,7 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
 
   async execute(): Promise<void> {
     if (this.pendingStories.length === 0) {
-      this.log('STORY_QA_STARTED', 'No stories pending QA');
+      await this.log('STORY_QA_STARTED', 'No stories pending QA');
       return;
     }
 
@@ -83,23 +91,23 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
   }
 
   private async processStory(story: StoryRow): Promise<void> {
-    this.setCurrentTask(story.id, 'qa');
-    this.log('STORY_QA_STARTED', `QA for story: ${story.title}`, { storyId: story.id });
+    await this.setCurrentTask(story.id, 'qa');
+    await this.log('STORY_QA_STARTED', `QA for story: ${story.title}`, { storyId: story.id });
 
     // Checkout the branch
     if (story.branch_name) {
       try {
         await execa('git', ['checkout', story.branch_name], { cwd: this.workDir });
       } catch (err) {
-        this.log(
+        await this.log(
           'STORY_QA_FAILED',
           `Failed to checkout branch: ${err instanceof Error ? err.message : 'Unknown error'}`,
           {
             storyId: story.id,
           }
         );
-        updateStory(this.db, story.id, { status: 'qa_failed' }, this.storiesDir);
-        this.checkAndEscalate(story);
+        await updateStory(this.db, story.id, { status: 'qa_failed' }, this.storiesDir);
+        await this.checkAndEscalate(story);
         return;
       }
     }
@@ -107,16 +115,16 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
     // Run quality checks
     const qualityPassed = await this.runQualityChecks(story.id);
     if (!qualityPassed) {
-      updateStory(this.db, story.id, { status: 'qa_failed' });
-      this.checkAndEscalate(story);
+      await updateStory(this.db, story.id, { status: 'qa_failed' });
+      await this.checkAndEscalate(story);
       return;
     }
 
     // Run build
     const buildPassed = await this.runBuild(story.id);
     if (!buildPassed) {
-      updateStory(this.db, story.id, { status: 'qa_failed' });
-      this.checkAndEscalate(story);
+      await updateStory(this.db, story.id, { status: 'qa_failed' });
+      await this.checkAndEscalate(story);
       return;
     }
 
@@ -124,21 +132,21 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
     if (this.qaConfig.testCommand) {
       const testsPassed = await this.runTests(story.id);
       if (!testsPassed) {
-        updateStory(this.db, story.id, { status: 'qa_failed' }, this.storiesDir);
-        this.checkAndEscalate(story);
+        await updateStory(this.db, story.id, { status: 'qa_failed' }, this.storiesDir);
+        await this.checkAndEscalate(story);
         return;
       }
     }
 
     // All checks passed
-    this.log('STORY_QA_PASSED', 'All QA checks passed', { storyId: story.id });
+    await this.log('STORY_QA_PASSED', 'All QA checks passed', { storyId: story.id });
 
     // Create PR
     await this.createPR(story);
   }
 
   private async runQualityChecks(storyId: string): Promise<boolean> {
-    this.log('CODE_QUALITY_CHECK_STARTED', 'Running quality checks', { storyId });
+    await this.log('CODE_QUALITY_CHECK_STARTED', 'Running quality checks', { storyId });
 
     for (const check of this.qaConfig.qualityChecks) {
       try {
@@ -146,7 +154,7 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
         await execa(cmd, args, { cwd: this.workDir });
       } catch (err) {
         const error = err as { stderr?: string; stdout?: string };
-        this.log('CODE_QUALITY_CHECK_FAILED', `Check failed: ${check}`, {
+        await this.log('CODE_QUALITY_CHECK_FAILED', `Check failed: ${check}`, {
           storyId,
           error: error.stderr || error.stdout,
         });
@@ -154,21 +162,21 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
       }
     }
 
-    this.log('CODE_QUALITY_CHECK_PASSED', 'All quality checks passed', { storyId });
+    await this.log('CODE_QUALITY_CHECK_PASSED', 'All quality checks passed', { storyId });
     return true;
   }
 
   private async runBuild(storyId: string): Promise<boolean> {
-    this.log('BUILD_STARTED', 'Running build', { storyId });
+    await this.log('BUILD_STARTED', 'Running build', { storyId });
 
     try {
       const [cmd, ...args] = this.qaConfig.buildCommand.split(' ');
       await execa(cmd, args, { cwd: this.workDir });
-      this.log('BUILD_PASSED', 'Build succeeded', { storyId });
+      await this.log('BUILD_PASSED', 'Build succeeded', { storyId });
       return true;
     } catch (err) {
       const error = err as { stderr?: string; stdout?: string };
-      this.log('BUILD_FAILED', 'Build failed', {
+      await this.log('BUILD_FAILED', 'Build failed', {
         storyId,
         error: error.stderr || error.stdout,
       });
@@ -179,16 +187,16 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
   private async runTests(storyId: string): Promise<boolean> {
     if (!this.qaConfig.testCommand) return true;
 
-    this.log('BUILD_STARTED', 'Running tests', { storyId });
+    await this.log('BUILD_STARTED', 'Running tests', { storyId });
 
     try {
       const [cmd, ...args] = this.qaConfig.testCommand.split(' ');
       await execa(cmd, args, { cwd: this.workDir });
-      this.log('BUILD_PASSED', 'Tests passed', { storyId });
+      await this.log('BUILD_PASSED', 'Tests passed', { storyId });
       return true;
     } catch (err) {
       const error = err as { stderr?: string; stdout?: string };
-      this.log('BUILD_FAILED', 'Tests failed', {
+      await this.log('BUILD_FAILED', 'Tests failed', {
         storyId,
         error: error.stderr || error.stdout,
       });
@@ -198,15 +206,17 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
 
   private async createPR(story: StoryRow): Promise<void> {
     if (!story.branch_name) {
-      this.log('STORY_PR_CREATED', 'No branch name, skipping PR creation', { storyId: story.id });
-      updateStory(this.db, story.id, { status: 'pr_submitted' }, this.storiesDir);
+      await this.log('STORY_PR_CREATED', 'No branch name, skipping PR creation', {
+        storyId: story.id,
+      });
+      await updateStory(this.db, story.id, { status: 'pr_submitted' }, this.storiesDir);
       return;
     }
 
     // Check if PR already exists
-    const existingPR = getPullRequestByStory(this.db, story.id);
+    const existingPR = await getPullRequestByStory(this.db, story.id);
     if (existingPR) {
-      this.log('STORY_PR_CREATED', 'PR already exists', {
+      await this.log('STORY_PR_CREATED', 'PR already exists', {
         storyId: story.id,
         prUrl: existingPR.github_pr_url,
       });
@@ -241,7 +251,7 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
       const prNumber = prNumberMatch ? parseInt(prNumberMatch[1], 10) : undefined;
 
       // Create PR record
-      const pr = createPullRequest(this.db, {
+      const pr = await createPullRequest(this.db, {
         storyId: story.id,
         teamId: story.team_id,
         branchName: story.branch_name || `feature/${story.id}`,
@@ -250,7 +260,7 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
       });
 
       // Update story
-      updateStory(
+      await updateStory(
         this.db,
         story.id,
         {
@@ -260,40 +270,44 @@ ${this.memoryState.conversationSummary || 'Starting fresh.'}`;
         this.storiesDir
       );
 
-      this.log('STORY_PR_CREATED', `PR created: ${prUrl}`, {
+      await this.log('STORY_PR_CREATED', `PR created: ${prUrl}`, {
         storyId: story.id,
         prId: pr.id,
         prNumber,
       });
     } catch (err) {
       const error = err as { stderr?: string };
-      this.log('STORY_PR_CREATED', `Failed to create PR: ${error.stderr || 'Unknown error'}`, {
-        storyId: story.id,
-      });
+      await this.log(
+        'STORY_PR_CREATED',
+        `Failed to create PR: ${error.stderr || 'Unknown error'}`,
+        {
+          storyId: story.id,
+        }
+      );
 
       // Still mark as pr_submitted since QA passed
-      updateStory(this.db, story.id, { status: 'pr_submitted' }, this.storiesDir);
+      await updateStory(this.db, story.id, { status: 'pr_submitted' }, this.storiesDir);
     }
   }
 
-  private checkAndEscalate(story: StoryRow): void {
-    const failureCount = countQaFailuresByStory(this.db, story.id);
+  private async checkAndEscalate(story: StoryRow): Promise<void> {
+    const failureCount = await countQaFailuresByStory(this.db, story.id);
 
     if (failureCount >= 3) {
       // Find the senior agent for the team
-      const seniorAgents = getAgentsByType(this.db, 'senior').filter(
+      const seniorAgents = (await getAgentsByType(this.db, 'senior')).filter(
         a => a.team_id === story.team_id
       );
 
       if (seniorAgents.length > 0) {
-        const escalation = createEscalation(this.db, {
+        const escalation = await createEscalation(this.db, {
           storyId: story.id,
           fromAgentId: this.agentId,
           toAgentId: seniorAgents[0].id,
           reason: `Story failed QA ${failureCount} times. Needs senior review and assistance.`,
         });
 
-        this.log('ESCALATION_CREATED', `Story escalated after ${failureCount} QA failures`, {
+        await this.log('ESCALATION_CREATED', `Story escalated after ${failureCount} QA failures`, {
           storyId: story.id,
           escalationId: escalation.id,
           failureCount,