hungry-ghost-hive 0.48.0 → 0.49.0

package/dist/db/queries/stories.test.js

@@ -1,5 +1,6 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 import { beforeEach, describe, expect, it } from 'vitest';
+import { SqliteProvider } from '../provider.js';
 import { createAgent } from './agents.js';
 import { createRequirement } from './requirements.js';
 import { addStoryDependency, createStory, deleteStory, getActiveStoriesByAgent, getAllStories, getInProgressStories, getPlannedStories, getStoriesByAgent, getStoriesByRequirement, getStoriesByStatus, getStoriesByTeam, getStoriesDependingOn, getStoryById, getStoryCounts, getStoryDependencies, getStoryPointsByTeam, removeStoryDependency, updateStory, } from './stories.js';
@@ -11,24 +12,25 @@ describe('stories queries', () => {
     let agentId;
     let requirementId;
     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',
         });
         requirementId = requirement.id;
     });
     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',
@@ -44,8 +46,8 @@ describe('stories queries', () => {
             expect(story.status).toBe('draft');
             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',
             });
@@ -53,19 +55,19 @@ describe('stories queries', () => {
             expect(story.team_id).toBeNull();
             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',
             });
             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,
@@ -74,99 +76,99 @@ 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);
         });
     });
     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);
         });
     });
     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' });
-            const draft = getStoriesByStatus(db, 'draft');
-            const inProgress = getStoriesByStatus(db, 'in_progress');
+            await updateStory(db, story2.id, { status: '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);
             expect(inProgress).toHaveLength(1);
@@ -174,63 +176,63 @@ 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 });
-            const story2 = createStory(db, {
+            await updateStory(db, story1.id, { assignedAgentId: agentId });
+            const story2 = await createStory(db, {
                 title: 'Story 2',
                 description: 'Description',
             });
-            updateStory(db, story2.id, { assignedAgentId: agentId });
-            const agent2 = createAgent(db, { type: 'junior', teamId });
-            const story3 = createStory(db, {
+            await updateStory(db, story2.id, { assignedAgentId: agentId });
+            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 });
-            const stories = getStoriesByAgent(db, agentId);
+            await updateStory(db, story3.id, { assignedAgentId: agent2.id });
+            const stories = await getStoriesByAgent(db, agentId);
             expect(stories).toHaveLength(2);
             expect(stories.map(s => s.id)).toContain(story1.id);
             expect(stories.map(s => s.id)).toContain(story2.id);
         });
     });
     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);
         });
     });
     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
             expect(stories.map(s => s.id)).toContain(story1.id);
@@ -238,45 +240,45 @@ 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 });
-            const story2 = createStory(db, {
+            await updateStory(db, story1.id, { status: 'planned', storyPoints: 5 });
+            const story2 = await createStory(db, {
                 title: 'Story 2',
                 description: 'Description',
             });
-            updateStory(db, story2.id, { status: 'planned', storyPoints: 8 });
-            createStory(db, {
+            await updateStory(db, story2.id, { status: 'planned', storyPoints: 8 });
+            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
             expect(planned[1].id).toBe(story1.id); // 5 points second
         });
     });
     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' });
-            const story2 = createStory(db, {
+            await updateStory(db, story1.id, { status: 'in_progress' });
+            const story2 = await createStory(db, {
                 title: 'QA',
                 description: 'Description',
             });
-            updateStory(db, story2.id, { status: 'qa' });
-            const story3 = createStory(db, {
+            await updateStory(db, story2.id, { status: 'qa' });
+            const story3 = await createStory(db, {
                 title: 'Merged',
                 description: 'Description',
             });
-            updateStory(db, story3.id, { status: 'merged' });
-            const inProgress = getInProgressStories(db);
+            await updateStory(db, story3.id, { status: 'merged' });
+            const inProgress = await getInProgressStories(db);
             expect(inProgress).toHaveLength(2);
             expect(inProgress.map(s => s.id)).toContain(story1.id);
             expect(inProgress.map(s => s.id)).toContain(story2.id);
@@ -284,87 +286,87 @@ 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 });
-            const s2 = createStory(db, { title: 'S2', description: 'D', teamId });
-            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 total = getStoryPointsByTeam(db, teamId);
+        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 = await createStory(db, { title: 'S2', description: 'D', teamId });
+            await updateStory(db, s2.id, { status: 'in_progress', storyPoints: 8 });
+            const s3 = await createStory(db, { title: 'S3', description: 'D', teamId });
+            await updateStory(db, s3.id, { status: 'merged', storyPoints: 3 });
+            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,
             });
             expect(updated?.complexity_score).toBe(8);
             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'],
             });
             expect(updated?.acceptance_criteria).toBe(JSON.stringify(['New criterion 1', 'New criterion 2']));
         });
-        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',
             });
             expect(updated?.branch_name).toBe('feature/test-branch');
             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',
@@ -375,25 +377,25 @@ describe('stories queries', () => {
             expect(updated?.status).toBe('in_progress');
             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,
             });
@@ -402,120 +404,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);
-            const retrieved = getStoryById(db, story.id);
+            await deleteStory(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);
-            deleteStory(db, story1.id);
-            const dependencies = getStoryDependencies(db, story2.id);
+            await addStoryDependency(db, story2.id, story1.id);
+            await deleteStory(db, story1.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);
-            const dependencies = getStoryDependencies(db, story2.id);
+            await addStoryDependency(db, story2.id, story1.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);
-            const dependencies = getStoryDependencies(db, story2.id);
+            await addStoryDependency(db, story2.id, story1.id);
+            await addStoryDependency(db, story2.id, story1.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);
-            const dependencies = getStoryDependencies(db, story2.id);
+            await addStoryDependency(db, story2.id, story1.id);
+            await removeStoryDependency(db, story2.id, story1.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);
-            const dependents = getStoriesDependingOn(db, story1.id);
+            await addStoryDependency(db, story2.id, story1.id);
+            await addStoryDependency(db, story3.id, story1.id);
+            const dependents = await getStoriesDependingOn(db, story1.id);
             expect(dependents).toHaveLength(2);
             expect(dependents.map(s => s.id)).toContain(story2.id);
             expect(dependents.map(s => s.id)).toContain(story3.id);
         });
     });
     describe('getStoryCounts', () => {
-        it('should return counts by status', () => {
-            createStory(db, { title: 'S1', description: 'D' }); // draft
-            createStory(db, { title: 'S2', description: 'D' }); // draft
-            const s3 = createStory(db, { title: 'S3', description: 'D' });
-            updateStory(db, s3.id, { status: 'planned' });
-            const s4 = createStory(db, { title: 'S4', description: 'D' });
-            updateStory(db, s4.id, { status: 'in_progress' });
-            const counts = getStoryCounts(db);
+        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 = await createStory(db, { title: 'S3', description: 'D' });
+            await updateStory(db, s3.id, { status: 'planned' });
+            const s4 = await createStory(db, { title: 'S4', description: 'D' });
+            await updateStory(db, s4.id, { status: 'in_progress' });
+            const counts = await getStoryCounts(db);
             expect(counts.draft).toBe(2);
             expect(counts.planned).toBe(1);
             expect(counts.in_progress).toBe(1);
             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);
             expect(counts.planned).toBe(0);
         });
     });
     describe('edge cases', () => {
-        it('should handle all story statuses', () => {
+        it('should handle all story statuses', async () => {
             const statuses = [
                 'draft',
                 'estimated',
@@ -527,31 +529,31 @@ describe('stories queries', () => {
                 'pr_submitted',
                 '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');
         });