hungry-ghost-hive 0.48.0 → 0.49.0

package/dist/orchestrator/scheduler.js

@@ -3,7 +3,6 @@ import { join } from 'path';
 import { getCliRuntimeBuilder, resolveRuntimeModelForCli, validateModelCliCompatibility, } from '../cli-runtimes/index.js';
 import { PMOperationQueue } from '../connectors/project-management/operation-queue.js';
 import { createSubtaskForStory, postCommentOnIssue, syncStatusForStory, } from '../connectors/project-management/operations.js';
-import { queryAll, withTransaction } from '../db/client.js';
 import { createAgent, getAgentById, getAgentsByTeam, updateAgent, } from '../db/queries/agents.js';
 import { createEscalation } from '../db/queries/escalations.js';
 import { createLog } from '../db/queries/logs.js';
@@ -41,12 +40,12 @@ const DEFAULT_MAX_QA_AGENTS = 5;
 /** Default manager check interval in seconds */
 const DEFAULT_MANAGER_INTERVAL_SECONDS = 60;
 export class Scheduler {
-    db;
+    provider;
     config;
     saveFn;
     pmQueue;
     constructor(db, config) {
-        this.db = db;
+        this.provider = db;
         this.config = config;
         this.saveFn = config.saveFn;
         this.pmQueue = new PMOperationQueue();
@@ -111,14 +110,14 @@ export class Scheduler {
     /**
      * Remove a git worktree for an agent
      */
-    removeAgentWorktree(worktreePath, agentId) {
+    async removeAgentWorktree(worktreePath, agentId) {
         if (!worktreePath)
             return;
         const result = removeWorktree(this.config.rootDir, worktreePath, {
             timeout: GIT_WORKTREE_REMOVE_TIMEOUT_MS,
         });
         if (!result.success) {
-            createLog(this.db, {
+            await createLog(this.provider, {
                 agentId,
                 eventType: 'WORKTREE_REMOVAL_FAILED',
                 status: 'error',
@@ -134,12 +133,12 @@ export class Scheduler {
      * Assign planned stories to available agents
      */
     async assignStories() {
-        const plannedStories = getPlannedStories(this.db);
+        const plannedStories = await getPlannedStories(this.provider);
         const errors = [];
         let assigned = 0;
         let preventedDuplicates = 0;
         // Topological sort stories to respect dependencies
-        const sortedStories = topologicalSort(this.db, plannedStories);
+        const sortedStories = await topologicalSort(this.provider, plannedStories);
         if (sortedStories === null) {
             errors.push('Circular dependency detected in planned stories');
             return { assigned, errors, preventedDuplicates };
@@ -159,15 +158,15 @@ export class Scheduler {
         }
         // Process each team
         for (const [teamId, stories] of storiesByTeam) {
-            const team = getTeamById(this.db, teamId);
+            const team = await getTeamById(this.provider, teamId);
             if (!team)
                 continue;
             // Get available agents for this team
             // Include agents that are working but have no current story (effectively idle)
-            const agents = getAgentsByTeam(this.db, teamId).filter(a => a.type !== 'qa' &&
+            const agents = (await getAgentsByTeam(this.provider, teamId)).filter(a => a.type !== 'qa' &&
                 a.type !== 'auditor' &&
                 (a.status === 'idle' || (a.status === 'working' && a.current_story_id === null)));
-            const activeSeniors = getAgentsByTeam(this.db, teamId).filter(a => a.type === 'senior' && a.status !== 'terminated');
+            const activeSeniors = (await getAgentsByTeam(this.provider, teamId)).filter(a => a.type === 'senior' && a.status !== 'terminated');
             const seniorSessionPrefix = generateSessionName('senior', team.name, undefined, join(this.config.rootDir, '.hive'));
             const indexedSeniorSessions = activeSeniors
                 .map(senior => {
@@ -209,12 +208,12 @@ export class Scheduler {
                 continue;
             }
             // Assign stories based on complexity and capacity policy
-            const storiesToAssign = selectStoriesForCapacity(stories, this.config.scaling);
+            const storiesToAssign = await selectStoriesForCapacity(stories, this.config.scaling);
             // Separate blocker stories from regular stories
             const blockerStories = [];
             const regularStories = [];
             for (const story of storiesToAssign) {
-                const dependents = getStoriesDependingOn(this.db, story.id);
+                const dependents = await getStoriesDependingOn(this.provider, story.id);
                 if (dependents.length > 0) {
                     blockerStories.push(story);
                 }
@@ -226,10 +225,10 @@ export class Scheduler {
             const orderedStoriesToAssign = [...blockerStories, ...regularStories];
             for (const story of orderedStoriesToAssign) {
                 // Check if story is already assigned (prevent duplicate assignment)
-                const currentStory = getStoryById(this.db, story.id);
+                const currentStory = await getStoryById(this.provider, story.id);
                 if (currentStory && currentStory.assigned_agent_id !== null) {
                     preventedDuplicates++;
-                    createLog(this.db, {
+                    await createLog(this.provider, {
                         agentId: 'scheduler',
                         storyId: story.id,
                         eventType: 'DUPLICATE_ASSIGNMENT_PREVENTED',
@@ -238,11 +237,11 @@ export class Scheduler {
                     continue;
                 }
                 // Check if dependencies are satisfied before assigning
-                if (!areDependenciesSatisfied(this.db, story.id)) {
+                if (!(await areDependenciesSatisfied(this.provider, story.id))) {
                     continue;
                 }
                 // Check if this story is a blocker (has dependents)
-                const dependents = getStoriesDependingOn(this.db, story.id);
+                const dependents = await getStoriesDependingOn(this.provider, story.id);
                 const isBlocker = dependents.length > 0;
                 const complexity = story.complexity_score || 5;
                 let targetAgent;
@@ -254,7 +253,9 @@ export class Scheduler {
                     // Assign to Junior with least workload
                     const juniors = agents.filter(a => a.type === 'junior' && a.status === 'idle');
                     targetAgent =
-                        juniors.length > 0 ? selectAgentWithLeastWorkload(this.db, juniors) : undefined;
+                        juniors.length > 0
+                            ? await selectAgentWithLeastWorkload(this.provider, juniors)
+                            : undefined;
                     if (!targetAgent) {
                         try {
                             targetAgent = await this.spawnJunior(teamId, team.name, team.repo_path);
@@ -265,7 +266,7 @@ export class Scheduler {
                             const intermediates = agents.filter(a => a.type === 'intermediate' && a.status === 'idle');
                             targetAgent =
                                 intermediates.length > 0
-                                    ? selectAgentWithLeastWorkload(this.db, intermediates)
+                                    ? await selectAgentWithLeastWorkload(this.provider, intermediates)
                                     : await getOrSpawnSenior();
                         }
                     }
@@ -275,7 +276,7 @@ export class Scheduler {
                     const intermediates = agents.filter(a => a.type === 'intermediate' && a.status === 'idle');
                     targetAgent =
                         intermediates.length > 0
-                            ? selectAgentWithLeastWorkload(this.db, intermediates)
+                            ? await selectAgentWithLeastWorkload(this.provider, intermediates)
                             : undefined;
                     if (!targetAgent) {
                         try {
@@ -298,25 +299,27 @@ export class Scheduler {
                 }
                 // Assign the story (atomic transaction)
                 try {
-                    await withTransaction(this.db, () => {
-                        updateStory(this.db, story.id, {
+                    await this.provider.withTransaction(async () => {
+                        await updateStory(this.provider, story.id, {
                             assignedAgentId: targetAgent.id,
                             status: 'in_progress',
                         }, this.storiesDir);
-                        updateAgent(this.db, targetAgent.id, {
+                        await updateAgent(this.provider, targetAgent.id, {
                             status: 'working',
                             currentStoryId: story.id,
                         });
                         const message = isBlocker
                             ? `Assigned to ${targetAgent.type} (escalated due to being a dependency blocker)`
                             : `Assigned to ${targetAgent.type}`;
-                        createLog(this.db, {
+                        await createLog(this.provider, {
                             agentId: targetAgent.id,
                             storyId: story.id,
                             eventType: 'STORY_ASSIGNED',
                             message,
                         });
-                    }, this.saveFn);
+                    });
+                    if (this.saveFn)
+                        this.saveFn();
                     assigned++;
                     // Keep local availability snapshot in sync so we don't reassign
                     // additional stories to an agent already marked busy this cycle.
@@ -337,7 +340,7 @@ export class Scheduler {
                         await this.handleJiraAfterAssignment(story, targetAgent, team);
                     });
                     this.pmQueue.enqueue(`story-${story.id}-status-transition`, async () => {
-                        await syncStatusForStory(this.config.rootDir, this.db, story.id, 'in_progress');
+                        await syncStatusForStory(this.config.rootDir, this.provider, story.id, 'in_progress');
                     });
                     // Force an explicit context handoff in the assigned tmux session so
                     // reused sessions do not continue stale prior-story threads.
@@ -370,7 +373,7 @@ export class Scheduler {
         ].join(' ');
         try {
             await sendToTmuxSession(sessionName, handoffMessage);
-            createLog(this.db, {
+            await createLog(this.provider, {
                 agentId: 'scheduler',
                 storyId: story.id,
                 eventType: 'STORY_PROGRESS_UPDATE',
@@ -382,7 +385,7 @@ export class Scheduler {
             });
         }
         catch (err) {
-            createLog(this.db, {
+            await createLog(this.provider, {
                 agentId: 'scheduler',
                 storyId: story.id,
                 eventType: 'STORY_PROGRESS_UPDATE',
@@ -407,7 +410,7 @@ export class Scheduler {
         // Re-fetch the story from DB to get the latest PM data (the passed-in
         // story object may be stale — external_issue_key is set during sync
         // which may have completed after this object was fetched).
-        const freshStory = getStoryById(this.db, story.id);
+        const freshStory = await getStoryById(this.provider, story.id);
         if (!freshStory?.external_issue_key) {
             logger.debug(`Story ${story.id} has no external issue key, skipping subtask creation`);
             return;
@@ -428,7 +431,7 @@ export class Scheduler {
             });
             if (subtask) {
                 // Persist subtask reference back to the story
-                updateStory(this.db, freshStory.id, {
+                await updateStory(this.provider, freshStory.id, {
                     externalSubtaskKey: subtask.key,
                     externalSubtaskId: subtask.id,
                 }, this.storiesDir);
@@ -449,12 +452,12 @@ export class Scheduler {
     /**
      * Get the next story to work on for a specific agent
      */
-    getNextStoryForAgent(agentId) {
-        const agent = getAgentById(this.db, agentId);
+    async getNextStoryForAgent(agentId) {
+        const agent = await getAgentById(this.provider, agentId);
         if (!agent || !agent.team_id)
             return null;
         // Find unassigned planned stories for this team
-        const stories = queryAll(this.db, `
+        const stories = await this.provider.queryAll(`
       SELECT * FROM stories
       WHERE team_id = ?
         AND status = 'planned'
@@ -463,7 +466,7 @@ export class Scheduler {
     `, [agent.team_id]);
         // Filter out stories with unresolved dependencies
         for (const story of stories) {
-            if (areDependenciesSatisfied(this.db, story.id)) {
+            if (await areDependenciesSatisfied(this.provider, story.id)) {
                 return story;
             }
         }
@@ -474,15 +477,21 @@ export class Scheduler {
      * Only spawns agents when there is assignable work (stories with satisfied dependencies)
      */
     async checkScaling() {
-        const teams = getAllTeams(this.db);
+        const teams = await getAllTeams(this.provider);
         for (const team of teams) {
             // Get planned stories for this team
-            const plannedStories = getPlannedStories(this.db).filter(s => s.team_id === team.id);
+            const plannedStories = (await getPlannedStories(this.provider)).filter(s => s.team_id === team.id);
             // Filter to only assignable stories (dependencies satisfied, within refactor capacity)
-            const assignableStories = selectStoriesForCapacity(plannedStories, this.config.scaling).filter(story => areDependenciesSatisfied(this.db, story.id));
+            const capacityStories = selectStoriesForCapacity(plannedStories, this.config.scaling);
+            const assignableStories = [];
+            for (const story of capacityStories) {
+                if (await areDependenciesSatisfied(this.provider, story.id)) {
+                    assignableStories.push(story);
+                }
+            }
             // Count story points only from assignable work
             const assignableStoryPoints = assignableStories.reduce((sum, story) => sum + getCapacityPoints(story), 0);
-            const seniors = getAgentsByTeam(this.db, team.id).filter(a => a.type === 'senior' && a.status !== 'terminated');
+            const seniors = (await getAgentsByTeam(this.provider, team.id)).filter(a => a.type === 'senior' && a.status !== 'terminated');
             // Calculate needed seniors based on assignable work only
             const seniorCapacity = this.config.scaling.senior_capacity;
             const neededSeniors = Math.ceil(assignableStoryPoints / seniorCapacity);
@@ -493,7 +502,7 @@ export class Scheduler {
                 for (let i = 0; i < toSpawn; i++) {
                     try {
                         await this.spawnSenior(team.id, team.name, team.repo_path, currentSeniors + i + 1);
-                        createLog(this.db, {
+                        await createLog(this.provider, {
                             agentId: 'scheduler',
                             eventType: 'TEAM_SCALED_UP',
                             message: `Spawned additional Senior for team ${team.name}`,
@@ -502,7 +511,7 @@ export class Scheduler {
                     }
                     catch (error) {
                         // Log error but continue
-                        createLog(this.db, {
+                        await createLog(this.provider, {
                             agentId: 'scheduler',
                             eventType: 'TEAM_SCALED_UP',
                             status: 'error',
@@ -519,7 +528,7 @@ export class Scheduler {
      * Returns number of agents whose status was corrected
      */
     async healthCheck() {
-        const allAgents = queryAll(this.db, `
+        const allAgents = await this.provider.queryAll(`
       SELECT * FROM agents WHERE status != 'terminated'
     `);
         const liveSessions = await getHiveSessions(join(this.config.rootDir, '.hive'));
@@ -538,12 +547,12 @@ export class Scheduler {
                 if (agent.worktree_path) {
                     this.removeAgentWorktree(agent.worktree_path, agent.id);
                 }
-                updateAgent(this.db, agent.id, {
+                await updateAgent(this.provider, agent.id, {
                     status: 'terminated',
                     currentStoryId: null,
                     worktreePath: null,
                 });
-                createLog(this.db, {
+                await createLog(this.provider, {
                     agentId: agent.id,
                     eventType: 'AGENT_TERMINATED',
                     message: `Session ${agent.tmux_session} no longer running`,
@@ -551,18 +560,18 @@ export class Scheduler {
                 terminated++;
                 // If agent was working on a story, mark it for reassignment
                 if (agent.current_story_id) {
-                    updateStory(this.db, agent.current_story_id, {
+                    await updateStory(this.provider, agent.current_story_id, {
                         status: 'planned',
                         assignedAgentId: null,
                     }, this.storiesDir);
                     revived.push(agent.current_story_id);
                     // Sync status change to Jira (fire and forget)
-                    syncStatusForStory(this.config.rootDir, this.db, agent.current_story_id, 'planned');
+                    syncStatusForStory(this.config.rootDir, this.provider, agent.current_story_id, 'planned');
                 }
             }
         }
         // Detect and recover orphaned stories (assigned to terminated agents)
-        const orphanedRecovered = detectAndRecoverOrphanedStories(this.db, this.config.rootDir, this.storiesDir);
+        const orphanedRecovered = await detectAndRecoverOrphanedStories(this.provider, this.config.rootDir, this.storiesDir);
         return { terminated, revived, orphanedRecovered };
     }
     /**
@@ -570,7 +579,7 @@ export class Scheduler {
      * Scales QA agents based on pending work: 1 QA per 2-3 pending PRs, max 5
      */
     async checkMergeQueue() {
-        const teams = getAllTeams(this.db);
+        const teams = await getAllTeams(this.provider);
         for (const team of teams) {
             await this.scaleQAAgents(team.id, team.name, team.repo_path);
         }
@@ -590,7 +599,7 @@ export class Scheduler {
      */
     async scaleQAAgents(teamId, teamName, repoPath) {
         // Count pending QA work: explicit QA statuses OR any non-merged story with an open PR.
-        const qaStories = queryAll(this.db, `
+        const qaStories = await this.provider.queryAll(`
       SELECT DISTINCT s.* FROM stories s
       LEFT JOIN pull_requests pr ON pr.story_id = s.id
       WHERE s.team_id = ? AND (
@@ -609,7 +618,7 @@ export class Scheduler {
         // If no pending work, scale down to 0 agents
         const neededQAs = pendingCount > 0 ? Math.min(Math.ceil(pendingCount / pendingPerAgent), maxAgents) : 0;
         // Get currently active QA agents for this team
-        const activeQAs = getAgentsByTeam(this.db, teamId).filter(a => a.type === 'qa' && a.status !== 'terminated');
+        const activeQAs = (await getAgentsByTeam(this.provider, teamId)).filter(a => a.type === 'qa' && a.status !== 'terminated');
         const currentQACount = activeQAs.length;
         if (neededQAs > currentQACount) {
             // Scale up: spawn additional QA agents in parallel
@@ -621,7 +630,7 @@ export class Scheduler {
             }
             try {
                 await Promise.all(spawnPromises);
-                createLog(this.db, {
+                await createLog(this.provider, {
                     agentId: 'scheduler',
                     eventType: 'TEAM_SCALED_UP',
                     message: `Scaled QA agents for team ${teamName}: ${currentQACount} → ${neededQAs} (${pendingCount} pending stories)`,
@@ -635,7 +644,7 @@ export class Scheduler {
                 });
             }
             catch (err) {
-                createLog(this.db, {
+                await createLog(this.provider, {
                     agentId: 'scheduler',
                     eventType: 'AGENT_SPAWNED',
                     status: 'error',
@@ -655,7 +664,12 @@ export class Scheduler {
                 return bIndex - aIndex; // Descending order to remove highest indices first
             });
             // Filter out agents that are actively reviewing
-            const terminableAgents = sortedAgents.filter(agent => !isAgentReviewingPR(this.db, agent.id));
+            const terminableAgents = [];
+            for (const agent of sortedAgents) {
+                if (!(await isAgentReviewingPR(this.provider, agent.id))) {
+                    terminableAgents.push(agent);
+                }
+            }
             const qaAgentsToTerminate = terminableAgents.slice(0, toTerminate);
             try {
                 for (const agent of qaAgentsToTerminate) {
@@ -668,20 +682,20 @@ export class Scheduler {
                         this.removeAgentWorktree(agent.worktree_path, agent.id);
                     }
                     // Update database
-                    updateAgent(this.db, agent.id, {
+                    await updateAgent(this.provider, agent.id, {
                         status: 'terminated',
                         currentStoryId: null,
                         worktreePath: null,
                     });
                     // Log the event
-                    createLog(this.db, {
+                    await createLog(this.provider, {
                         agentId: agent.id,
                         eventType: 'AGENT_TERMINATED',
                         message: 'QA agent scaled down due to reduced PR queue',
                         metadata: { teamId, agentType: 'qa', reason: 'queue_shrink', pendingCount },
                     });
                 }
-                createLog(this.db, {
+                await createLog(this.provider, {
                     agentId: 'scheduler',
                     eventType: 'TEAM_SCALED_DOWN',
                     message: `Scaled down QA agents for team ${teamName}: ${currentQACount} → ${neededQAs} (${pendingCount} pending stories)`,
@@ -695,7 +709,7 @@ export class Scheduler {
                 });
             }
             catch (err) {
-                createLog(this.db, {
+                await createLog(this.provider, {
                     agentId: 'scheduler',
                     eventType: 'AGENT_TERMINATED',
                     status: 'error',
@@ -723,7 +737,7 @@ export class Scheduler {
             : generateSessionName(type, teamName, index, hiveDir);
         // Prevent creating duplicate agents on same tmux session (for senior agents)
         if (type === 'senior') {
-            const existingSeniors = getAgentsByTeam(this.db, teamId).filter(a => a.type === 'senior');
+            const existingSeniors = (await getAgentsByTeam(this.provider, teamId)).filter(a => a.type === 'senior');
             const existingOnSession = existingSeniors.find(a => a.tmux_session === sessionName && a.status !== 'terminated');
             if (existingOnSession && (await isTmuxSessionRunning(sessionName))) {
                 const sessionSeniorAvailable = existingOnSession.status === 'idle' ||
@@ -738,7 +752,7 @@ export class Scheduler {
         let modelConfig = this.config.models[type];
         // Override Claude runtime models to Opus 4.6 when godmode is active
         const configuredCliTool = modelConfig.cli_tool || 'claude';
-        if (this.isGodmodeActive() && configuredCliTool === 'claude') {
+        if ((await this.isGodmodeActive()) && configuredCliTool === 'claude') {
             modelConfig = {
                 provider: 'anthropic',
                 model: 'claude-opus-4-6',
@@ -759,10 +773,10 @@ export class Scheduler {
         catch (err) {
             // Create an escalation for human review instead of spawning a broken agent
             const errorMessage = err instanceof Error ? err.message : 'Unknown compatibility error';
-            createEscalation(this.db, {
+            await createEscalation(this.provider, {
                 reason: `Configuration mismatch: Cannot spawn ${type} agent for team ${teamName}. ${errorMessage}`,
             });
-            createLog(this.db, {
+            await createLog(this.provider, {
                 agentId: 'scheduler',
                 eventType: 'AGENT_SPAWN_FAILED',
                 status: 'error',
@@ -778,26 +792,26 @@ export class Scheduler {
             // Throw the error to prevent agent creation
             throw new OperationalError(`Cannot spawn ${type} agent: ${errorMessage}`);
         }
-        const agent = createAgent(this.db, {
+        const agent = await createAgent(this.provider, {
             type,
             teamId,
             model: runtimeModel,
         });
         // Determine the target branch for this team's stories
-        const targetBranch = this.getTargetBranchForTeam(teamId);
+        const targetBranch = await this.getTargetBranchForTeam(teamId);
         // Create git worktree for this agent from the correct base branch
         const worktreePath = await this.createWorktree(agent.id, teamId, repoPath, targetBranch);
         const workDir = `${this.config.rootDir}/${worktreePath}`;
         if (!(await isTmuxSessionRunning(sessionName))) {
             // Build the initial prompt for this agent type
-            const team = getTeamById(this.db, teamId);
+            const team = await getTeamById(this.provider, teamId);
             const includeProgressUpdates = this.shouldIncludeProgressUpdates();
             const hiveDir = join(this.config.rootDir, '.hive');
             const techLeadSession = getTechLeadSessionName(hiveDir);
             const chromeEnabled = this.config.hiveConfig?.agents?.chrome_enabled === true && cliTool === 'claude';
             let prompt;
             if (type === 'senior') {
-                const stories = this.getTeamStories(teamId);
+                const stories = await this.getTeamStories(teamId);
                 prompt = generateSeniorPrompt(teamName, team?.repo_url || '', worktreePath, stories, targetBranch, { includeProgressUpdates, techLeadSession, chromeEnabled }, sessionName);
             }
             else if (type === 'intermediate') {
@@ -834,7 +848,7 @@ export class Scheduler {
             // Auto-start manager when spawning agents
             await this.ensureManagerRunning();
         }
-        updateAgent(this.db, agent.id, {
+        await updateAgent(this.provider, agent.id, {
             tmuxSession: sessionName,
             status: 'idle',
             worktreePath,
@@ -850,8 +864,8 @@ export class Scheduler {
      * Checks requirements directly rather than through stories, so godmode stays
      * active even after stories move from planned to in_progress/review/qa.
      */
-    isGodmodeActive() {
-        const activeRequirements = queryAll(this.db, `SELECT * FROM requirements WHERE status IN ('planning', 'planned', 'in_progress') AND godmode = 1`);
+    async isGodmodeActive() {
+        const activeRequirements = await this.provider.queryAll(`SELECT * FROM requirements WHERE status IN ('planning', 'planned', 'in_progress') AND godmode = 1`);
         return activeRequirements.length > 0;
     }
     /**
@@ -889,12 +903,12 @@ export class Scheduler {
         return this.spawnAgent('senior', teamId, teamName, repoPath, index);
     }
     async spawnIntermediate(teamId, teamName, repoPath) {
-        const existing = getAgentsByTeam(this.db, teamId).filter(a => a.type === 'intermediate');
+        const existing = (await getAgentsByTeam(this.provider, teamId)).filter(a => a.type === 'intermediate');
         const index = existing.length + 1;
         return this.spawnAgent('intermediate', teamId, teamName, repoPath, index);
     }
     async spawnJunior(teamId, teamName, repoPath) {
-        const existing = getAgentsByTeam(this.db, teamId).filter(a => a.type === 'junior');
+        const existing = (await getAgentsByTeam(this.provider, teamId)).filter(a => a.type === 'junior');
         const index = existing.length + 1;
         return this.spawnAgent('junior', teamId, teamName, repoPath, index);
     }
@@ -904,13 +918,13 @@ export class Scheduler {
      * If stories come from multiple requirements with different target branches,
      * use the most common one. Defaults to 'main' if no requirement or target_branch is set.
      */
-    getTargetBranchForTeam(teamId) {
-        const stories = this.getTeamStories(teamId);
+    async getTargetBranchForTeam(teamId) {
+        const stories = await this.getTeamStories(teamId);
         const branchCounts = new Map();
         for (const story of stories) {
             if (!story.requirement_id)
                 continue;
-            const requirement = getRequirementById(this.db, story.requirement_id);
+            const requirement = await getRequirementById(this.provider, story.requirement_id);
             if (!requirement?.target_branch)
                 continue;
             const count = branchCounts.get(requirement.target_branch) || 0;
@@ -929,8 +943,8 @@ export class Scheduler {
         }
         return maxBranch;
     }
-    getTeamStories(teamId) {
-        return queryAll(this.db, `
+    async getTeamStories(teamId) {
+        return this.provider.queryAll(`
       SELECT * FROM stories
       WHERE team_id = ? AND status IN ('planned', 'estimated')
       ORDER BY complexity_score DESC
@@ -949,17 +963,17 @@ export class Scheduler {
      */
     async createFeatureBranchesForPlannedStories(stories, errors) {
         const storyIds = stories.map(s => s.id);
-        const requirementIds = getRequirementsNeedingFeatureBranch(this.db, storyIds, this.config.hiveConfig);
+        const requirementIds = await getRequirementsNeedingFeatureBranch(this.provider, storyIds, this.config.hiveConfig);
         if (requirementIds.length === 0)
             return;
         // Find the repo path from the first team that has stories
         // (all stories for a requirement typically belong to the same repo)
-        const teams = getAllTeams(this.db);
+        const teams = await getAllTeams(this.provider);
         const repoPath = teams.length > 0 ? `${this.config.rootDir}/${teams[0].repo_path}` : null;
         if (!repoPath)
             return;
         for (const reqId of requirementIds) {
-            const branch = await createRequirementFeatureBranch(this.db, repoPath, reqId, this.saveFn);
+            const branch = await createRequirementFeatureBranch(this.provider, repoPath, reqId, this.saveFn);
             if (!branch) {
                 errors.push(`Failed to create feature branch for requirement ${reqId}`);
             }