hungry-ghost-hive 0.48.0 → 0.49.0

package/src/cli/commands/manager/spin-down.ts

@@ -2,7 +2,6 @@
 
 import chalk from 'chalk';
 import type { StoryRow } from '../../../db/client.js';
-import { queryAll, withTransaction } from '../../../db/client.js';
 import { getAgentById, updateAgent } from '../../../db/queries/agents.js';
 import { createLog } from '../../../db/queries/logs.js';
 import { updateStoryAssignment } from '../../../db/queries/stories.js';
@@ -18,8 +17,7 @@ function verboseLog(ctx: Pick<ManagerCheckContext, 'verbose'>, message: string):
 export async function spinDownMergedAgents(ctx: ManagerCheckContext): Promise<void> {
   // Phase 1: Read merged stories and determine actions (brief lock)
   const actions = await ctx.withDb(async db => {
-    const mergedStoriesWithAgents = queryAll<StoryRow>(
-      db.db,
+    const mergedStoriesWithAgents = await db.provider.queryAll<StoryRow>(
       `SELECT * FROM stories WHERE status = 'merged' AND assigned_agent_id IS NOT NULL`
     );
     verboseLog(ctx, `spinDownMergedAgents: mergedStories=${mergedStoriesWithAgents.length}`);
@@ -42,7 +40,7 @@ export async function spinDownMergedAgents(ctx: ManagerCheckContext): Promise<vo
     for (const story of mergedStoriesWithAgents) {
       if (!story.assigned_agent_id) continue;
 
-      const agent = getAgentById(db.db, story.assigned_agent_id);
+      const agent = await getAgentById(db.provider, story.assigned_agent_id);
       if (!agent || agent.status === 'terminated') {
         verboseLog(
           ctx,
@@ -53,9 +51,10 @@ export async function spinDownMergedAgents(ctx: ManagerCheckContext): Promise<vo
 
       // Safety: Don't kill agents that are working on other stories
       if (agent.current_story_id && agent.current_story_id !== story.id) {
-        await withTransaction(db.db, () => {
-          updateStoryAssignment(db.db, story.id, null);
+        await db.provider.withTransaction(async () => {
+          await updateStoryAssignment(db.provider, story.id, null);
         });
+        db.save();
         verboseLog(
           ctx,
           `spinDownMergedAgents: story=${story.id} cleared assignment; agent=${agent.id} moved_to=${agent.current_story_id}`
@@ -64,15 +63,15 @@ export async function spinDownMergedAgents(ctx: ManagerCheckContext): Promise<vo
       }
 
       // Check if agent has other non-merged stories assigned
-      const otherActiveStories = queryAll<StoryRow>(
-        db.db,
+      const otherActiveStories = await db.provider.queryAll<StoryRow>(
         `SELECT * FROM stories WHERE assigned_agent_id = ? AND id != ? AND status NOT IN ('merged', 'draft')`,
         [agent.id, story.id]
       );
       if (otherActiveStories.length > 0) {
-        await withTransaction(db.db, () => {
-          updateStoryAssignment(db.db, story.id, null);
+        await db.provider.withTransaction(async () => {
+          await updateStoryAssignment(db.provider, story.id, null);
         });
+        db.save();
         verboseLog(
           ctx,
           `spinDownMergedAgents: story=${story.id} cleared assignment; agent=${agent.id} has_other_active=${otherActiveStories.length}`
@@ -93,19 +92,17 @@ export async function spinDownMergedAgents(ctx: ManagerCheckContext): Promise<vo
     }
 
     // Also find working agents with no current story that have no active stories assigned
-    const orphanedWorkingAgents = queryAll<{
+    const orphanedWorkingAgents = await db.provider.queryAll<{
       id: string;
       tmux_session: string | null;
       type: string;
     }>(
-      db.db,
       `SELECT id, tmux_session, type FROM agents
        WHERE status = 'working' AND current_story_id IS NULL AND type != 'tech_lead'`
     );
 
     for (const agent of orphanedWorkingAgents) {
-      const activeStories = queryAll<StoryRow>(
-        db.db,
+      const activeStories = await db.provider.queryAll<StoryRow>(
         `SELECT * FROM stories WHERE assigned_agent_id = ? AND status NOT IN ('merged', 'draft')`,
         [agent.id]
       );
@@ -150,9 +147,12 @@ export async function spinDownMergedAgents(ctx: ManagerCheckContext): Promise<vo
   if (spindownActions.length > 0) {
     await ctx.withDb(async db => {
       for (const action of spindownActions) {
-        await withTransaction(db.db, () => {
-          updateAgent(db.db, action.agentId, { status: 'terminated', currentStoryId: null });
-          createLog(db.db, {
+        await db.provider.withTransaction(async () => {
+          await updateAgent(db.provider, action.agentId, {
+            status: 'terminated',
+            currentStoryId: null,
+          });
+          await createLog(db.provider, {
             agentId: action.agentId,
             storyId: action.storyId || undefined,
             eventType: 'AGENT_TERMINATED',
@@ -161,7 +161,7 @@ export async function spinDownMergedAgents(ctx: ManagerCheckContext): Promise<vo
               : `Agent spun down: status was working with no current story and no active stories`,
           });
           if (action.storyId) {
-            updateStoryAssignment(db.db, action.storyId, null);
+            await updateStoryAssignment(db.provider, action.storyId, null);
           }
         });
         verboseLog(
@@ -181,8 +181,7 @@ export async function spinDownMergedAgents(ctx: ManagerCheckContext): Promise<vo
 export async function spinDownIdleAgents(ctx: ManagerCheckContext): Promise<void> {
   // Phase 1: Read agent state (brief lock)
   const workingAgents = await ctx.withDb(async db => {
-    const activeStories = queryAll<StoryRow>(
-      db.db,
+    const activeStories = await db.provider.queryAll<StoryRow>(
       `SELECT * FROM stories WHERE status IN ('planned', 'in_progress', 'review', 'qa', 'qa_failed', 'pr_submitted')`
     );
     verboseLog(ctx, `spinDownIdleAgents: activeStories=${activeStories.length}`);
@@ -192,8 +191,11 @@ export async function spinDownIdleAgents(ctx: ManagerCheckContext): Promise<void
       return [];
     }
 
-    const agents = queryAll<{ id: string; tmux_session: string | null; type: string }>(
-      db.db,
+    const agents = await db.provider.queryAll<{
+      id: string;
+      tmux_session: string | null;
+      type: string;
+    }>(
       `SELECT id, tmux_session, type FROM agents WHERE status = 'working' AND type != 'tech_lead'`
     );
     verboseLog(ctx, `spinDownIdleAgents: workingAgents=${agents.length}`);
@@ -218,9 +220,9 @@ export async function spinDownIdleAgents(ctx: ManagerCheckContext): Promise<void
   // Phase 3: DB writes (brief lock)
   await ctx.withDb(async db => {
     for (const agent of workingAgents) {
-      await withTransaction(db.db, () => {
-        updateAgent(db.db, agent.id, { status: 'terminated', currentStoryId: null });
-        createLog(db.db, {
+      await db.provider.withTransaction(async () => {
+        await updateAgent(db.provider, agent.id, { status: 'terminated', currentStoryId: null });
+        await createLog(db.provider, {
           agentId: agent.id,
           eventType: 'AGENT_TERMINATED',
           message: 'Agent spun down - no work remaining in pipeline',

package/src/cli/commands/manager/stale-escalations.ts

@@ -1,9 +1,8 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
-import type { EscalationRow } from '../../../db/client.js';
-import type { getAllAgents } from '../../../db/queries/agents.js';
+import type { AgentRow, EscalationRow } from '../../../db/client.js';
 
-type AgentRecord = ReturnType<typeof getAllAgents>[number];
+type AgentRecord = AgentRow;
 
 export interface FindStaleSessionEscalationsInput {
   pendingEscalations: EscalationRow[];

package/src/cli/commands/manager/stuck-story-helpers.ts

@@ -106,13 +106,13 @@ export async function applyHumanInterventionStateOverride(
       ? null
       : await ctx.withDb(async db => {
           return (
-            (agentId ? getActiveEscalationsForAgent(db.db, agentId) : []).find(
+            (agentId ? await getActiveEscalationsForAgent(db.provider, agentId) : []).find(
               escalation =>
                 escalation.story_id === storyId &&
                 (escalation.reason.startsWith(CLASSIFIER_TIMEOUT_REASON_PREFIX) ||
                   escalation.reason.startsWith(AI_DONE_FALSE_REASON_PREFIX))
             ) ??
-            getPendingEscalations(db.db).find(
+            (await getPendingEscalations(db.provider)).find(
               escalation =>
                 escalation.story_id === storyId &&
                 (escalation.reason.startsWith(CLASSIFIER_TIMEOUT_REASON_PREFIX) ||
@@ -158,16 +158,16 @@ export async function markClassifierTimeoutForHumanIntervention(
 
   await ctx.withDb(async db => {
     const activeTimeoutEscalation = (
-      agentId ? getActiveEscalationsForAgent(db.db, agentId) : []
+      agentId ? await getActiveEscalationsForAgent(db.provider, agentId) : []
     ).some(escalation => escalation.reason.startsWith(CLASSIFIER_TIMEOUT_REASON_PREFIX));
     if (!activeTimeoutEscalation) {
-      const escalation = createEscalation(db.db, {
+      const escalation = await createEscalation(db.provider, {
         storyId,
         fromAgentId: agentId,
         toAgentId: null,
         reason: escalationReason,
       });
-      createLog(db.db, {
+      await createLog(db.provider, {
         agentId: 'manager',
         storyId,
         eventType: 'ESCALATION_CREATED',
@@ -213,17 +213,17 @@ export async function markDoneFalseForHumanIntervention(
   });
 
   await ctx.withDb(async db => {
-    const hasActiveEscalation = (agentId ? getActiveEscalationsForAgent(db.db, agentId) : []).some(
-      escalation => escalation.reason.startsWith(AI_DONE_FALSE_REASON_PREFIX)
-    );
+    const hasActiveEscalation = (
+      agentId ? await getActiveEscalationsForAgent(db.provider, agentId) : []
+    ).some(escalation => escalation.reason.startsWith(AI_DONE_FALSE_REASON_PREFIX));
     if (!hasActiveEscalation) {
-      const escalation = createEscalation(db.db, {
+      const escalation = await createEscalation(db.provider, {
         storyId,
         fromAgentId: agentId,
         toAgentId: null,
         reason: escalationReason,
       });
-      createLog(db.db, {
+      await createLog(db.provider, {
         agentId: 'manager',
         storyId,
         eventType: 'ESCALATION_CREATED',

package/src/cli/commands/manager/stuck-story-processor.ts

@@ -5,8 +5,8 @@ import { execa } from 'execa';
 import { join } from 'path';
 import { syncStatusForStory } from '../../../connectors/project-management/operations.js';
 import type { StoryRow } from '../../../db/client.js';
-import { queryAll, withTransaction } from '../../../db/client.js';
-import { getAgentById, type getAllAgents } from '../../../db/queries/agents.js';
+import type { AgentRow } from '../../../db/queries/agents.js';
+import { getAgentById } from '../../../db/queries/agents.js';
 import { createLog } from '../../../db/queries/logs.js';
 import {
   createPullRequest,
@@ -52,12 +52,13 @@ export async function nudgeStuckStories(ctx: ManagerCheckContext): Promise<void>
 
   // Phase 1: Read stuck stories and agents (brief lock)
   const candidates = await ctx.withDb(async db => {
-    const stuckStories = queryAll<StoryRow>(
-      db.db,
-      `SELECT * FROM stories
+    const stuckStories = (
+      await db.provider.queryAll<StoryRow>(
+        `SELECT * FROM stories
        WHERE status = 'in_progress'
        AND updated_at < ?`,
-      [staleUpdatedAt]
+        [staleUpdatedAt]
+      )
     ).filter(story => !['merged', 'completed'].includes(story.status));
     verboseLogCtx(
       ctx,
@@ -66,7 +67,7 @@ export async function nudgeStuckStories(ctx: ManagerCheckContext): Promise<void>
 
     const result: Array<{
       story: StoryRow;
-      agent: ReturnType<typeof getAllAgents>[number];
+      agent: AgentRow;
       sessionName: string;
       cliTool: CLITool;
     }> = [];
@@ -77,7 +78,7 @@ export async function nudgeStuckStories(ctx: ManagerCheckContext): Promise<void>
         verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} skip=no_assigned_agent`);
         continue;
       }
-      const agent = getAgentById(db.db, story.assigned_agent_id);
+      const agent = await getAgentById(db.provider, story.assigned_agent_id);
       if (!agent) {
         verboseLogCtx(ctx, `nudgeStuckStories: story=${story.id} skip=missing_agent`);
         continue;
@@ -331,7 +332,7 @@ export async function nudgeStuckStories(ctx: ManagerCheckContext): Promise<void>
 export async function autoProgressDoneStory(
   ctx: ManagerCheckContext,
   story: StoryRow,
-  agent: ReturnType<typeof getAllAgents>[number],
+  agent: AgentRow,
   sessionName: string,
   reason: string,
   confidence: number
@@ -348,12 +349,12 @@ export async function autoProgressDoneStory(
 
   // DB operations under brief lock
   const action = await ctx.withDb(async (db, scheduler) => {
-    const openPRs = getOpenPullRequestsByStory(db.db, story.id);
+    const openPRs = await getOpenPullRequestsByStory(db.provider, story.id);
     verboseLogCtx(ctx, `autoProgressDoneStory: story=${story.id}, openPRs=${openPRs.length}`);
     if (openPRs.length > 0) {
       if (story.status !== 'pr_submitted') {
-        updateStory(db.db, story.id, { status: 'pr_submitted' });
-        createLog(db.db, {
+        await updateStory(db.provider, story.id, { status: 'pr_submitted' });
+        await createLog(db.provider, {
           agentId: 'manager',
           storyId: story.id,
           eventType: 'STORY_PROGRESS_UPDATE',
@@ -367,7 +368,7 @@ export async function autoProgressDoneStory(
           },
         });
         db.save();
-        await syncStatusForStory(ctx.root, db.db, story.id, 'pr_submitted');
+        await syncStatusForStory(ctx.root, db.provider, story.id, 'pr_submitted');
         verboseLogCtx(ctx, `autoProgressDoneStory: story=${story.id} status moved to pr_submitted`);
       }
       return 'existing_pr' as const;
@@ -378,33 +379,30 @@ export async function autoProgressDoneStory(
       return 'no_branch' as const;
     }
 
-    await withTransaction(
-      db.db,
-      () => {
-        updateStory(db.db, story.id, { status: 'pr_submitted', branchName: branch });
-        createPullRequest(db.db, {
-          storyId: story.id,
-          teamId: story.team_id || null,
-          branchName: branch,
-          submittedBy: sessionName,
-        });
-        createLog(db.db, {
-          agentId: 'manager',
-          storyId: story.id,
-          eventType: 'PR_SUBMITTED',
-          message: `Auto-submitted PR for ${story.id} after AI completion inference`,
-          metadata: {
-            session_name: sessionName,
-            recovery: 'done_inference_auto_submit',
-            reason,
-            confidence,
-            branch,
-          },
-        });
-      },
-      () => db.save()
-    );
-    await syncStatusForStory(ctx.root, db.db, story.id, 'pr_submitted');
+    await db.provider.withTransaction(async () => {
+      await updateStory(db.provider, story.id, { status: 'pr_submitted', branchName: branch });
+      await createPullRequest(db.provider, {
+        storyId: story.id,
+        teamId: story.team_id || null,
+        branchName: branch,
+        submittedBy: sessionName,
+      });
+      await createLog(db.provider, {
+        agentId: 'manager',
+        storyId: story.id,
+        eventType: 'PR_SUBMITTED',
+        message: `Auto-submitted PR for ${story.id} after AI completion inference`,
+        metadata: {
+          session_name: sessionName,
+          recovery: 'done_inference_auto_submit',
+          reason,
+          confidence,
+          branch,
+        },
+      });
+    });
+    db.save();
+    await syncStatusForStory(ctx.root, db.provider, story.id, 'pr_submitted');
     await scheduler.checkMergeQueue();
     db.save();
     verboseLogCtx(
@@ -440,7 +438,7 @@ export async function autoProgressDoneStory(
 async function resolveStoryBranchName(
   root: string,
   story: StoryRow,
-  agent: ReturnType<typeof getAllAgents>[number],
+  agent: AgentRow,
   log?: (message: string) => void
 ): Promise<string | null> {
   if (story.branch_name && story.branch_name.trim().length > 0) {
@@ -472,7 +470,7 @@ async function resolveStoryBranchName(
 export async function nudgeQAFailedStories(ctx: ManagerCheckContext): Promise<void> {
   // Phase 1: Read QA-failed stories and agents (brief lock)
   const candidates = await ctx.withDb(async db => {
-    const qaFailedStories = getStoriesByStatus(db.db, 'qa_failed').filter(
+    const qaFailedStories = (await getStoriesByStatus(db.provider, 'qa_failed')).filter(
       story => !['merged', 'completed'].includes(story.status)
     );
     verboseLogCtx(ctx, `nudgeQAFailedStories: candidates=${qaFailedStories.length}`);
@@ -483,7 +481,7 @@ export async function nudgeQAFailedStories(ctx: ManagerCheckContext): Promise<vo
         verboseLogCtx(ctx, `nudgeQAFailedStories: story=${story.id} skip=no_assigned_agent`);
         continue;
       }
-      const agent = getAgentById(db.db, story.assigned_agent_id);
+      const agent = await getAgentById(db.provider, story.assigned_agent_id);
       if (!agent || agent.status !== 'working') {
         verboseLogCtx(
           ctx,
@@ -538,8 +536,7 @@ hive pr queue`
 
 export async function recoverUnassignedQAFailedStories(ctx: ManagerCheckContext): Promise<void> {
   const result = await ctx.withDb(async (db, scheduler) => {
-    const recoverableStories = queryAll<StoryRow>(
-      db.db,
+    const recoverableStories = await db.provider.queryAll<StoryRow>(
       `
       SELECT * FROM stories
       WHERE status = 'qa_failed'
@@ -550,25 +547,22 @@ export async function recoverUnassignedQAFailedStories(ctx: ManagerCheckContext)
     if (recoverableStories.length === 0) return null;
     verboseLogCtx(ctx, `recoverUnassignedQAFailedStories: recovered=${recoverableStories.length}`);
 
-    await withTransaction(
-      db.db,
-      () => {
-        for (const story of recoverableStories) {
-          updateStory(db.db, story.id, { status: 'planned', assignedAgentId: null });
-          createLog(db.db, {
-            agentId: 'manager',
-            storyId: story.id,
-            eventType: 'ORPHANED_STORY_RECOVERED',
-            message: `Recovered QA-failed story ${story.id} (unassigned) back to planned`,
-            metadata: { from_status: 'qa_failed', to_status: 'planned' },
-          });
-        }
-      },
-      () => db.save()
-    );
+    await db.provider.withTransaction(async () => {
+      for (const story of recoverableStories) {
+        await updateStory(db.provider, story.id, { status: 'planned', assignedAgentId: null });
+        await createLog(db.provider, {
+          agentId: 'manager',
+          storyId: story.id,
+          eventType: 'ORPHANED_STORY_RECOVERED',
+          message: `Recovered QA-failed story ${story.id} (unassigned) back to planned`,
+          metadata: { from_status: 'qa_failed', to_status: 'planned' },
+        });
+      }
+    });
+    db.save();
 
     for (const story of recoverableStories) {
-      await syncStatusForStory(ctx.root, db.db, story.id, 'planned');
+      await syncStatusForStory(ctx.root, db.provider, story.id, 'planned');
     }
 
     // Proactively re-assign recovered work so it does not stall until manual `hive assign`.

package/src/cli/commands/manager/tech-lead-lifecycle.ts

@@ -33,7 +33,7 @@ export async function restartStaleTechLead(ctx: ManagerCheckContext): Promise<vo
 
   // Phase 1: Read tech lead agents (brief lock)
   const techLeads = await ctx.withDb(async db => {
-    const leads = getAgentsByType(db.db, 'tech_lead');
+    const leads = await getAgentsByType(db.provider, 'tech_lead');
     verboseLogCtx(ctx, `restartStaleTechLead: found ${leads.length} tech lead agent(s)`);
     return leads.map(tl => ({
       id: tl.id,
@@ -139,10 +139,10 @@ export async function restartStaleTechLead(ctx: ManagerCheckContext): Promise<vo
 
     // Look up active requirement and teams to provide context to the restarted tech lead
     const initialPrompt = await ctx.withDb(async db => {
-      const planningReqs = getRequirementsByStatus(db.db, 'planning');
-      const inProgressReqs = getRequirementsByStatus(db.db, 'in_progress');
+      const planningReqs = await getRequirementsByStatus(db.provider, 'planning');
+      const inProgressReqs = await getRequirementsByStatus(db.provider, 'in_progress');
       const activeReq = planningReqs[0] ?? inProgressReqs[0] ?? null;
-      const teams = getAllTeams(db.db);
+      const teams = await getAllTeams(db.provider);
 
       if (activeReq) {
         return generateTechLeadPrompt(
@@ -185,7 +185,7 @@ hive msg inbox ${techLeadInbox}
 
     // DB writes under brief lock
     await ctx.withDb(async db => {
-      createLog(db.db, {
+      await createLog(db.provider, {
         agentId: 'manager',
         eventType: 'AGENT_SPAWNED',
         status: 'info',
@@ -198,7 +198,7 @@ hive msg inbox ${techLeadInbox}
           restart_reason: 'context_freshness',
         },
       });
-      updateAgent(db.db, techLead.id, {
+      await updateAgent(db.provider, techLead.id, {
         status: 'working',
         createdAt: new Date().toISOString(),
       });

package/src/cli/commands/manager/types.ts

@@ -1,8 +1,7 @@
 // Licensed under the Hungry Ghost Hive License. See LICENSE.
 
 import type { HiveConfig } from '../../../config/schema.js';
-import type { DatabaseClient, StoryRow } from '../../../db/client.js';
-import type { getAllAgents } from '../../../db/queries/agents.js';
+import type { AgentRow, DatabaseClient, StoryRow } from '../../../db/client.js';
 import type { MessageRow } from '../../../db/queries/messages.js';
 import type { Scheduler } from '../../../orchestrator/scheduler.js';
 import type { TmuxSession } from '../../../tmux/manager.js';
@@ -86,7 +85,7 @@ export interface ManagerCheckContext {
   };
   // Shared state for dedup
   escalatedSessions: Set<string | null>;
-  agentsBySessionName: Map<string, ReturnType<typeof getAllAgents>[number]>;
+  agentsBySessionName: Map<string, AgentRow>;
   messagesToMarkRead: string[];
 }
 

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

@@ -10,8 +10,8 @@ vi.mock('../../db/client.js', () => ({
 }));
 
 vi.mock('../../utils/with-hive-context.js', () => ({
-  withHiveContext: vi.fn(callback => callback({ db: { db: {}, save: vi.fn() } })),
-  withReadOnlyHiveContext: vi.fn(callback => callback({ db: { db: {} } })),
+  withHiveContext: vi.fn(callback => callback({ db: { db: {}, provider: {}, save: vi.fn() } })),
+  withReadOnlyHiveContext: vi.fn(callback => callback({ db: { db: {}, provider: {} } })),
 }));
 
 import { msgCommand } from './msg.js';

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

@@ -24,8 +24,10 @@ vi.mock('../../integrations/jira/transitions.js', () => ({
 }));
 
 vi.mock('../../utils/with-hive-context.js', () => ({
-  withHiveContext: vi.fn(callback => callback({ db: { db: {}, save: vi.fn() }, root: '/tmp' })),
-  withReadOnlyHiveContext: vi.fn(callback => callback({ db: { db: {} } })),
+  withHiveContext: vi.fn(callback =>
+    callback({ db: { db: {}, provider: {}, save: vi.fn() }, root: '/tmp' })
+  ),
+  withReadOnlyHiveContext: vi.fn(callback => callback({ db: { db: {}, provider: {} } })),
 }));
 
 import { myStoriesCommand } from './my-stories.js';