hungry-ghost-hive 0.48.0 → 0.49.0

package/src/utils/auto-merge.ts

@@ -7,7 +7,6 @@ import {
   syncStatusForStory,
 } from '../connectors/project-management/operations.js';
 import type { DatabaseClient } from '../db/client.js';
-import { queryOne, withTransaction } from '../db/client.js';
 import { getAgentById, updateAgent } from '../db/queries/agents.js';
 import { createLog } from '../db/queries/logs.js';
 import {
@@ -153,7 +152,7 @@ export async function autoMergeApprovedPRs(
   const claimedPRs: ClaimedPR[] = [];
 
   const claimPhase = async (phaseDb: DatabaseClient) => {
-    const approvedPRs = getApprovedPullRequests(phaseDb.db).filter(
+    const approvedPRs = (await getApprovedPullRequests(phaseDb.provider)).filter(
       pr => !isManualMergeRequired(pr.review_notes)
     );
 
@@ -161,21 +160,17 @@ export async function autoMergeApprovedPRs(
       if (!pr.github_pr_number) continue;
 
       let claimed = false;
-      await withTransaction(
-        phaseDb.db,
-        () => {
-          const currentPR = queryOne<{ status: string }>(
-            phaseDb.db,
-            `SELECT status FROM pull_requests WHERE id = ?`,
-            [pr.id]
-          );
-          if (currentPR?.status === 'approved') {
-            updatePullRequest(phaseDb.db, pr.id, { status: 'queued' });
-            claimed = true;
-          }
-        },
-        () => phaseDb.save()
-      );
+      await phaseDb.provider.withTransaction(async () => {
+        const currentPR = await phaseDb.provider.queryOne<{ status: string }>(
+          `SELECT status FROM pull_requests WHERE id = ?`,
+          [pr.id]
+        );
+        if (currentPR?.status === 'approved') {
+          await updatePullRequest(phaseDb.provider, pr.id, { status: 'queued' });
+          claimed = true;
+        }
+      });
+      phaseDb.save();
 
       if (!claimed) continue;
 
@@ -185,11 +180,11 @@ export async function autoMergeApprovedPRs(
       let repoSlug: string | null = null;
 
       if (teamId) {
-        const team = getAllTeams(phaseDb.db).find(t => t.id === teamId);
+        const team = (await getAllTeams(phaseDb.provider)).find(t => t.id === teamId);
         if (team?.repo_path) repoCwd = join(root, team.repo_path);
         if (team?.repo_url) repoSlug = ghRepoSlug(team.repo_url);
       } else if (pr.branch_name) {
-        const teams = getAllTeams(phaseDb.db);
+        const teams = await getAllTeams(phaseDb.provider);
         for (const team of teams) {
           if (team.repo_path) {
             repoCwd = join(root, team.repo_path);
@@ -379,7 +374,7 @@ export async function autoMergeApprovedPRs(
 
       switch (result.outcome.type) {
         case 'unknown_state': {
-          createLog(phaseDb.db, {
+          await createLog(phaseDb.provider, {
             agentId: 'manager',
             storyId: pr.story_id || undefined,
             eventType: 'PR_MERGE_SKIPPED',
@@ -393,55 +388,58 @@ export async function autoMergeApprovedPRs(
         case 'already_closed': {
           const prState = result.outcome.prState;
           const newStatus = prState.state === 'MERGED' ? 'merged' : 'closed';
-          await withTransaction(
-            phaseDb.db,
-            () => {
-              updatePullRequest(phaseDb.db, pr.id, { status: newStatus });
-              if (pr.story_id && prState.state === 'MERGED') {
-                const story = getStoryById(phaseDb.db, pr.story_id);
-                if (story?.assigned_agent_id) {
-                  const agent = getAgentById(phaseDb.db, story.assigned_agent_id);
-                  if (agent && agent.current_story_id === pr.story_id) {
-                    updateAgent(phaseDb.db, agent.id, { currentStoryId: null, status: 'idle' });
-                  }
+          await phaseDb.provider.withTransaction(async () => {
+            await updatePullRequest(phaseDb.provider, pr.id, { status: newStatus });
+            if (pr.story_id && prState.state === 'MERGED') {
+              const story = await getStoryById(phaseDb.provider, pr.story_id);
+              if (story?.assigned_agent_id) {
+                const agent = await getAgentById(phaseDb.provider, story.assigned_agent_id);
+                if (agent && agent.current_story_id === pr.story_id) {
+                  await updateAgent(phaseDb.provider, agent.id, {
+                    currentStoryId: null,
+                    status: 'idle',
+                  });
                 }
-                updateStory(phaseDb.db, pr.story_id, { status: 'merged', assignedAgentId: null });
-                createLog(phaseDb.db, {
-                  agentId: 'manager',
-                  storyId: pr.story_id,
-                  eventType: 'STORY_MERGED',
-                  message: `Story merged (PR #${pr.github_pr_number} was already merged on GitHub)`,
-                  metadata: { pr_id: pr.id },
-                });
-                postLifecycleComment(
-                  phaseDb.db,
-                  paths.hiveDir,
-                  config,
-                  pr.story_id,
-                  'merged'
-                ).catch(() => {
-                  /* non-fatal */
-                });
               }
-              createLog(phaseDb.db, {
+              await updateStory(phaseDb.provider, pr.story_id, {
+                status: 'merged',
+                assignedAgentId: null,
+              });
+              await createLog(phaseDb.provider, {
                 agentId: 'manager',
-                storyId: pr.story_id || undefined,
-                eventType: 'PR_MERGE_SKIPPED',
-                message: `PR #${pr.github_pr_number} is already ${prState.state.toLowerCase()}, skipping merge`,
-                metadata: { pr_id: pr.id, github_state: prState.state },
+                storyId: pr.story_id,
+                eventType: 'STORY_MERGED',
+                message: `Story merged (PR #${pr.github_pr_number} was already merged on GitHub)`,
+                metadata: { pr_id: pr.id },
               });
-            },
-            () => phaseDb.save()
-          );
+              postLifecycleComment(
+                phaseDb.provider,
+                paths.hiveDir,
+                config,
+                pr.story_id,
+                'merged'
+              ).catch(() => {
+                /* non-fatal */
+              });
+            }
+            await createLog(phaseDb.provider, {
+              agentId: 'manager',
+              storyId: pr.story_id || undefined,
+              eventType: 'PR_MERGE_SKIPPED',
+              message: `PR #${pr.github_pr_number} is already ${prState.state.toLowerCase()}, skipping merge`,
+              metadata: { pr_id: pr.id, github_state: prState.state },
+            });
+          });
+          phaseDb.save();
 
           if (pr.story_id && prState.state === 'MERGED') {
-            syncStatusForStory(root, phaseDb.db, pr.story_id, 'merged');
+            syncStatusForStory(root, phaseDb.provider, pr.story_id, 'merged');
           }
           break;
         }
 
         case 'conflicts': {
-          createLog(phaseDb.db, {
+          await createLog(phaseDb.provider, {
             agentId: 'manager',
             storyId: pr.story_id || undefined,
             eventType: 'PR_MERGE_SKIPPED',
@@ -453,115 +451,116 @@ export async function autoMergeApprovedPRs(
         }
 
         case 'ci_blocked': {
-          await withTransaction(
-            phaseDb.db,
-            () => {
-              updatePullRequest(phaseDb.db, pr.id, { status: 'approved' });
-              createLog(phaseDb.db, {
-                agentId: 'manager',
-                storyId: pr.story_id || undefined,
-                eventType: 'PR_MERGE_SKIPPED',
-                status: 'warn',
-                message: `Skipped auto-merge of PR #${pr.github_pr_number}: CI checks are failing (not pre-existing on base branch)`,
-                metadata: { pr_id: pr.id },
-              });
-            },
-            () => phaseDb.save()
-          );
+          await phaseDb.provider.withTransaction(async () => {
+            await updatePullRequest(phaseDb.provider, pr.id, { status: 'approved' });
+            await createLog(phaseDb.provider, {
+              agentId: 'manager',
+              storyId: pr.story_id || undefined,
+              eventType: 'PR_MERGE_SKIPPED',
+              status: 'warn',
+              message: `Skipped auto-merge of PR #${pr.github_pr_number}: CI checks are failing (not pre-existing on base branch)`,
+              metadata: { pr_id: pr.id },
+            });
+          });
+          phaseDb.save();
           break;
         }
 
         case 'ci_bypassed': {
           const storyId = pr.story_id;
           const bypassedChecks = result.outcome.bypassedChecks;
-          await withTransaction(
-            phaseDb.db,
-            () => {
-              updatePullRequest(phaseDb.db, pr.id, { status: 'merged' });
-              if (storyId) {
-                updateStory(phaseDb.db, storyId, { status: 'merged' });
-                const story = getStoryById(phaseDb.db, storyId);
-                if (story?.assigned_agent_id) {
-                  const agent = getAgentById(phaseDb.db, story.assigned_agent_id);
-                  if (agent && agent.current_story_id === storyId) {
-                    updateAgent(phaseDb.db, agent.id, { currentStoryId: null, status: 'idle' });
-                  }
+          await phaseDb.provider.withTransaction(async () => {
+            await updatePullRequest(phaseDb.provider, pr.id, { status: 'merged' });
+            if (storyId) {
+              await updateStory(phaseDb.provider, storyId, { status: 'merged' });
+              const story = await getStoryById(phaseDb.provider, storyId);
+              if (story?.assigned_agent_id) {
+                const agent = await getAgentById(phaseDb.provider, story.assigned_agent_id);
+                if (agent && agent.current_story_id === storyId) {
+                  await updateAgent(phaseDb.provider, agent.id, {
+                    currentStoryId: null,
+                    status: 'idle',
+                  });
                 }
-                createLog(phaseDb.db, {
-                  agentId: 'manager',
-                  storyId,
-                  eventType: 'STORY_MERGED',
-                  message: `Story auto-merged from GitHub PR #${pr.github_pr_number} (bypassed pre-existing CI failures: ${bypassedChecks.join(', ')})`,
-                });
-              } else {
-                createLog(phaseDb.db, {
-                  agentId: 'manager',
-                  eventType: 'PR_MERGED',
-                  message: `PR ${pr.id} auto-merged (GitHub PR #${pr.github_pr_number}, bypassed pre-existing CI failures: ${bypassedChecks.join(', ')})`,
-                  metadata: { pr_id: pr.id },
-                });
               }
-            },
-            () => phaseDb.save()
-          );
+              await createLog(phaseDb.provider, {
+                agentId: 'manager',
+                storyId,
+                eventType: 'STORY_MERGED',
+                message: `Story auto-merged from GitHub PR #${pr.github_pr_number} (bypassed pre-existing CI failures: ${bypassedChecks.join(', ')})`,
+              });
+            } else {
+              await createLog(phaseDb.provider, {
+                agentId: 'manager',
+                eventType: 'PR_MERGED',
+                message: `PR ${pr.id} auto-merged (GitHub PR #${pr.github_pr_number}, bypassed pre-existing CI failures: ${bypassedChecks.join(', ')})`,
+                metadata: { pr_id: pr.id },
+              });
+            }
+          });
+          phaseDb.save();
 
           mergedCount++;
 
           if (storyId) {
-            postLifecycleComment(phaseDb.db, paths.hiveDir, config, storyId, 'merged').catch(() => {
-              /* non-fatal */
-            });
-            syncStatusForStory(root, phaseDb.db, storyId, 'merged');
+            postLifecycleComment(phaseDb.provider, paths.hiveDir, config, storyId, 'merged').catch(
+              () => {
+                /* non-fatal */
+              }
+            );
+            syncStatusForStory(root, phaseDb.provider, storyId, 'merged');
           }
           break;
         }
 
         case 'merged': {
           const storyId = pr.story_id;
-          await withTransaction(
-            phaseDb.db,
-            () => {
-              updatePullRequest(phaseDb.db, pr.id, { status: 'merged' });
-              if (storyId) {
-                updateStory(phaseDb.db, storyId, { status: 'merged' });
-                const story = getStoryById(phaseDb.db, storyId);
-                if (story?.assigned_agent_id) {
-                  const agent = getAgentById(phaseDb.db, story.assigned_agent_id);
-                  if (agent && agent.current_story_id === storyId) {
-                    updateAgent(phaseDb.db, agent.id, { currentStoryId: null, status: 'idle' });
-                  }
+          await phaseDb.provider.withTransaction(async () => {
+            await updatePullRequest(phaseDb.provider, pr.id, { status: 'merged' });
+            if (storyId) {
+              await updateStory(phaseDb.provider, storyId, { status: 'merged' });
+              const story = await getStoryById(phaseDb.provider, storyId);
+              if (story?.assigned_agent_id) {
+                const agent = await getAgentById(phaseDb.provider, story.assigned_agent_id);
+                if (agent && agent.current_story_id === storyId) {
+                  await updateAgent(phaseDb.provider, agent.id, {
+                    currentStoryId: null,
+                    status: 'idle',
+                  });
                 }
-                createLog(phaseDb.db, {
-                  agentId: 'manager',
-                  storyId,
-                  eventType: 'STORY_MERGED',
-                  message: `Story auto-merged from GitHub PR #${pr.github_pr_number}`,
-                });
-              } else {
-                createLog(phaseDb.db, {
-                  agentId: 'manager',
-                  eventType: 'PR_MERGED',
-                  message: `PR ${pr.id} auto-merged (GitHub PR #${pr.github_pr_number})`,
-                  metadata: { pr_id: pr.id },
-                });
               }
-            },
-            () => phaseDb.save()
-          );
+              await createLog(phaseDb.provider, {
+                agentId: 'manager',
+                storyId,
+                eventType: 'STORY_MERGED',
+                message: `Story auto-merged from GitHub PR #${pr.github_pr_number}`,
+              });
+            } else {
+              await createLog(phaseDb.provider, {
+                agentId: 'manager',
+                eventType: 'PR_MERGED',
+                message: `PR ${pr.id} auto-merged (GitHub PR #${pr.github_pr_number})`,
+                metadata: { pr_id: pr.id },
+              });
+            }
+          });
+          phaseDb.save();
 
           mergedCount++;
 
           if (storyId) {
-            postLifecycleComment(phaseDb.db, paths.hiveDir, config, storyId, 'merged').catch(() => {
-              /* non-fatal */
-            });
-            syncStatusForStory(root, phaseDb.db, storyId, 'merged');
+            postLifecycleComment(phaseDb.provider, paths.hiveDir, config, storyId, 'merged').catch(
+              () => {
+                /* non-fatal */
+              }
+            );
+            syncStatusForStory(root, phaseDb.provider, storyId, 'merged');
           }
           break;
         }
 
         case 'auto_merge_pending': {
-          createLog(phaseDb.db, {
+          await createLog(phaseDb.provider, {
             agentId: 'manager',
             storyId: pr.story_id || undefined,
             eventType: 'PR_MERGE_SKIPPED',
@@ -574,40 +573,34 @@ export async function autoMergeApprovedPRs(
 
         case 'branch_updated': {
           // Reset to 'approved' so the PR is retried on the next cycle once CI passes
-          await withTransaction(
-            phaseDb.db,
-            () => {
-              updatePullRequest(phaseDb.db, pr.id, { status: 'approved' });
-              createLog(phaseDb.db, {
-                agentId: 'manager',
-                storyId: pr.story_id || undefined,
-                eventType: 'PR_MERGE_SKIPPED',
-                status: 'info',
-                message: `Updated stale branch for PR #${pr.github_pr_number} (was behind base branch), will retry merge`,
-                metadata: { pr_id: pr.id },
-              });
-            },
-            () => phaseDb.save()
-          );
+          await phaseDb.provider.withTransaction(async () => {
+            await updatePullRequest(phaseDb.provider, pr.id, { status: 'approved' });
+            await createLog(phaseDb.provider, {
+              agentId: 'manager',
+              storyId: pr.story_id || undefined,
+              eventType: 'PR_MERGE_SKIPPED',
+              status: 'info',
+              message: `Updated stale branch for PR #${pr.github_pr_number} (was behind base branch), will retry merge`,
+              metadata: { pr_id: pr.id },
+            });
+          });
+          phaseDb.save();
           break;
         }
 
         case 'merge_failed': {
-          await withTransaction(
-            phaseDb.db,
-            () => {
-              updatePullRequest(phaseDb.db, pr.id, { status: 'approved' });
-              createLog(phaseDb.db, {
-                agentId: 'manager',
-                storyId: pr.story_id || undefined,
-                eventType: 'PR_MERGE_FAILED',
-                status: 'error',
-                message: `Failed to auto-merge PR ${pr.id} (GitHub PR #${pr.github_pr_number}): ${result.outcome.type === 'merge_failed' ? result.outcome.error.message : 'Unknown error'}`,
-                metadata: { pr_id: pr.id },
-              });
-            },
-            () => phaseDb.save()
-          );
+          await phaseDb.provider.withTransaction(async () => {
+            await updatePullRequest(phaseDb.provider, pr.id, { status: 'approved' });
+            await createLog(phaseDb.provider, {
+              agentId: 'manager',
+              storyId: pr.story_id || undefined,
+              eventType: 'PR_MERGE_FAILED',
+              status: 'error',
+              message: `Failed to auto-merge PR ${pr.id} (GitHub PR #${pr.github_pr_number}): ${result.outcome.type === 'merge_failed' ? result.outcome.error.message : 'Unknown error'}`,
+              metadata: { pr_id: pr.id },
+            });
+          });
+          phaseDb.save();
           break;
         }
       }

package/src/utils/cli-helpers.test.ts

@@ -2,10 +2,6 @@
 
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 
-vi.mock('../db/client.js', () => ({
-  queryOne: vi.fn(),
-}));
-
 vi.mock('../db/queries/agents.js', () => ({
   getAgentById: vi.fn(),
 }));
@@ -18,7 +14,6 @@ vi.mock('../db/queries/stories.js', () => ({
   getStoryById: vi.fn(),
 }));
 
-import { queryOne } from '../db/client.js';
 import { getAgentById } from '../db/queries/agents.js';
 import { getPullRequestById } from '../db/queries/pull-requests.js';
 import { getStoryById } from '../db/queries/stories.js';
@@ -29,83 +24,86 @@ import {
   requireStory,
 } from './cli-helpers.js';
 
-const mockDb = {} as any;
+const mockDb = {
+  queryOne: vi.fn(),
+} as any;
 
 beforeEach(() => {
   vi.clearAllMocks();
 });
 
 describe('requireStory', () => {
-  it('returns the story when found', () => {
+  it('returns the story when found', async () => {
     const story = { id: 'STORY-1', title: 'Test' };
-    vi.mocked(getStoryById).mockReturnValue(story as any);
+    vi.mocked(getStoryById).mockResolvedValue(story as any);
 
-    const result = requireStory(mockDb, 'STORY-1');
+    const result = await requireStory(mockDb, 'STORY-1');
 
     expect(result).toBe(story);
     expect(getStoryById).toHaveBeenCalledWith(mockDb, 'STORY-1');
   });
 
-  it('exits with error when story not found', () => {
-    vi.mocked(getStoryById).mockReturnValue(undefined);
+  it('exits with error when story not found', async () => {
+    vi.mocked(getStoryById).mockResolvedValue(undefined);
     const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
     const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
       throw new Error('process.exit called');
     }) as any);
 
-    expect(() => requireStory(mockDb, 'STORY-99')).toThrow('process.exit called');
+    await expect(requireStory(mockDb, 'STORY-99')).rejects.toThrow('process.exit called');
     expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Story not found: STORY-99'));
     expect(exitSpy).toHaveBeenCalledWith(1);
   });
 });
 
 describe('requireAgent', () => {
-  it('returns the agent when found', () => {
+  it('returns the agent when found', async () => {
     const agent = { id: 'agent-1', type: 'senior' };
-    vi.mocked(getAgentById).mockReturnValue(agent as any);
+    vi.mocked(getAgentById).mockResolvedValue(agent as any);
 
-    const result = requireAgent(mockDb, 'agent-1');
+    const result = await requireAgent(mockDb, 'agent-1');
 
     expect(result).toBe(agent);
     expect(getAgentById).toHaveBeenCalledWith(mockDb, 'agent-1');
   });
 
-  it('exits with error when agent not found', () => {
-    vi.mocked(getAgentById).mockReturnValue(undefined);
+  it('exits with error when agent not found', async () => {
+    vi.mocked(getAgentById).mockResolvedValue(undefined);
     const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
     const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
       throw new Error('process.exit called');
     }) as any);
 
-    expect(() => requireAgent(mockDb, 'agent-99')).toThrow('process.exit called');
+    await expect(requireAgent(mockDb, 'agent-99')).rejects.toThrow('process.exit called');
     expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Agent not found: agent-99'));
     expect(exitSpy).toHaveBeenCalledWith(1);
   });
 });
 
 describe('requireAgentBySession', () => {
-  it('returns the agent when session matches', () => {
+  it('returns the agent when session matches', async () => {
     const agent = { id: 'agent-1', tmux_session: 'hive-senior-team' };
-    vi.mocked(queryOne).mockReturnValue(agent as any);
+    mockDb.queryOne.mockResolvedValue(agent as any);
 
-    const result = requireAgentBySession(mockDb, 'hive-senior-team');
+    const result = await requireAgentBySession(mockDb, 'hive-senior-team');
 
     expect(result).toBe(agent);
-    expect(queryOne).toHaveBeenCalledWith(
-      mockDb,
+    expect(mockDb.queryOne).toHaveBeenCalledWith(
       expect.stringContaining("status != 'terminated'"),
       ['hive-senior-team']
     );
   });
 
-  it('exits with error when session not found', () => {
-    vi.mocked(queryOne).mockReturnValue(undefined);
+  it('exits with error when session not found', async () => {
+    mockDb.queryOne.mockResolvedValue(undefined);
     const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
     const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
       throw new Error('process.exit called');
     }) as any);
 
-    expect(() => requireAgentBySession(mockDb, 'unknown-session')).toThrow('process.exit called');
+    await expect(requireAgentBySession(mockDb, 'unknown-session')).rejects.toThrow(
+      'process.exit called'
+    );
     expect(errorSpy).toHaveBeenCalledWith(
       expect.stringContaining('No agent found with session: unknown-session')
     );
@@ -114,24 +112,24 @@ describe('requireAgentBySession', () => {
 });
 
 describe('requirePullRequest', () => {
-  it('returns the PR when found', () => {
+  it('returns the PR when found', async () => {
     const pr = { id: 'pr-1', branch_name: 'feature/test' };
-    vi.mocked(getPullRequestById).mockReturnValue(pr as any);
+    vi.mocked(getPullRequestById).mockResolvedValue(pr as any);
 
-    const result = requirePullRequest(mockDb, 'pr-1');
+    const result = await requirePullRequest(mockDb, 'pr-1');
 
     expect(result).toBe(pr);
     expect(getPullRequestById).toHaveBeenCalledWith(mockDb, 'pr-1');
   });
 
-  it('exits with error when PR not found', () => {
-    vi.mocked(getPullRequestById).mockReturnValue(undefined);
+  it('exits with error when PR not found', async () => {
+    vi.mocked(getPullRequestById).mockResolvedValue(undefined);
     const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
     const exitSpy = vi.spyOn(process, 'exit').mockImplementation((() => {
       throw new Error('process.exit called');
     }) as any);
 
-    expect(() => requirePullRequest(mockDb, 'pr-99')).toThrow('process.exit called');
+    await expect(requirePullRequest(mockDb, 'pr-99')).rejects.toThrow('process.exit called');
     expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('PR not found: pr-99'));
     expect(exitSpy).toHaveBeenCalledWith(1);
   });

package/src/utils/cli-helpers.ts

@@ -1,9 +1,8 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
 import chalk from 'chalk';
-import type { Database } from 'sql.js';
 import type { AgentRow, PullRequestRow, StoryRow } from '../db/client.js';
-import { queryOne } from '../db/client.js';
+import type { DatabaseProvider } from '../db/provider.js';
 import { getAgentById } from '../db/queries/agents.js';
 import { getPullRequestById } from '../db/queries/pull-requests.js';
 import { getStoryById } from '../db/queries/stories.js';
@@ -12,8 +11,8 @@ import { normalizeStoryId } from './story-id.js';
 /**
  * Require a story by ID, exit with error if not found.
  */
-export function requireStory(db: Database, storyId: string): StoryRow {
-  const story = getStoryById(db, normalizeStoryId(storyId));
+export async function requireStory(db: DatabaseProvider, storyId: string): Promise<StoryRow> {
+  const story = await getStoryById(db, normalizeStoryId(storyId));
   if (!story) {
     console.error(chalk.red(`Story not found: ${storyId}`));
     process.exit(1);
@@ -24,8 +23,8 @@ export function requireStory(db: Database, storyId: string): StoryRow {
 /**
  * Require an agent by ID, exit with error if not found.
  */
-export function requireAgent(db: Database, agentId: string): AgentRow {
-  const agent = getAgentById(db, agentId);
+export async function requireAgent(db: DatabaseProvider, agentId: string): Promise<AgentRow> {
+  const agent = await getAgentById(db, agentId);
   if (!agent) {
     console.error(chalk.red(`Agent not found: ${agentId}`));
     process.exit(1);
@@ -36,9 +35,11 @@ export function requireAgent(db: Database, agentId: string): AgentRow {
 /**
  * Require an active agent by tmux session name, exit with error if not found or terminated.
  */
-export function requireAgentBySession(db: Database, session: string): AgentRow {
-  const agent = queryOne<AgentRow>(
-    db,
+export async function requireAgentBySession(
+  db: DatabaseProvider,
+  session: string
+): Promise<AgentRow> {
+  const agent = await db.queryOne<AgentRow>(
     "SELECT * FROM agents WHERE tmux_session = ? AND status != 'terminated'",
     [session]
   );
@@ -52,8 +53,11 @@ export function requireAgentBySession(db: Database, session: string): AgentRow {
 /**
  * Require a pull request by ID, exit with error if not found.
  */
-export function requirePullRequest(db: Database, prId: string): PullRequestRow {
-  const pr = getPullRequestById(db, prId);
+export async function requirePullRequest(
+  db: DatabaseProvider,
+  prId: string
+): Promise<PullRequestRow> {
+  const pr = await getPullRequestById(db, prId);
   if (!pr) {
     console.error(chalk.red(`PR not found: ${prId}`));
     process.exit(1);

package/src/utils/paths.test.ts

@@ -99,6 +99,7 @@ describe('paths utility', () => {
         hiveDir: join(rootDir, '.hive'),
         dbPath: join(rootDir, '.hive', 'hive.db'),
         configPath: join(rootDir, '.hive', 'hive.config.yaml'),
+        workspaceIdPath: join(rootDir, '.hive', 'workspace.id'),
         agentsDir: join(rootDir, '.hive', 'agents'),
         logsDir: join(rootDir, '.hive', 'logs'),
         reposDir: join(rootDir, 'repos'),