hungry-ghost-hive 0.47.4 → 0.49.0

package/src/cli/commands/req-headless.test.ts

@@ -0,0 +1,170 @@
+// Licensed under the Hungry Ghost Hive License. See LICENSE.
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+vi.mock('../../cli-runtimes/index.js', () => ({
+  getCliRuntimeBuilder: vi.fn(() => ({
+    buildSpawnCommand: vi.fn(() => ['claude', '--dangerously-skip-permissions']),
+  })),
+  resolveRuntimeModelForCli: vi.fn(model => model),
+}));
+
+vi.mock('../../cluster/runtime.js', () => ({
+  fetchLocalClusterStatus: vi.fn(() => null),
+}));
+
+vi.mock('../../config/loader.js', () => ({
+  loadConfig: vi.fn(() => ({
+    models: {
+      tech_lead: {
+        cli_tool: 'claude',
+        safety_mode: 'bypassPermissions',
+        model: 'claude-sonnet-4-6',
+      },
+    },
+    integrations: {
+      project_management: { provider: 'none' },
+    },
+    agents: { chrome_enabled: false },
+    cluster: { enabled: false },
+  })),
+}));
+
+vi.mock('../../connectors/registry.js', () => ({
+  registry: {
+    getProjectManagement: vi.fn(() => null),
+  },
+}));
+
+vi.mock('../../db/client.js', () => ({
+  withTransaction: vi.fn(async (_db: unknown, fn: () => unknown) => fn()),
+}));
+
+vi.mock('../../db/queries/agents.js', () => ({
+  createAgent: vi.fn(() => ({ id: 'agent-1' })),
+  getTechLead: vi.fn(() => ({ id: 'agent-1' })),
+  updateAgent: vi.fn(),
+}));
+
+vi.mock('../../db/queries/logs.js', () => ({
+  createLog: vi.fn(),
+}));
+
+vi.mock('../../db/queries/requirements.js', () => ({
+  createRequirement: vi.fn(() => ({ id: 'req-1', godmode: 0 })),
+  updateRequirement: vi.fn(),
+}));
+
+vi.mock('../../db/queries/teams.js', () => ({
+  getAllTeams: vi.fn(() => [{ id: 'team-1', name: 'alpha' }]),
+}));
+
+vi.mock('../../tmux/manager.js', () => ({
+  isTmuxAvailable: vi.fn(),
+  isTmuxSessionRunning: vi.fn(),
+  sendToTmuxSession: vi.fn(),
+  spawnTmuxSession: vi.fn(),
+}));
+
+vi.mock('../../utils/instance.js', () => ({
+  getTechLeadSessionName: vi.fn(() => 'hive-tech-lead'),
+}));
+
+vi.mock('../../utils/with-hive-context.js', () => ({
+  withHiveContext: vi.fn(
+    (
+      cb: (ctx: {
+        root: string;
+        paths: { hiveDir: string };
+        db: { db: object; provider: object };
+      }) => unknown
+    ) =>
+      cb({
+        root: '/tmp/hive',
+        paths: { hiveDir: '/tmp/hive/.hive' },
+        db: { db: {}, provider: { withTransaction: vi.fn(async (fn: () => unknown) => fn()) } },
+      })
+  ),
+}));
+
+vi.mock('../dashboard/index.js', () => ({
+  startDashboard: vi.fn(),
+}));
+
+vi.mock('ora', () => ({
+  default: vi.fn(() => ({
+    start: vi.fn().mockReturnThis(),
+    succeed: vi.fn().mockReturnThis(),
+    fail: vi.fn().mockReturnThis(),
+    warn: vi.fn().mockReturnThis(),
+    text: '',
+  })),
+}));
+
+import * as tmuxManager from '../../tmux/manager.js';
+import * as dashboard from '../dashboard/index.js';
+import { reqCommand } from './req.js';
+
+describe('req command - headless dashboard behavior', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    delete process.env.HIVE_HEADLESS;
+    // Reset Commander option state between tests so --headless from one test
+    // doesn't bleed into the next.
+    reqCommand.setOptionValue('headless', undefined);
+    vi.mocked(tmuxManager.isTmuxAvailable).mockResolvedValue(true);
+    vi.mocked(tmuxManager.isTmuxSessionRunning).mockResolvedValue(false);
+  });
+
+  afterEach(() => {
+    delete process.env.HIVE_HEADLESS;
+  });
+
+  it('calls startDashboard when --headless flag is not set', async () => {
+    await reqCommand.parseAsync(['node', 'req', 'Build a feature', '--target-branch', 'main'], {
+      from: 'user',
+    });
+
+    expect(dashboard.startDashboard).toHaveBeenCalledOnce();
+  });
+
+  it('does not call startDashboard when --headless flag is passed', async () => {
+    await reqCommand.parseAsync(
+      ['node', 'req', 'Build a feature', '--target-branch', 'main', '--headless'],
+      { from: 'user' }
+    );
+
+    expect(dashboard.startDashboard).not.toHaveBeenCalled();
+  });
+
+  it('does not call startDashboard when HIVE_HEADLESS=1 env var is set', async () => {
+    process.env.HIVE_HEADLESS = '1';
+
+    await reqCommand.parseAsync(['node', 'req', 'Build a feature', '--target-branch', 'main'], {
+      from: 'user',
+    });
+
+    expect(dashboard.startDashboard).not.toHaveBeenCalled();
+  });
+
+  it('calls startDashboard when HIVE_HEADLESS env var is absent', async () => {
+    delete process.env.HIVE_HEADLESS;
+
+    await reqCommand.parseAsync(['node', 'req', 'Build a feature', '--target-branch', 'main'], {
+      from: 'user',
+    });
+
+    expect(dashboard.startDashboard).toHaveBeenCalledOnce();
+  });
+
+  it('does not call startDashboard when HIVE_HEADLESS is set to non-1 value', async () => {
+    process.env.HIVE_HEADLESS = '0';
+
+    await reqCommand.parseAsync(['node', 'req', 'Build a feature', '--target-branch', 'main'], {
+      from: 'user',
+    });
+
+    // HIVE_HEADLESS=0 is falsy for the === '1' check, so dashboard should launch
+    expect(dashboard.startDashboard).toHaveBeenCalledOnce();
+  });
+});

