hungry-ghost-hive 0.48.0 → 0.49.0

package/src/db/queries/stories.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 } from 'vitest';
+import { SqliteProvider } from '../provider.js';
 import { createAgent } from './agents.js';
 import { createRequirement } from './requirements.js';
 import {
@@ -28,24 +28,25 @@ import { createTeam } from './teams.js';
 import { createTestDatabase } from './test-helpers.js';
 
 describe('stories queries', () => {
-  let db: Database;
+  let db: SqliteProvider;
   let teamId: string;
   let agentId: string;
   let requirementId: string;
 
   beforeEach(async () => {
-    db = await createTestDatabase();
-    const team = createTeam(db, {
+    const rawDb = await createTestDatabase();
+    db = new SqliteProvider(rawDb);
+    const team = await createTeam(db, {
       repoUrl: 'https://github.com/test/repo.git',
       repoPath: '/path/to/repo',
       name: 'Test Team',
     });
     teamId = team.id;
 
-    const agent = createAgent(db, { type: 'senior', teamId });
+    const agent = await createAgent(db, { type: 'senior', teamId });
     agentId = agent.id;
 
-    const requirement = createRequirement(db, {
+    const requirement = await createRequirement(db, {
       title: 'Test Requirement',
       description: 'Test description',
     });
@@ -53,8 +54,8 @@ describe('stories queries', () => {
   });
 
   describe('createStory', () => {
-    it('should create a story with all fields', () => {
-      const story = createStory(db, {
+    it('should create a story with all fields', async () => {
+      const story = await createStory(db, {
         requirementId,
         teamId,
         title: 'Implement feature X',
@@ -72,8 +73,8 @@ describe('stories queries', () => {
       expect(story.created_at).toBeDefined();
     });
 
-    it('should create story with minimal fields', () => {
-      const story = createStory(db, {
+    it('should create story with minimal fields', async () => {
+      const story = await createStory(db, {
         title: 'Simple Story',
         description: 'Simple description',
       });
@@ -83,13 +84,13 @@ describe('stories queries', () => {
       expect(story.acceptance_criteria).toBeNull();
     });
 
-    it('should generate unique IDs', () => {
-      const story1 = createStory(db, {
+    it('should generate unique IDs', async () => {
+      const story1 = await createStory(db, {
         title: 'Story 1',
         description: 'Description 1',
       });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         title: 'Story 2',
         description: 'Description 2',
       });
@@ -97,8 +98,8 @@ describe('stories queries', () => {
       expect(story1.id).not.toBe(story2.id);
     });
 
-    it('should handle null acceptance criteria', () => {
-      const story = createStory(db, {
+    it('should handle null acceptance criteria', async () => {
+      const story = await createStory(db, {
         title: 'Story',
         description: 'Description',
         acceptanceCriteria: null,
@@ -109,71 +110,71 @@ describe('stories queries', () => {
   });
 
   describe('getStoryById', () => {
-    it('should retrieve a story by ID', () => {
-      const created = createStory(db, {
+    it('should retrieve a story by ID', async () => {
+      const created = await createStory(db, {
         title: 'Test Story',
         description: 'Test description',
         teamId,
       });
 
-      const retrieved = getStoryById(db, created.id);
+      const retrieved = await getStoryById(db, created.id);
 
       expect(retrieved).toBeDefined();
       expect(retrieved?.id).toBe(created.id);
       expect(retrieved?.title).toBe('Test Story');
     });
 
-    it('should return undefined for non-existent story', () => {
-      const result = getStoryById(db, 'non-existent-id');
+    it('should return undefined for non-existent story', async () => {
+      const result = await getStoryById(db, 'non-existent-id');
       expect(result).toBeUndefined();
     });
   });
 
   describe('getStoriesByRequirement', () => {
-    it('should return stories for a requirement', () => {
-      const story1 = createStory(db, {
+    it('should return stories for a requirement', async () => {
+      const story1 = await createStory(db, {
         requirementId,
         title: 'Story 1',
         description: 'Description 1',
       });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         requirementId,
         title: 'Story 2',
         description: 'Description 2',
       });
 
-      const req2 = createRequirement(db, {
+      const req2 = await createRequirement(db, {
         title: 'Requirement 2',
         description: 'Description',
       });
-      createStory(db, {
+      await createStory(db, {
         requirementId: req2.id,
         title: 'Story 3',
         description: 'Description 3',
       });
 
-      const stories = getStoriesByRequirement(db, requirementId);
+      const stories = await getStoriesByRequirement(db, requirementId);
 
       expect(stories).toHaveLength(2);
       expect(stories.map(s => s.id)).toContain(story1.id);
       expect(stories.map(s => s.id)).toContain(story2.id);
     });
 
-    it('should order by created_at', () => {
-      const story1 = createStory(db, {
+    it('should order by created_at', async () => {
+      const story1 = await createStory(db, {
         requirementId,
         title: 'First',
         description: 'Description',
       });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         requirementId,
         title: 'Second',
         description: 'Description',
       });
 
-      const stories = getStoriesByRequirement(db, requirementId);
+      const stories = await getStoriesByRequirement(db, requirementId);
 
       expect(stories[0].id).toBe(story1.id);
       expect(stories[1].id).toBe(story2.id);
@@ -181,25 +182,25 @@ describe('stories queries', () => {
   });
 
   describe('getStoriesByTeam', () => {
-    it('should filter stories by team', () => {
-      const story1 = createStory(db, {
+    it('should filter stories by team', async () => {
+      const story1 = await createStory(db, {
         teamId,
         title: 'Story 1',
         description: 'Description',
       });
 
-      const team2 = createTeam(db, {
+      const team2 = await createTeam(db, {
         repoUrl: 'https://github.com/test/repo2.git',
         repoPath: '/path/to/repo2',
         name: 'Team 2',
       });
-      createStory(db, {
+      await createStory(db, {
         teamId: team2.id,
         title: 'Story 2',
         description: 'Description',
       });
 
-      const stories = getStoriesByTeam(db, teamId);
+      const stories = await getStoriesByTeam(db, teamId);
 
       expect(stories).toHaveLength(1);
       expect(stories[0].id).toBe(story1.id);
@@ -207,20 +208,20 @@ describe('stories queries', () => {
   });
 
   describe('getStoriesByStatus', () => {
-    it('should filter stories by status', () => {
-      const story1 = createStory(db, {
+    it('should filter stories by status', async () => {
+      const story1 = await createStory(db, {
         title: 'Draft Story',
         description: 'Description',
       });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         title: 'In Progress Story',
         description: 'Description',
       });
-      updateStory(db, story2.id, { status: 'in_progress' });
+      await updateStory(db, story2.id, { status: 'in_progress' });
 
-      const draft = getStoriesByStatus(db, 'draft');
-      const inProgress = getStoriesByStatus(db, 'in_progress');
+      const draft = await getStoriesByStatus(db, 'draft');
+      const inProgress = await getStoriesByStatus(db, 'in_progress');
 
       expect(draft).toHaveLength(1);
       expect(draft[0].id).toBe(story1.id);
@@ -230,27 +231,27 @@ describe('stories queries', () => {
   });
 
   describe('getStoriesByAgent', () => {
-    it('should return stories assigned to an agent', () => {
-      const story1 = createStory(db, {
+    it('should return stories assigned to an agent', async () => {
+      const story1 = await createStory(db, {
         title: 'Story 1',
         description: 'Description',
       });
-      updateStory(db, story1.id, { assignedAgentId: agentId });
+      await updateStory(db, story1.id, { assignedAgentId: agentId });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         title: 'Story 2',
         description: 'Description',
       });
-      updateStory(db, story2.id, { assignedAgentId: agentId });
+      await updateStory(db, story2.id, { assignedAgentId: agentId });
 
-      const agent2 = createAgent(db, { type: 'junior', teamId });
-      const story3 = createStory(db, {
+      const agent2 = await createAgent(db, { type: 'junior', teamId });
+      const story3 = await createStory(db, {
         title: 'Story 3',
         description: 'Description',
       });
-      updateStory(db, story3.id, { assignedAgentId: agent2.id });
+      await updateStory(db, story3.id, { assignedAgentId: agent2.id });
 
-      const stories = getStoriesByAgent(db, agentId);
+      const stories = await getStoriesByAgent(db, agentId);
 
       expect(stories).toHaveLength(2);
       expect(stories.map(s => s.id)).toContain(story1.id);
@@ -259,26 +260,26 @@ describe('stories queries', () => {
   });
 
   describe('getActiveStoriesByAgent', () => {
-    it('should return only active stories for an agent', () => {
-      const story1 = createStory(db, {
+    it('should return only active stories for an agent', async () => {
+      const story1 = await createStory(db, {
         title: 'Planned Story',
         description: 'Description',
       });
-      updateStory(db, story1.id, {
+      await updateStory(db, story1.id, {
         assignedAgentId: agentId,
         status: 'planned',
       });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         title: 'Merged Story',
         description: 'Description',
       });
-      updateStory(db, story2.id, {
+      await updateStory(db, story2.id, {
         assignedAgentId: agentId,
         status: 'merged',
       });
 
-      const activeStories = getActiveStoriesByAgent(db, agentId);
+      const activeStories = await getActiveStoriesByAgent(db, agentId);
 
       expect(activeStories).toHaveLength(1);
       expect(activeStories[0].id).toBe(story1.id);
@@ -286,18 +287,18 @@ describe('stories queries', () => {
   });
 
   describe('getAllStories', () => {
-    it('should return all stories ordered by created_at DESC', () => {
-      const story1 = createStory(db, {
+    it('should return all stories ordered by created_at DESC', async () => {
+      const story1 = await createStory(db, {
         title: 'First',
         description: 'Description',
       });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         title: 'Second',
         description: 'Description',
       });
 
-      const stories = getAllStories(db);
+      const stories = await getAllStories(db);
 
       expect(stories).toHaveLength(2);
       // Verify both stories are present
@@ -307,25 +308,25 @@ describe('stories queries', () => {
   });
 
   describe('getPlannedStories', () => {
-    it('should return planned stories ordered by story points DESC', () => {
-      const story1 = createStory(db, {
+    it('should return planned stories ordered by story points DESC', async () => {
+      const story1 = await createStory(db, {
         title: 'Story 1',
         description: 'Description',
       });
-      updateStory(db, story1.id, { status: 'planned', storyPoints: 5 });
+      await updateStory(db, story1.id, { status: 'planned', storyPoints: 5 });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         title: 'Story 2',
         description: 'Description',
       });
-      updateStory(db, story2.id, { status: 'planned', storyPoints: 8 });
+      await updateStory(db, story2.id, { status: 'planned', storyPoints: 8 });
 
-      createStory(db, {
+      await createStory(db, {
         title: 'Draft Story',
         description: 'Description',
       });
 
-      const planned = getPlannedStories(db);
+      const planned = await getPlannedStories(db);
 
       expect(planned).toHaveLength(2);
       expect(planned[0].id).toBe(story2.id); // 8 points first
@@ -334,26 +335,26 @@ describe('stories queries', () => {
   });
 
   describe('getInProgressStories', () => {
-    it('should return stories in progress statuses', () => {
-      const story1 = createStory(db, {
+    it('should return stories in progress statuses', async () => {
+      const story1 = await createStory(db, {
         title: 'In Progress',
         description: 'Description',
       });
-      updateStory(db, story1.id, { status: 'in_progress' });
+      await updateStory(db, story1.id, { status: 'in_progress' });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         title: 'QA',
         description: 'Description',
       });
-      updateStory(db, story2.id, { status: 'qa' });
+      await updateStory(db, story2.id, { status: 'qa' });
 
-      const story3 = createStory(db, {
+      const story3 = await createStory(db, {
         title: 'Merged',
         description: 'Description',
       });
-      updateStory(db, story3.id, { status: 'merged' });
+      await updateStory(db, story3.id, { status: 'merged' });
 
-      const inProgress = getInProgressStories(db);
+      const inProgress = await getInProgressStories(db);
 
       expect(inProgress).toHaveLength(2);
       expect(inProgress.map(s => s.id)).toContain(story1.id);
@@ -363,58 +364,58 @@ describe('stories queries', () => {
   });
 
   describe('getStoryPointsByTeam', () => {
-    it('should sum story points for active team stories', () => {
-      createStory(db, { title: 'S1', description: 'D', teamId });
-      const s1 = createStory(db, { title: 'S1', description: 'D', teamId });
-      updateStory(db, s1.id, { status: 'planned', storyPoints: 5 });
+    it('should sum story points for active team stories', async () => {
+      await createStory(db, { title: 'S1', description: 'D', teamId });
+      const s1 = await createStory(db, { title: 'S1', description: 'D', teamId });
+      await updateStory(db, s1.id, { status: 'planned', storyPoints: 5 });
 
-      const s2 = createStory(db, { title: 'S2', description: 'D', teamId });
-      updateStory(db, s2.id, { status: 'in_progress', storyPoints: 8 });
+      const s2 = await createStory(db, { title: 'S2', description: 'D', teamId });
+      await updateStory(db, s2.id, { status: 'in_progress', storyPoints: 8 });
 
-      const s3 = createStory(db, { title: 'S3', description: 'D', teamId });
-      updateStory(db, s3.id, { status: 'merged', storyPoints: 3 });
+      const s3 = await createStory(db, { title: 'S3', description: 'D', teamId });
+      await updateStory(db, s3.id, { status: 'merged', storyPoints: 3 });
 
-      const total = getStoryPointsByTeam(db, teamId);
+      const total = await getStoryPointsByTeam(db, teamId);
 
       expect(total).toBe(13); // 5 + 8, not including merged
     });
 
-    it('should return 0 when no active stories', () => {
-      const total = getStoryPointsByTeam(db, teamId);
+    it('should return 0 when no active stories', async () => {
+      const total = await getStoryPointsByTeam(db, teamId);
       expect(total).toBe(0);
     });
   });
 
   describe('updateStory', () => {
-    it('should update story title', () => {
-      const story = createStory(db, {
+    it('should update story title', async () => {
+      const story = await createStory(db, {
         title: 'Original',
         description: 'Description',
       });
 
-      const updated = updateStory(db, story.id, { title: 'Updated' });
+      const updated = await updateStory(db, story.id, { title: 'Updated' });
 
       expect(updated?.title).toBe('Updated');
     });
 
-    it('should update story status', () => {
-      const story = createStory(db, {
+    it('should update story status', async () => {
+      const story = await createStory(db, {
         title: 'Story',
         description: 'Description',
       });
 
-      const updated = updateStory(db, story.id, { status: 'in_progress' });
+      const updated = await updateStory(db, story.id, { status: 'in_progress' });
 
       expect(updated?.status).toBe('in_progress');
     });
 
-    it('should update complexity and story points', () => {
-      const story = createStory(db, {
+    it('should update complexity and story points', async () => {
+      const story = await createStory(db, {
         title: 'Story',
         description: 'Description',
       });
 
-      const updated = updateStory(db, story.id, {
+      const updated = await updateStory(db, story.id, {
         complexityScore: 8,
         storyPoints: 5,
       });
@@ -423,24 +424,24 @@ describe('stories queries', () => {
       expect(updated?.story_points).toBe(5);
     });
 
-    it('should update assigned agent', () => {
-      const story = createStory(db, {
+    it('should update assigned agent', async () => {
+      const story = await createStory(db, {
         title: 'Story',
         description: 'Description',
       });
 
-      const updated = updateStory(db, story.id, { assignedAgentId: agentId });
+      const updated = await updateStory(db, story.id, { assignedAgentId: agentId });
 
       expect(updated?.assigned_agent_id).toBe(agentId);
     });
 
-    it('should update acceptance criteria', () => {
-      const story = createStory(db, {
+    it('should update acceptance criteria', async () => {
+      const story = await createStory(db, {
         title: 'Story',
         description: 'Description',
       });
 
-      const updated = updateStory(db, story.id, {
+      const updated = await updateStory(db, story.id, {
         acceptanceCriteria: ['New criterion 1', 'New criterion 2'],
       });
 
@@ -449,13 +450,13 @@ describe('stories queries', () => {
       );
     });
 
-    it('should update branch and PR info', () => {
-      const story = createStory(db, {
+    it('should update branch and PR info', async () => {
+      const story = await createStory(db, {
         title: 'Story',
         description: 'Description',
       });
 
-      const updated = updateStory(db, story.id, {
+      const updated = await updateStory(db, story.id, {
         branchName: 'feature/test-branch',
         prUrl: 'https://github.com/test/repo/pull/123',
       });
@@ -464,13 +465,13 @@ describe('stories queries', () => {
       expect(updated?.pr_url).toBe('https://github.com/test/repo/pull/123');
     });
 
-    it('should update multiple fields at once', () => {
-      const story = createStory(db, {
+    it('should update multiple fields at once', async () => {
+      const story = await createStory(db, {
         title: 'Original',
         description: 'Original description',
       });
 
-      const updated = updateStory(db, story.id, {
+      const updated = await updateStory(db, story.id, {
         title: 'Updated',
         description: 'Updated description',
         status: 'in_progress',
@@ -483,30 +484,30 @@ describe('stories queries', () => {
       expect(updated?.assigned_agent_id).toBe(agentId);
     });
 
-    it('should return story when no updates provided', () => {
-      const story = createStory(db, {
+    it('should return story when no updates provided', async () => {
+      const story = await createStory(db, {
         title: 'Story',
         description: 'Description',
       });
 
-      const updated = updateStory(db, story.id, {});
+      const updated = await updateStory(db, story.id, {});
 
       expect(updated?.id).toBe(story.id);
     });
 
-    it('should return undefined for non-existent story', () => {
-      const updated = updateStory(db, 'non-existent-id', { title: 'Updated' });
+    it('should return undefined for non-existent story', async () => {
+      const updated = await updateStory(db, 'non-existent-id', { title: 'Updated' });
       expect(updated).toBeUndefined();
     });
 
-    it('should handle setting fields to null', () => {
-      const story = createStory(db, {
+    it('should handle setting fields to null', async () => {
+      const story = await createStory(db, {
         title: 'Story',
         description: 'Description',
         teamId,
       });
 
-      const updated = updateStory(db, story.id, {
+      const updated = await updateStory(db, story.id, {
         teamId: null,
         acceptanceCriteria: null,
       });
@@ -517,120 +518,120 @@ describe('stories queries', () => {
   });
 
   describe('deleteStory', () => {
-    it('should delete a story', () => {
-      const story = createStory(db, {
+    it('should delete a story', async () => {
+      const story = await createStory(db, {
         title: 'To Delete',
         description: 'Description',
       });
 
-      deleteStory(db, story.id);
+      await deleteStory(db, story.id);
 
-      const retrieved = getStoryById(db, story.id);
+      const retrieved = await getStoryById(db, story.id);
       expect(retrieved).toBeUndefined();
     });
 
-    it('should delete story dependencies when deleting story', () => {
-      const story1 = createStory(db, {
+    it('should delete story dependencies when deleting story', async () => {
+      const story1 = await createStory(db, {
         title: 'Story 1',
         description: 'Description',
       });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         title: 'Story 2',
         description: 'Description',
       });
 
-      addStoryDependency(db, story2.id, story1.id);
+      await addStoryDependency(db, story2.id, story1.id);
 
-      deleteStory(db, story1.id);
+      await deleteStory(db, story1.id);
 
-      const dependencies = getStoryDependencies(db, story2.id);
+      const dependencies = await getStoryDependencies(db, story2.id);
       expect(dependencies).toEqual([]);
     });
 
-    it('should not throw when deleting non-existent story', () => {
-      expect(() => deleteStory(db, 'non-existent-id')).not.toThrow();
+    it('should not throw when deleting non-existent story', async () => {
+      await expect(deleteStory(db, 'non-existent-id')).resolves.not.toThrow();
     });
   });
 
   describe('story dependencies', () => {
-    it('should add a story dependency', () => {
-      const story1 = createStory(db, {
+    it('should add a story dependency', async () => {
+      const story1 = await createStory(db, {
         title: 'Story 1',
         description: 'Description',
       });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         title: 'Story 2',
         description: 'Description',
       });
 
-      addStoryDependency(db, story2.id, story1.id);
+      await addStoryDependency(db, story2.id, story1.id);
 
-      const dependencies = getStoryDependencies(db, story2.id);
+      const dependencies = await getStoryDependencies(db, story2.id);
 
       expect(dependencies).toHaveLength(1);
       expect(dependencies[0].id).toBe(story1.id);
     });
 
-    it('should not duplicate dependencies', () => {
-      const story1 = createStory(db, {
+    it('should not duplicate dependencies', async () => {
+      const story1 = await createStory(db, {
         title: 'Story 1',
         description: 'Description',
       });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         title: 'Story 2',
         description: 'Description',
       });
 
-      addStoryDependency(db, story2.id, story1.id);
-      addStoryDependency(db, story2.id, story1.id);
+      await addStoryDependency(db, story2.id, story1.id);
+      await addStoryDependency(db, story2.id, story1.id);
 
-      const dependencies = getStoryDependencies(db, story2.id);
+      const dependencies = await getStoryDependencies(db, story2.id);
 
       expect(dependencies).toHaveLength(1);
     });
 
-    it('should remove a story dependency', () => {
-      const story1 = createStory(db, {
+    it('should remove a story dependency', async () => {
+      const story1 = await createStory(db, {
         title: 'Story 1',
         description: 'Description',
       });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         title: 'Story 2',
         description: 'Description',
       });
 
-      addStoryDependency(db, story2.id, story1.id);
-      removeStoryDependency(db, story2.id, story1.id);
+      await addStoryDependency(db, story2.id, story1.id);
+      await removeStoryDependency(db, story2.id, story1.id);
 
-      const dependencies = getStoryDependencies(db, story2.id);
+      const dependencies = await getStoryDependencies(db, story2.id);
 
       expect(dependencies).toEqual([]);
     });
 
-    it('should get stories depending on a story', () => {
-      const story1 = createStory(db, {
+    it('should get stories depending on a story', async () => {
+      const story1 = await createStory(db, {
         title: 'Base Story',
         description: 'Description',
       });
 
-      const story2 = createStory(db, {
+      const story2 = await createStory(db, {
         title: 'Dependent 1',
         description: 'Description',
       });
 
-      const story3 = createStory(db, {
+      const story3 = await createStory(db, {
         title: 'Dependent 2',
         description: 'Description',
       });
 
-      addStoryDependency(db, story2.id, story1.id);
-      addStoryDependency(db, story3.id, story1.id);
+      await addStoryDependency(db, story2.id, story1.id);
+      await addStoryDependency(db, story3.id, story1.id);
 
-      const dependents = getStoriesDependingOn(db, story1.id);
+      const dependents = await getStoriesDependingOn(db, story1.id);
 
       expect(dependents).toHaveLength(2);
       expect(dependents.map(s => s.id)).toContain(story2.id);
@@ -639,17 +640,17 @@ describe('stories queries', () => {
   });
 
   describe('getStoryCounts', () => {
-    it('should return counts by status', () => {
-      createStory(db, { title: 'S1', description: 'D' }); // draft
-      createStory(db, { title: 'S2', description: 'D' }); // draft
+    it('should return counts by status', async () => {
+      await createStory(db, { title: 'S1', description: 'D' }); // draft
+      await createStory(db, { title: 'S2', description: 'D' }); // draft
 
-      const s3 = createStory(db, { title: 'S3', description: 'D' });
-      updateStory(db, s3.id, { status: 'planned' });
+      const s3 = await createStory(db, { title: 'S3', description: 'D' });
+      await updateStory(db, s3.id, { status: 'planned' });
 
-      const s4 = createStory(db, { title: 'S4', description: 'D' });
-      updateStory(db, s4.id, { status: 'in_progress' });
+      const s4 = await createStory(db, { title: 'S4', description: 'D' });
+      await updateStory(db, s4.id, { status: 'in_progress' });
 
-      const counts = getStoryCounts(db);
+      const counts = await getStoryCounts(db);
 
       expect(counts.draft).toBe(2);
       expect(counts.planned).toBe(1);
@@ -657,8 +658,8 @@ describe('stories queries', () => {
       expect(counts.merged).toBe(0);
     });
 
-    it('should return zero counts when no stories', () => {
-      const counts = getStoryCounts(db);
+    it('should return zero counts when no stories', async () => {
+      const counts = await getStoryCounts(db);
 
       expect(counts.draft).toBe(0);
       expect(counts.estimated).toBe(0);
@@ -667,7 +668,7 @@ describe('stories queries', () => {
   });
 
   describe('edge cases', () => {
-    it('should handle all story statuses', () => {
+    it('should handle all story statuses', async () => {
       const statuses: Array<
         | 'draft'
         | 'estimated'
@@ -690,36 +691,36 @@ describe('stories queries', () => {
         'merged',
       ];
 
-      const story = createStory(db, {
+      const story = await createStory(db, {
         title: 'Test',
         description: 'Description',
       });
 
-      statuses.forEach(status => {
-        const updated = updateStory(db, story.id, { status });
+      for (const status of statuses) {
+        const updated = await updateStory(db, story.id, { status });
         expect(updated?.status).toBe(status);
-      });
+      }
     });
 
-    it('should handle very long text fields', () => {
+    it('should handle very long text fields', async () => {
       const longText = 'A'.repeat(100000);
-      const story = createStory(db, {
+      const story = await createStory(db, {
         title: longText,
         description: longText,
       });
 
-      const retrieved = getStoryById(db, story.id);
+      const retrieved = await getStoryById(db, story.id);
       expect(retrieved?.title).toBe(longText);
       expect(retrieved?.description).toBe(longText);
     });
 
-    it('should handle special characters', () => {
-      const story = createStory(db, {
+    it('should handle special characters', async () => {
+      const story = await createStory(db, {
         title: 'Title with \'quotes\' and "double"',
         description: 'Description with\nnewlines\tand\ttabs',
       });
 
-      const retrieved = getStoryById(db, story.id);
+      const retrieved = await getStoryById(db, story.id);
       expect(retrieved?.title).toBe('Title with \'quotes\' and "double"');
       expect(retrieved?.description).toBe('Description with\nnewlines\tand\ttabs');
     });