hungry-ghost-hive 0.48.0 → 0.49.0

package/src/cli/commands/approvals.ts

@@ -63,8 +63,10 @@ approvalsCommand
   .action(async (options: { all?: boolean; json?: boolean }) => {
     await withHiveContext(async ({ db }) => {
       const approvals = options.all
-        ? getAllEscalations(db.db).filter(escalation => escalation.to_agent_id === null)
-        : getPendingHumanEscalations(db.db);
+        ? (await getAllEscalations(db.provider)).filter(
+            escalation => escalation.to_agent_id === null
+          )
+        : await getPendingHumanEscalations(db.provider);
 
       if (options.json) {
         console.log(JSON.stringify(approvals, null, 2));
@@ -107,7 +109,7 @@ approvalsCommand
   .description('Show a human approval request')
   .action(async (id: string) => {
     await withHiveContext(async ({ db }) => {
-      const approval = ensureHumanApprovalEscalation(getEscalationById(db.db, id), id);
+      const approval = ensureHumanApprovalEscalation(await getEscalationById(db.provider, id), id);
       const type = classifyApproval(approval.reason);
 
       console.log(chalk.bold(`\nApproval: ${approval.id}\n`));
@@ -132,14 +134,14 @@ approvalsCommand
   .option('-m, --message <message>', 'Optional guidance sent as approval context')
   .action(async (id: string, options: { message?: string }) => {
     await withHiveContext(async ({ db }) => {
-      const approval = ensureHumanApprovalEscalation(getEscalationById(db.db, id), id);
+      const approval = ensureHumanApprovalEscalation(await getEscalationById(db.provider, id), id);
       if (approval.status === 'resolved') {
         console.log(chalk.yellow(`Approval ${id} is already resolved.`));
         return;
       }
 
       const note = options.message?.trim() || 'Approved by human reviewer.';
-      resolveEscalation(db.db, id, `APPROVED: ${note}`);
+      await resolveEscalation(db.provider, id, `APPROVED: ${note}`);
       console.log(chalk.green(`Approved ${id}.`));
     });
   });
@@ -150,13 +152,13 @@ approvalsCommand
   .requiredOption('-m, --message <message>', 'Reason/guidance for denial')
   .action(async (id: string, options: { message: string }) => {
     await withHiveContext(async ({ db }) => {
-      const approval = ensureHumanApprovalEscalation(getEscalationById(db.db, id), id);
+      const approval = ensureHumanApprovalEscalation(await getEscalationById(db.provider, id), id);
       if (approval.status === 'resolved') {
         console.log(chalk.yellow(`Approval ${id} is already resolved.`));
         return;
       }
 
-      resolveEscalation(db.db, id, `DENIED: ${options.message}`);
+      await resolveEscalation(db.provider, id, `DENIED: ${options.message}`);
       console.log(chalk.green(`Denied ${id}.`));
     });
   });

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

@@ -1,8 +1,8 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
-import type { Database } from 'sql.js';
 import initSqlJs from 'sql.js';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { SqliteProvider } from '../../db/provider.js';
 import { getPlannedStories } from '../../db/queries/stories.js';
 import { getTeamById } from '../../db/queries/teams.js';
 
@@ -16,7 +16,7 @@ vi.mock('../../db/queries/stories.js');
 vi.mock('../../db/queries/teams.js');
 
 describe('Assign Command', () => {
-  let db: Database;
+  let db: SqliteProvider;
 
   const mockConfig = {
     scaling: {
@@ -90,22 +90,23 @@ CREATE TABLE IF NOT EXISTS stories (
 
   beforeEach(async () => {
     const SQL = await initSqlJs();
-    db = new SQL.Database();
-    db.run('PRAGMA foreign_keys = ON');
-    db.run(INITIAL_MIGRATION);
+    const rawDb = new SQL.Database();
+    rawDb.run('PRAGMA foreign_keys = ON');
+    rawDb.run(INITIAL_MIGRATION);
+    db = new SqliteProvider(rawDb);
     vi.clearAllMocks();
   });
 
   describe('--dry-run flag', () => {
-    it('should return empty when no stories are planned', () => {
+    it('should return empty when no stories are planned', async () => {
       // Mock empty planned stories
-      vi.mocked(getPlannedStories).mockReturnValue([]);
+      vi.mocked(getPlannedStories).mockResolvedValue([]);
 
-      const plannedStories = getPlannedStories(db);
+      const plannedStories = await getPlannedStories(db);
       expect(plannedStories).toEqual([]);
     });
 
-    it('should show stories grouped by team without making assignments', () => {
+    it('should show stories grouped by team without making assignments', async () => {
       // Mock planned stories with team association
       const mockStories = [
         {
@@ -168,8 +169,8 @@ CREATE TABLE IF NOT EXISTS stories (
         },
       ];
 
-      vi.mocked(getPlannedStories).mockReturnValue(mockStories);
-      vi.mocked(getTeamById).mockReturnValue({
+      vi.mocked(getPlannedStories).mockResolvedValue(mockStories);
+      vi.mocked(getTeamById).mockResolvedValue({
         id: 'team-1',
         repo_url: 'https://github.com/test/repo',
         repo_path: '/path/to/repo',
@@ -177,7 +178,7 @@ CREATE TABLE IF NOT EXISTS stories (
         created_at: new Date().toISOString(),
       });
 
-      const plannedStories = getPlannedStories(db);
+      const plannedStories = await getPlannedStories(db);
       expect(plannedStories).toHaveLength(2);
       expect(plannedStories[0].team_id).toBe('team-1');
     });
@@ -220,7 +221,7 @@ CREATE TABLE IF NOT EXISTS stories (
       expect(targetLevel).toBe('Senior');
     });
 
-    it('should not make database changes during dry-run', () => {
+    it('should not make database changes during dry-run', async () => {
       // The dry-run option should only call getPlannedStories without making any changes
       const mockStories = [
         {
@@ -254,17 +255,17 @@ CREATE TABLE IF NOT EXISTS stories (
         },
       ];
 
-      vi.mocked(getPlannedStories).mockReturnValue(mockStories);
+      vi.mocked(getPlannedStories).mockResolvedValue(mockStories);
 
       // In dry-run mode, we should only read data, not write
-      const plannedStories = getPlannedStories(db);
+      const plannedStories = await getPlannedStories(db);
       expect(plannedStories).toHaveLength(1);
 
       // Verify that no assignment operations were performed
       // (This would be verified by checking that Scheduler.assignStories was not called)
     });
 
-    it('should handle multiple teams in planned stories', () => {
+    it('should handle multiple teams in planned stories', async () => {
       const mockStories = [
         {
           id: 'STORY-001',
@@ -326,9 +327,9 @@ CREATE TABLE IF NOT EXISTS stories (
         },
       ];
 
-      vi.mocked(getPlannedStories).mockReturnValue(mockStories);
+      vi.mocked(getPlannedStories).mockResolvedValue(mockStories);
 
-      const plannedStories = getPlannedStories(db);
+      const plannedStories = await getPlannedStories(db);
       expect(plannedStories).toHaveLength(2);
 
       // Verify stories are grouped by team

package/src/cli/commands/assign.ts

@@ -48,11 +48,11 @@ export const assignCommand = new Command('assign')
         }
 
         // Check if godmode is active
-        const plannedStories = getPlannedStories(db.db);
+        const plannedStories = await getPlannedStories(db.provider);
         let godmodeActive = false;
         for (const story of plannedStories) {
           if (story.requirement_id) {
-            const requirement = getRequirementById(db.db, story.requirement_id);
+            const requirement = await getRequirementById(db.provider, story.requirement_id);
             if (requirement && requirement.godmode) {
               godmodeActive = true;
               break;
@@ -85,7 +85,7 @@ export const assignCommand = new Command('assign')
 
           // Display planned assignments
           for (const [teamId, stories] of storiesByTeam) {
-            const team = getTeamById(db.db, teamId);
+            const team = await getTeamById(db.provider, teamId);
             if (!team) continue;
 
             console.log(chalk.cyan(`\n📦 Team: ${team.name}\n`));
@@ -114,7 +114,7 @@ export const assignCommand = new Command('assign')
           console.log(chalk.yellow('⚡ GODMODE is active - all agents will use Opus 4.6\n'));
         }
 
-        const scheduler = new Scheduler(db.db, {
+        const scheduler = new Scheduler(db.provider, {
           scaling: config.scaling,
           models: config.models,
           qa: config.qa,

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

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

package/src/cli/commands/cleanup.ts

@@ -47,7 +47,7 @@ async function findOrphanedWorktrees(root: string, db: DatabaseClient): Promise<
 
   try {
     const entries = await fs.readdir(reposDir, { withFileTypes: true });
-    const allAgents = getAllAgents(db.db);
+    const allAgents = await getAllAgents(db.provider);
     const agentWorktrees = new Set(
       allAgents.filter(a => a.worktree_path).map(a => a.worktree_path)
     );
@@ -110,7 +110,7 @@ async function findDeadTmuxSessions(db: DatabaseClient): Promise<string[]> {
 
   try {
     const hiveSessions = await getHiveSessions();
-    const allAgents = getAllAgents(db.db);
+    const allAgents = await getAllAgents(db.provider);
     const agentSessionNames = new Set(
       allAgents.filter(a => a.tmux_session).map(a => a.tmux_session)
     );
@@ -132,9 +132,11 @@ async function findDeadTmuxSessions(db: DatabaseClient): Promise<string[]> {
   return deadSessions;
 }
 
-function findOrphanedAssignments(db: DatabaseClient): Array<{ id: string; agent_id: string }> {
+async function findOrphanedAssignments(
+  db: DatabaseClient
+): Promise<Array<{ id: string; agent_id: string }>> {
   try {
-    return getStoriesWithOrphanedAssignments(db.db);
+    return await getStoriesWithOrphanedAssignments(db.provider);
   } catch (err) {
     console.error(
       chalk.yellow(
@@ -225,11 +227,11 @@ async function cleanupDeadTmuxSessions(deadSessions: string[], dryRun: boolean):
   return cleaned;
 }
 
-function cleanupOrphanedAssignments(
+async function cleanupOrphanedAssignments(
   db: DatabaseClient,
   orphaned: Array<{ id: string; agent_id: string }>,
   dryRun: boolean
-): number {
+): Promise<number> {
   let cleaned = 0;
 
   for (const assignment of orphaned) {
@@ -237,7 +239,7 @@ function cleanupOrphanedAssignments(
       if (dryRun) {
         console.log(chalk.gray(`  Would unassign: ${assignment.id} from ${assignment.agent_id}`));
       } else {
-        updateStoryAssignment(db.db, assignment.id, null);
+        await updateStoryAssignment(db.provider, assignment.id, null);
         console.log(chalk.gray(`  ✓ Unassigned: ${assignment.id}`));
         cleaned++;
       }
@@ -300,7 +302,7 @@ export const cleanupCommand = new Command('cleanup')
           stats.deadTmuxSessions = await findDeadTmuxSessions(db);
         }
         if (shouldCleanupAssignments) {
-          stats.orphanedStories = findOrphanedAssignments(db);
+          stats.orphanedStories = await findOrphanedAssignments(db);
         }
 
         stats.totalIssuesFound =
@@ -395,7 +397,7 @@ export const cleanupCommand = new Command('cleanup')
 
         if (stats.orphanedStories.length > 0) {
           console.log(chalk.cyan('Unassigning orphaned stories:'));
-          const cleaned = cleanupOrphanedAssignments(db, stats.orphanedStories, false);
+          const cleaned = await cleanupOrphanedAssignments(db, stats.orphanedStories, false);
           totalCleaned += cleaned;
           db.save();
           console.log();

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

@@ -16,8 +16,8 @@ vi.mock('../../db/queries/logs.js', () => ({
 }));
 
 vi.mock('../../utils/with-hive-context.js', () => ({
-  withHiveContext: vi.fn(callback => callback({ db: { db: {} } })),
-  withReadOnlyHiveContext: vi.fn(callback => callback({ db: { db: {} } })),
+  withHiveContext: vi.fn(callback => callback({ db: { db: {}, provider: {} } })),
+  withReadOnlyHiveContext: vi.fn(callback => callback({ db: { db: {}, provider: {} } })),
 }));
 
 import { escalationsCommand } from './escalations.js';

package/src/cli/commands/escalations.ts

@@ -21,7 +21,9 @@ escalationsCommand
   .option('--json', 'Output as JSON')
   .action(async (options: { all?: boolean; json?: boolean }) => {
     await withReadOnlyHiveContext(async ({ db }) => {
-      const escalations = options.all ? getAllEscalations(db.db) : getPendingEscalations(db.db);
+      const escalations = options.all
+        ? await getAllEscalations(db.provider)
+        : await getPendingEscalations(db.provider);
 
       if (options.json) {
         console.log(JSON.stringify(escalations, null, 2));
@@ -64,7 +66,7 @@ escalationsCommand
   .description('Show escalation details')
   .action(async (id: string) => {
     await withReadOnlyHiveContext(async ({ db }) => {
-      const escalation = getEscalationById(db.db, id);
+      const escalation = await getEscalationById(db.provider, id);
       if (!escalation) {
         console.error(chalk.red(`Escalation not found: ${id}`));
         process.exit(1);
@@ -95,7 +97,7 @@ escalationsCommand
   .requiredOption('-m, --message <message>', 'Resolution message/guidance')
   .action(async (id: string, options: { message: string }) => {
     await withHiveContext(async ({ db }) => {
-      const escalation = getEscalationById(db.db, id);
+      const escalation = await getEscalationById(db.provider, id);
       if (!escalation) {
         console.error(chalk.red(`Escalation not found: ${id}`));
         process.exit(1);
@@ -106,11 +108,11 @@ escalationsCommand
         return;
       }
 
-      const resolved = resolveEscalation(db.db, id, options.message);
+      const resolved = await resolveEscalation(db.provider, id, options.message);
 
       // Log the resolution
       if (escalation.from_agent_id) {
-        createLog(db.db, {
+        await createLog(db.provider, {
           agentId: escalation.from_agent_id,
           storyId: escalation.story_id,
           eventType: 'ESCALATION_RESOLVED',
@@ -129,7 +131,7 @@ escalationsCommand
   .description('Acknowledge an escalation (mark as being worked on)')
   .action(async (id: string) => {
     await withHiveContext(async ({ db }) => {
-      const escalation = getEscalationById(db.db, id);
+      const escalation = await getEscalationById(db.provider, id);
       if (!escalation) {
         console.error(chalk.red(`Escalation not found: ${id}`));
         process.exit(1);
@@ -140,7 +142,7 @@ escalationsCommand
         return;
       }
 
-      acknowledgeEscalation(db.db, id);
+      await acknowledgeEscalation(db.provider, id);
       console.log(chalk.green(`Escalation ${id} acknowledged.`));
     });
   });

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

@@ -85,5 +85,10 @@ describe('init command', () => {
       const jiraOpt = initCommand.options.find(opt => opt.long === '--jira-project');
       expect(jiraOpt).toBeDefined();
     });
+
+    it('should have --distributed option', () => {
+      const distributedOpt = initCommand.options.find(opt => opt.long === '--distributed');
+      expect(distributedOpt).toBeDefined();
+    });
   });
 });

package/src/cli/commands/init.ts

@@ -3,12 +3,14 @@
 import chalk from 'chalk';
 import { Command } from 'commander';
 import { execa } from 'execa';
-import { existsSync, mkdirSync } from 'fs';
+import { existsSync, mkdirSync, writeFileSync } from 'fs';
+import { nanoid } from 'nanoid';
 import ora from 'ora';
 import { join } from 'path';
 import { createDefaultConfig, loadConfig, saveConfig } from '../../config/loader.js';
 import type { HiveConfig } from '../../config/schema.js';
 import { createDatabase } from '../../db/client.js';
+import { createPostgresProvider } from '../../db/postgres-provider.js';
 import { getHivePaths, isHiveWorkspace } from '../../utils/paths.js';
 import type { AgentRuntime } from '../wizard/init-wizard.js';
 import { runInitWizard } from '../wizard/init-wizard.js';
@@ -23,6 +25,7 @@ export const initCommand = new Command('init')
   .option('--agent-runtime <runtime>', 'Agent runtime (claude, codex)')
   .option('--jira-project <key>', 'Jira project key (for non-interactive mode)')
   .option('--e2e-test-path <path>', 'Path to E2E tests directory')
+  .option('--distributed', 'Use Postgres for distributed multi-workspace mode')
   .action(
     async (options: {
       force?: boolean;
@@ -33,6 +36,7 @@ export const initCommand = new Command('init')
       agentRuntime?: string;
       jiraProject?: string;
       e2eTestPath?: string;
+      distributed?: boolean;
     }) => {
       const rootDir = process.cwd();
       const paths = getHivePaths(rootDir);
@@ -59,10 +63,15 @@ export const initCommand = new Command('init')
         createDefaultConfig(paths.hiveDir);
 
         // Initialize database
-        spinner.text = 'Initializing database...';
-        const db = await createDatabase(paths.dbPath);
-        db.runMigrations();
-        db.close();
+        if (options.distributed) {
+          spinner.text = 'Validating Postgres connection...';
+          await initDistributedDatabase(paths.workspaceIdPath);
+        } else {
+          spinner.text = 'Initializing database...';
+          const db = await createDatabase(paths.dbPath);
+          db.runMigrations();
+          db.close();
+        }
 
         // Initialize git repository if not already in one
         spinner.text = 'Initializing git repository...';
@@ -106,6 +115,9 @@ export const initCommand = new Command('init')
             }
           }
         }
+        if (options.distributed) {
+          config.distributed = true;
+        }
         saveConfig(paths.hiveDir, config);
 
         console.log();
@@ -116,6 +128,11 @@ export const initCommand = new Command('init')
         console.log(chalk.cyan('     hive req "Your requirement here"'));
         console.log(chalk.gray('  3. View dashboard:'));
         console.log(chalk.cyan('     hive dashboard'));
+        if (options.distributed) {
+          console.log();
+          console.log(chalk.gray('  Distributed mode enabled. Database: Postgres'));
+          console.log(chalk.gray(`  Workspace ID stored in: ${paths.workspaceIdPath}`));
+        }
         console.log();
       } catch (err) {
         spinner.fail(chalk.red('Failed to initialize Hive workspace'));
@@ -125,6 +142,37 @@ export const initCommand = new Command('init')
     }
   );
 
+/**
+ * Initialize distributed mode: validate HIVE_DATABASE_URL, test connection,
+ * generate workspace_id, and run Postgres migrations.
+ */
+async function initDistributedDatabase(workspaceIdPath: string): Promise<void> {
+  // Load .env if available
+  try {
+    const dotenv = await import('dotenv');
+    dotenv.config();
+  } catch {
+    // dotenv not available
+  }
+
+  const connectionString = process.env.HIVE_DATABASE_URL;
+  if (!connectionString) {
+    throw new Error(
+      'HIVE_DATABASE_URL environment variable is not set.\n' +
+        'Set it in your environment or in a .env file before running hive init --distributed.\n' +
+        'Example: HIVE_DATABASE_URL=postgres://user:pass@host:5432/hive'
+    );
+  }
+
+  // Generate unique workspace ID
+  const workspaceId = nanoid();
+  writeFileSync(workspaceIdPath, workspaceId, 'utf-8');
+
+  // Test connection and run migrations
+  const provider = await createPostgresProvider(workspaceId);
+  await provider.close();
+}
+
 function applyAgentRuntimePreset(config: HiveConfig, agentRuntime: AgentRuntime): void {
   const provider = agentRuntime === 'codex' ? 'openai' : 'anthropic';
   const cliTool = agentRuntime;

package/src/cli/commands/manager/agent-monitoring.ts

@@ -3,7 +3,7 @@
 import chalk from 'chalk';
 import { randomUUID } from 'crypto';
 import type { HiveConfig } from '../../../config/schema.js';
-import type { getAllAgents } from '../../../db/queries/agents.js';
+import type { AgentRow } from '../../../db/queries/agents.js';
 import { createLog } from '../../../db/queries/logs.js';
 import { getStateDetector, type StateDetectionResult } from '../../../state-detectors/index.js';
 import { AgentState } from '../../../state-detectors/types.js';
@@ -189,7 +189,7 @@ export function describeAgentState(state: AgentState, cliTool: CLITool): string
 
 export function getAgentSafetyMode(
   config: HiveConfig,
-  agent: ReturnType<typeof getAllAgents>[number] | undefined
+  agent: AgentRow | undefined
 ): 'safe' | 'unsafe' {
   if (!agent) return 'unsafe';
   return config.models[agent.type].safety_mode;
@@ -252,7 +252,7 @@ export async function handlePermissionPrompt(
     const approved = await autoApprovePermission(sessionName);
     if (approved) {
       await ctx.withDb(async db => {
-        createLog(db.db, {
+        createLog(db.provider, {
           agentId: 'manager',
           eventType: 'STORY_PROGRESS_UPDATE',
           message: `Auto-approved permission prompt for ${sessionName}`,

package/src/cli/commands/manager/auditor-lifecycle.test.ts

@@ -52,7 +52,14 @@ function makeCtx(
   overrides: Partial<ManagerCheckContext> = {},
   schedulerOverrides: Record<string, unknown> = {}
 ): ManagerCheckContext {
-  const mockDb = { db: {} as never, save: vi.fn(), close: vi.fn(), runMigrations: vi.fn() };
+  const mockProvider = {} as never;
+  const mockDb = {
+    db: {} as never,
+    provider: mockProvider,
+    save: vi.fn(),
+    close: vi.fn(),
+    runMigrations: vi.fn(),
+  };
   const mockScheduler = {
     spawnAuditor: vi.fn().mockResolvedValue({ id: 'auditor-abc123' }),
     ...schedulerOverrides,
@@ -118,8 +125,8 @@ describe('spawnAuditorIfNeeded', () => {
   });
 
   it('spawns auditor when interval elapsed and no active auditor', async () => {
-    mockGetAgentsByType.mockReturnValue([]);
-    mockGetAllTeams.mockReturnValue([{ id: 'team-1', name: 'alpha', repo_path: '/repo' }]);
+    mockGetAgentsByType.mockResolvedValue([]);
+    mockGetAllTeams.mockResolvedValue([{ id: 'team-1', name: 'alpha', repo_path: '/repo' }]);
 
     const ctx = makeCtx();
     const result = await spawnAuditorIfNeeded(ctx);
@@ -135,8 +142,8 @@ describe('spawnAuditorIfNeeded', () => {
   });
 
   it('skips spawn when interval has not elapsed', async () => {
-    mockGetAgentsByType.mockReturnValue([]);
-    mockGetAllTeams.mockReturnValue([{ id: 'team-1', name: 'alpha', repo_path: '/repo' }]);
+    mockGetAgentsByType.mockResolvedValue([]);
+    mockGetAllTeams.mockResolvedValue([{ id: 'team-1', name: 'alpha', repo_path: '/repo' }]);
 
     const ctx = makeCtx();
 
@@ -151,7 +158,7 @@ describe('spawnAuditorIfNeeded', () => {
   });
 
   it('skips spawn when an active auditor is running', async () => {
-    mockGetAgentsByType.mockReturnValue([
+    mockGetAgentsByType.mockResolvedValue([
       { id: 'auditor-existing', type: 'auditor', status: 'working' },
     ]);
 
@@ -166,8 +173,8 @@ describe('spawnAuditorIfNeeded', () => {
   });
 
   it('skips spawn when no teams exist', async () => {
-    mockGetAgentsByType.mockReturnValue([]);
-    mockGetAllTeams.mockReturnValue([]);
+    mockGetAgentsByType.mockResolvedValue([]);
+    mockGetAllTeams.mockResolvedValue([]);
 
     const ctx = makeCtx();
     const result = await spawnAuditorIfNeeded(ctx);
@@ -177,8 +184,8 @@ describe('spawnAuditorIfNeeded', () => {
   });
 
   it('handles spawn errors gracefully', async () => {
-    mockGetAgentsByType.mockReturnValue([]);
-    mockGetAllTeams.mockReturnValue([{ id: 'team-1', name: 'alpha', repo_path: '/repo' }]);
+    mockGetAgentsByType.mockResolvedValue([]);
+    mockGetAllTeams.mockResolvedValue([{ id: 'team-1', name: 'alpha', repo_path: '/repo' }]);
 
     const ctx = makeCtx(
       {},
@@ -193,10 +200,10 @@ describe('spawnAuditorIfNeeded', () => {
   });
 
   it('does not count terminated auditors as active', async () => {
-    mockGetAgentsByType.mockReturnValue([
+    mockGetAgentsByType.mockResolvedValue([
       { id: 'auditor-old', type: 'auditor', status: 'terminated' },
     ]);
-    mockGetAllTeams.mockReturnValue([{ id: 'team-1', name: 'alpha', repo_path: '/repo' }]);
+    mockGetAllTeams.mockResolvedValue([{ id: 'team-1', name: 'alpha', repo_path: '/repo' }]);
 
     const ctx = makeCtx();
     const result = await spawnAuditorIfNeeded(ctx);
@@ -206,8 +213,8 @@ describe('spawnAuditorIfNeeded', () => {
   });
 
   it('updates lastAuditorSpawnTime after successful spawn', async () => {
-    mockGetAgentsByType.mockReturnValue([]);
-    mockGetAllTeams.mockReturnValue([{ id: 'team-1', name: 'alpha', repo_path: '/repo' }]);
+    mockGetAgentsByType.mockResolvedValue([]);
+    mockGetAllTeams.mockResolvedValue([{ id: 'team-1', name: 'alpha', repo_path: '/repo' }]);
 
     expect(getLastAuditorSpawnTime()).toBe(0);
 

package/src/cli/commands/manager/auditor-lifecycle.ts

@@ -55,7 +55,7 @@ export async function spawnAuditorIfNeeded(ctx: ManagerCheckContext): Promise<bo
 
   // Check if a previous auditor is still running
   const hasActiveAuditor = await ctx.withDb(async db => {
-    const auditors = getAgentsByType(db.db, 'auditor');
+    const auditors = await getAgentsByType(db.provider, 'auditor');
     return auditors.some(a => a.status === 'idle' || a.status === 'working');
   });
 
@@ -67,7 +67,7 @@ export async function spawnAuditorIfNeeded(ctx: ManagerCheckContext): Promise<bo
   // Spawn a new auditor agent
   try {
     const agent = await ctx.withDb(async (db, scheduler) => {
-      const teams = getAllTeams(db.db);
+      const teams = await getAllTeams(db.provider);
       if (teams.length === 0) {
         verboseLogCtx(ctx, 'spawnAuditorIfNeeded: skip=no_teams');
         return null;
@@ -76,7 +76,7 @@ export async function spawnAuditorIfNeeded(ctx: ManagerCheckContext): Promise<bo
       const team = teams[0];
       const spawned = await scheduler.spawnAuditor(team.id, team.name, team.repo_path);
 
-      createLog(db.db, {
+      await createLog(db.provider, {
         agentId: spawned.id,
         eventType: 'AGENT_SPAWNED',
         message: `Spawned auditor agent ${spawned.id} for team ${team.name}`,