package/src/cli/commands/req-spawn.test.ts

@@ -75,8 +75,18 @@ vi.mock('../../utils/instance.js', () => ({
 
 vi.mock('../../utils/with-hive-context.js', () => ({
   withHiveContext: vi.fn(
-    (cb: (ctx: { root: string; paths: { hiveDir: string }; db: { db: object } }) => unknown) =>
-      cb({ root: '/tmp/hive', paths: { hiveDir: '/tmp/hive/.hive' }, db: { db: {} } })
+    (
+      cb: (ctx: {
+        root: string;
+        paths: { hiveDir: string };
+        db: { db: object; provider: object };
+      }) => unknown
+    ) =>
+      cb({
+        root: '/tmp/hive',
+        paths: { hiveDir: '/tmp/hive/.hive' },
+        db: { db: {}, provider: { withTransaction: vi.fn(async (fn: () => unknown) => fn()) } },
+      })
   ),
 }));
 

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

@@ -131,3 +131,39 @@ describe('req command - URL validation', () => {
     expect(connector).toBeNull();
   });
 });
+
+describe('req command - headless flag', () => {
+  afterEach(() => {
+    delete process.env.HIVE_HEADLESS;
+    vi.restoreAllMocks();
+  });
+
+  it('should set HIVE_HEADLESS env var when headless option is true', () => {
+    // Simulate what req command does when --headless is passed
+    const options = { headless: true };
+    if (options.headless) {
+      process.env.HIVE_HEADLESS = '1';
+    }
+    expect(process.env.HIVE_HEADLESS).toBe('1');
+  });
+
+  it('should not set HIVE_HEADLESS env var when headless option is false', () => {
+    const options = { headless: false };
+    if (options.headless) {
+      process.env.HIVE_HEADLESS = '1';
+    }
+    expect(process.env.HIVE_HEADLESS).toBeUndefined();
+  });
+
+  it('should skip dashboard when HIVE_HEADLESS env var is set', () => {
+    process.env.HIVE_HEADLESS = '1';
+    const headless = process.env.HIVE_HEADLESS === '1';
+    expect(headless).toBe(true);
+  });
+
+  it('should launch dashboard when HIVE_HEADLESS env var is not set', () => {
+    delete process.env.HIVE_HEADLESS;
+    const headless = process.env.HIVE_HEADLESS === '1';
+    expect(headless).toBe(false);
+  });
+});

package/src/cli/commands/req.ts

@@ -9,7 +9,6 @@ import { getCliRuntimeBuilder, resolveRuntimeModelForCli } from '../../cli-runti
 import { fetchLocalClusterStatus } from '../../cluster/runtime.js';
 import { loadConfig } from '../../config/loader.js';
 import { registry } from '../../connectors/registry.js';
-import { withTransaction } from '../../db/client.js';
 import { createAgent, getTechLead, updateAgent } from '../../db/queries/agents.js';
 import { createLog } from '../../db/queries/logs.js';
 import { createRequirement, updateRequirement } from '../../db/queries/requirements.js';
@@ -32,6 +31,7 @@ export const reqCommand = new Command('req')
   .option('--dry-run', 'Create requirement without spawning agents')
   .option('--godmode', 'Enable godmode - use most powerful models for all agents')
   .option('--target-branch <branch>', 'Target branch for PRs (skips interactive prompt)')
+  .option('--headless', 'Skip TUI dashboard auto-launch after submitting requirement')
   .action(
     async (
       requirement: string | undefined,
@@ -41,6 +41,7 @@ export const reqCommand = new Command('req')
         dryRun?: boolean;
         godmode?: boolean;
         targetBranch?: string;
+        headless?: boolean;
       }
     ) => {
       await withHiveContext(async ({ root, paths, db }) => {
@@ -141,7 +142,7 @@ export const reqCommand = new Command('req')
 
         try {
           // Check if there are any teams
-          const teams = getAllTeams(db.db);
+          const teams = await getAllTeams(db.provider);
           if (teams.length === 0) {
             spinner.fail(chalk.red('No teams found. Add a repository first:'));
             console.log(chalk.gray('  hive add-repo --url <repo-url> --team <team-name>'));
@@ -150,7 +151,7 @@ export const reqCommand = new Command('req')
 
           // Create requirement
           spinner.text = 'Creating requirement...';
-          const req = createRequirement(db.db, {
+          const req = await createRequirement(db.provider, {
             title,
             description,
             godmode: options.godmode,
@@ -159,7 +160,7 @@ export const reqCommand = new Command('req')
 
           // If this came from a PM provider epic URL, store the epic key/id
           if (epicKey && epicId) {
-            updateRequirement(db.db, req.id, {
+            await updateRequirement(db.provider, req.id, {
               jiraEpicKey: epicKey,
               jiraEpicId: epicId,
             });
@@ -188,7 +189,7 @@ export const reqCommand = new Command('req')
 
           // Get or create Tech Lead agent
           spinner.text = 'Spawning Tech Lead...';
-          let techLead = getTechLead(db.db);
+          let techLead = await getTechLead(db.provider);
           const techLeadCliTool = config.models.tech_lead.cli_tool;
           const techLeadSafetyMode = config.models.tech_lead.safety_mode;
           const techLeadModel = resolveRuntimeModelForCli(
@@ -197,21 +198,21 @@ export const reqCommand = new Command('req')
           );
 
           if (!techLead) {
-            techLead = createAgent(db.db, { type: 'tech_lead', model: techLeadModel });
+            techLead = await createAgent(db.provider, { type: 'tech_lead', model: techLeadModel });
           }
 
           // Update Tech Lead status and log event (atomic transaction)
-          await withTransaction(db.db, () => {
-            updateAgent(db.db, techLead.id, { status: 'working' });
+          await db.provider.withTransaction(async () => {
+            await updateAgent(db.provider, techLead.id, { status: 'working' });
 
-            createLog(db.db, {
+            await createLog(db.provider, {
               agentId: techLead.id,
               eventType: 'REQUIREMENT_RECEIVED',
               message: title,
               metadata: { requirement_id: req.id, godmode: req.godmode ? true : false },
             });
 
-            updateRequirement(db.db, req.id, { status: 'planning' });
+            await updateRequirement(db.provider, req.id, { status: 'planning' });
           });
 
           // Spawn Tech Lead tmux session
@@ -255,17 +256,17 @@ export const reqCommand = new Command('req')
             }
 
             // Update agent and log spawning/planning events (atomic transaction)
-            await withTransaction(db.db, () => {
-              updateAgent(db.db, techLead.id, { tmuxSession: sessionName });
+            await db.provider.withTransaction(async () => {
+              await updateAgent(db.provider, techLead.id, { tmuxSession: sessionName });
 
-              createLog(db.db, {
+              await createLog(db.provider, {
                 agentId: techLead.id,
                 eventType: 'AGENT_SPAWNED',
                 message: `Tech Lead spawned for requirement ${req.id}`,
                 metadata: { tmux_session: sessionName },
               });
 
-              createLog(db.db, {
+              await createLog(db.provider, {
                 agentId: techLead.id,
                 eventType: 'PLANNING_STARTED',
                 message: `Planning started for requirement ${req.id}`,
@@ -284,12 +285,15 @@ export const reqCommand = new Command('req')
             console.log(chalk.cyan(`  tmux attach -t ${sessionName}`));
             console.log();
 
-            // Launch dashboard
-            try {
-              await startDashboard();
-            } catch (dashboardErr) {
-              console.warn(chalk.yellow('⚠️  Failed to start dashboard'));
-              console.error(dashboardErr);
+            // Launch dashboard (skip if --headless flag or HIVE_HEADLESS env var is set)
+            const headless = options.headless || process.env.HIVE_HEADLESS === '1';
+            if (!headless) {
+              try {
+                await startDashboard();
+              } catch (dashboardErr) {
+                console.warn(chalk.yellow('⚠️  Failed to start dashboard'));
+                console.error(dashboardErr);
+              }
             }
           } catch (tmuxErr) {
             spinner.warn(chalk.yellow('Requirement created but failed to spawn Tech Lead'));

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

@@ -49,7 +49,7 @@ vi.mock('../../tmux/manager.js', () => ({
 
 vi.mock('../../utils/with-hive-context.js', () => ({
   withHiveContext: vi.fn(callback =>
-    callback({ db: { db: {} }, root: '/tmp', paths: { hiveDir: '/tmp/.hive' } })
+    callback({ db: { db: {}, provider: {} }, root: '/tmp', paths: { hiveDir: '/tmp/.hive' } })
   ),
 }));
 

package/src/cli/commands/resume.ts

@@ -9,7 +9,6 @@ import {
   selectCompatibleModelForCli,
 } from '../../cli-runtimes/index.js';
 import { loadConfig } from '../../config/index.js';
-import { withTransaction } from '../../db/client.js';
 import { getAllAgents, updateAgent, type AgentRow } from '../../db/queries/agents.js';
 import { createLog } from '../../db/queries/logs.js';
 import { getTeamById } from '../../db/queries/teams.js';
@@ -35,17 +34,17 @@ export const resumeCommand = new Command('resume')
       let agentsToResume: AgentRow[];
 
       if (options.agent) {
-        const agent = requireAgent(db.db, options.agent);
+        const agent = await requireAgent(db.provider, options.agent);
         if (agent.status === 'terminated') {
           console.error(chalk.red('Cannot resume a terminated agent'));
           process.exit(1);
         }
         agentsToResume = [agent];
       } else if (options.all) {
-        agentsToResume = getAllAgents(db.db).filter(a => a.status !== 'terminated');
+        agentsToResume = (await getAllAgents(db.provider)).filter(a => a.status !== 'terminated');
       } else {
         // Default: resume blocked or idle agents that have memory state
-        agentsToResume = getAllAgents(db.db).filter(
+        agentsToResume = (await getAllAgents(db.provider)).filter(
           a => a.status !== 'terminated' && a.memory_state
         );
       }
@@ -73,7 +72,7 @@ export const resumeCommand = new Command('resume')
           // Determine work directory
           let workDir = root;
           if (agent.team_id) {
-            const team = getTeamById(db.db, agent.team_id);
+            const team = await getTeamById(db.provider, agent.team_id);
             if (team) {
               workDir = `${root}/${team.repo_path}`;
             }
@@ -105,13 +104,13 @@ export const resumeCommand = new Command('resume')
           });
 
           // Update agent state and log event (atomic transaction)
-          await withTransaction(db.db, () => {
-            updateAgent(db.db, agent.id, {
+          await db.provider.withTransaction(async () => {
+            await updateAgent(db.provider, agent.id, {
               status: 'working',
               tmuxSession: sessionName,
             });
 
-            createLog(db.db, {
+            await createLog(db.provider, {
               agentId: agent.id,
               storyId: agent.current_story_id,
               eventType: 'AGENT_RESUMED',

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

@@ -36,7 +36,7 @@ vi.mock('../../db/queries/teams.js', () => ({
 }));
 
 vi.mock('../../utils/with-hive-context.js', () => ({
-  withReadOnlyHiveContext: vi.fn(callback => callback({ db: { db: {} } })),
+  withReadOnlyHiveContext: vi.fn(callback => callback({ db: { db: {}, provider: {} } })),
 }));
 
 import { statusCommand } from './status.js';

package/src/cli/commands/status.ts

@@ -2,6 +2,7 @@
 
 import chalk from 'chalk';
 import { Command } from 'commander';
+import type { DatabaseProvider } from '../../db/provider.js';
 import { getActiveAgents, getAllAgents } from '../../db/queries/agents.js';
 import { getPendingEscalations, getPendingHumanEscalations } from '../../db/queries/escalations.js';
 import { getLogsByStory, getRecentLogs } from '../../db/queries/logs.js';
@@ -23,26 +24,26 @@ export const statusCommand = new Command('status')
   .option('--story <id>', 'Show status for a specific story')
   .option('--json', 'Output as JSON')
   .action(async (options: { team?: string; story?: string; json?: boolean }) => {
-    await withReadOnlyHiveContext(({ db }) => {
+    await withReadOnlyHiveContext(async ({ db }) => {
       if (options.story) {
-        showStoryStatus(db.db, options.story, options.json);
+        await showStoryStatus(db.provider, options.story, options.json);
       } else if (options.team) {
-        showTeamStatus(db.db, options.team, options.json);
+        await showTeamStatus(db.provider, options.team, options.json);
       } else {
-        showOverallStatus(db.db, options.json);
+        await showOverallStatus(db.provider, options.json);
       }
     });
   });
 
-function showOverallStatus(db: import('sql.js').Database, json?: boolean): void {
-  const teams = getAllTeams(db);
-  const allAgents = getAllAgents(db);
-  const activeAgents = getActiveAgents(db);
-  const storyCounts = getStoryCounts(db);
-  const requirements = getPendingRequirements(db);
-  const escalations = getPendingEscalations(db);
-  const approvals = getPendingHumanEscalations(db);
-  const recentLogs = getRecentLogs(db, 5);
+async function showOverallStatus(db: DatabaseProvider, json?: boolean): Promise<void> {
+  const teams = await getAllTeams(db);
+  const allAgents = await getAllAgents(db);
+  const activeAgents = await getActiveAgents(db);
+  const storyCounts = await getStoryCounts(db);
+  const requirements = await getPendingRequirements(db);
+  const escalations = await getPendingEscalations(db);
+  const approvals = await getPendingHumanEscalations(db);
+  const recentLogs = await getRecentLogs(db, 5);
 
   const terminatedAgents = allAgents.filter(a => a.status === 'terminated').length;
 
@@ -153,21 +154,44 @@ function showOverallStatus(db: import('sql.js').Database, json?: boolean): void
   }
 }
 
-function showTeamStatus(db: import('sql.js').Database, teamName: string, json?: boolean): void {
-  const team = getTeamByName(db, teamName);
+async function showTeamStatus(
+  db: DatabaseProvider,
+  teamName: string,
+  json?: boolean
+): Promise<void> {
+  const team = await getTeamByName(db, teamName);
   if (!team) {
     console.error(chalk.red(`Team not found: ${teamName}`));
     process.exit(1);
   }
 
-  const stories = getStoriesByTeam(db, team.id);
-  const activeAgents = getActiveAgents(db).filter(a => a.team_id === team.id);
+  const stories = await getStoriesByTeam(db, team.id);
+  const activeAgents = (await getActiveAgents(db)).filter(a => a.team_id === team.id);
 
   const storyCounts: Record<string, number> = {};
   for (const story of stories) {
     storyCounts[story.status] = (storyCounts[story.status] || 0) + 1;
   }
 
+  const agentDetails = [];
+  for (const a of activeAgents) {
+    let godmode = false;
+    if (a.current_story_id) {
+      const story = await getStoryById(db, a.current_story_id);
+      if (story && story.requirement_id) {
+        const requirement = await getRequirementById(db, story.requirement_id);
+        godmode = requirement?.godmode ? true : false;
+      }
+    }
+    agentDetails.push({
+      id: a.id,
+      type: a.type,
+      status: a.status,
+      currentStory: a.current_story_id,
+      godmode,
+    });
+  }
+
   const status = {
     team: {
       id: team.id,
@@ -175,23 +199,7 @@ function showTeamStatus(db: import('sql.js').Database, teamName: string, json?:
       repo_url: team.repo_url,
       repo_path: team.repo_path,
     },
-    agents: activeAgents.map(a => {
-      let godmode = false;
-      if (a.current_story_id) {
-        const story = getStoryById(db, a.current_story_id);
-        if (story && story.requirement_id) {
-          const requirement = getRequirementById(db, story.requirement_id);
-          godmode = requirement?.godmode ? true : false;
-        }
-      }
-      return {
-        id: a.id,
-        type: a.type,
-        status: a.status,
-        currentStory: a.current_story_id,
-        godmode,
-      };
-    }),
+    agents: agentDetails,
     stories: {
       total: stories.length,
       counts: storyCounts,
@@ -215,9 +223,9 @@ function showTeamStatus(db: import('sql.js').Database, teamName: string, json?:
     for (const agent of activeAgents) {
       let opusIndicator = '';
       if (agent.current_story_id) {
-        const story = getStoryById(db, agent.current_story_id);
+        const story = await getStoryById(db, agent.current_story_id);
         if (story && story.requirement_id) {
-          const requirement = getRequirementById(db, story.requirement_id);
+          const requirement = await getRequirementById(db, story.requirement_id);
           if (requirement?.godmode) {
             opusIndicator = chalk.yellow(' [Opus]');
           }
@@ -237,11 +245,15 @@ function showTeamStatus(db: import('sql.js').Database, teamName: string, json?:
   }
 }
 
-function showStoryStatus(db: import('sql.js').Database, storyId: string, json?: boolean): void {
-  const story = requireStory(db, storyId);
+async function showStoryStatus(
+  db: DatabaseProvider,
+  storyId: string,
+  json?: boolean
+): Promise<void> {
+  const story = await requireStory(db, storyId);
 
-  const dependencies = getStoryDependencies(db, story.id);
-  const logs = getLogsByStory(db, story.id).slice(0, 10);
+  const dependencies = await getStoryDependencies(db, story.id);
+  const logs = (await getLogsByStory(db, story.id)).slice(0, 10);
 
   const status = {
     story: {

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

@@ -34,8 +34,10 @@ vi.mock('../../integrations/jira/stories.js', () => ({
 }));
 
 vi.mock('../../utils/with-hive-context.js', () => ({
-  withHiveContext: vi.fn(callback => callback({ db: { db: {} }, paths: { hiveDir: '/tmp' } })),
-  withReadOnlyHiveContext: vi.fn(callback => callback({ db: { db: {} } })),
+  withHiveContext: vi.fn(callback =>
+    callback({ db: { db: {}, provider: {} }, paths: { hiveDir: '/tmp' } })
+  ),
+  withReadOnlyHiveContext: vi.fn(callback => callback({ db: { db: {}, provider: {} } })),
 }));
 
 import { storiesCommand } from './stories.js';

package/src/cli/commands/stories.ts

@@ -27,9 +27,9 @@ storiesCommand
     await withReadOnlyHiveContext(async ({ db }) => {
       let stories;
       if (options.status) {
-        stories = getStoriesByStatus(db.db, options.status as StoryStatus);
+        stories = await getStoriesByStatus(db.provider, options.status as StoryStatus);
       } else {
-        stories = getAllStories(db.db);
+        stories = await getAllStories(db.provider);
       }
 
       if (options.json) {
@@ -89,8 +89,8 @@ storiesCommand
     }) => {
       await withHiveContext(async ({ root, paths, db }) => {
         // Create local story
-        const story = createStory(
-          db.db,
+        const story = await createStory(
+          db.provider,
           {
             requirementId: options.requirement || null,
             teamId: options.team || null,
@@ -103,8 +103,8 @@ storiesCommand
 
         // Update with optional fields
         if (options.points !== undefined || options.complexity !== undefined) {
-          updateStory(
-            db.db,
+          await updateStory(
+            db.provider,
             story.id,
             {
               storyPoints: options.points ?? null,
@@ -118,8 +118,8 @@ storiesCommand
         // Sync to PM provider if configured
         let externalKey: string | null = null;
         try {
-          const updatedStory = getStoryById(db.db, story.id)!;
-          const result = await syncStoryToProvider(root, db.db, updatedStory);
+          const updatedStory = (await getStoryById(db.provider, story.id))!;
+          const result = await syncStoryToProvider(root, db.provider, updatedStory);
 
           if (result) {
             externalKey = result.key;
@@ -134,7 +134,7 @@ storiesCommand
         }
 
         if (options.json) {
-          const finalStory = getStoryById(db.db, story.id);
+          const finalStory = await getStoryById(db.provider, story.id);
           console.log(JSON.stringify(finalStory, null, 2));
           return;
         }
@@ -154,9 +154,9 @@ storiesCommand
   .description('Show story details')
   .action(async (storyId: string) => {
     await withReadOnlyHiveContext(async ({ db }) => {
-      const story = requireStory(db.db, storyId);
+      const story = await requireStory(db.provider, storyId);
 
-      const dependencies = getStoryDependencies(db.db, story.id);
+      const dependencies = await getStoryDependencies(db.provider, story.id);
 
       console.log(chalk.bold(`\nStory: ${story.id}\n`));
       console.log(chalk.bold('Title:'), story.title);