hungry-ghost-hive 0.3.0

package/src/llm/openai.ts

@@ -0,0 +1,125 @@
+import OpenAI from 'openai';
+import type { LLMProvider, Message, CompletionOptions, CompletionResult } from './provider.js';
+import { withTimeout } from '../utils/timeout.js';
+
+export class OpenAIProvider implements LLMProvider {
+  name = 'openai';
+  private client: OpenAI;
+  private model: string;
+  private defaultMaxTokens: number;
+  private defaultTemperature: number;
+
+  constructor(options: {
+    apiKey?: string;
+    model?: string;
+    maxTokens?: number;
+    temperature?: number;
+  } = {}) {
+    this.client = new OpenAI({
+      apiKey: options.apiKey || process.env.OPENAI_API_KEY,
+    });
+    this.model = options.model || 'gpt-4o-mini';
+    this.defaultMaxTokens = options.maxTokens || 4000;
+    this.defaultTemperature = options.temperature ?? 0.2;
+  }
+
+  async complete(messages: Message[], options?: CompletionOptions): Promise<CompletionResult> {
+    const apiCall = async () => {
+      const response = await this.client.chat.completions.create({
+        model: this.model,
+        max_tokens: options?.maxTokens ?? this.defaultMaxTokens,
+        temperature: options?.temperature ?? this.defaultTemperature,
+        messages: messages.map(m => ({
+          role: m.role,
+          content: m.content,
+        })),
+        stop: options?.stopSequences,
+      });
+
+      const choice = response.choices[0];
+
+      return {
+        content: choice.message.content || '',
+        stopReason: this.mapStopReason(choice.finish_reason),
+        usage: {
+          inputTokens: response.usage?.prompt_tokens || 0,
+          outputTokens: response.usage?.completion_tokens || 0,
+        },
+      };
+    };
+
+    // Apply timeout if specified
+    if (options?.timeoutMs) {
+      return withTimeout(
+        apiCall(),
+        options.timeoutMs,
+        `OpenAI API call timed out after ${options.timeoutMs}ms`
+      );
+    }
+
+    return apiCall();
+  }
+
+  async *streamComplete(messages: Message[], options?: CompletionOptions): AsyncIterable<string> {
+    // Capture instance properties to avoid 'this' binding issues in generator
+    const client = this.client;
+    const model = this.model;
+    const defaultMaxTokens = this.defaultMaxTokens;
+    const defaultTemperature = this.defaultTemperature;
+
+    const streamGenerator = async function* () {
+      const stream = await client.chat.completions.create({
+        model: model,
+        max_tokens: options?.maxTokens ?? defaultMaxTokens,
+        temperature: options?.temperature ?? defaultTemperature,
+        messages: messages.map(m => ({
+          role: m.role,
+          content: m.content,
+        })),
+        stop: options?.stopSequences,
+        stream: true,
+      });
+
+      for await (const chunk of stream) {
+        const delta = chunk.choices[0]?.delta?.content;
+        if (delta) {
+          yield delta;
+        }
+      }
+    };
+
+    // Apply timeout if specified
+    if (options?.timeoutMs) {
+      const timeoutPromise = new Promise<never>((_, reject) => {
+        setTimeout(() => {
+          reject(new Error(`OpenAI streaming API call timed out after ${options.timeoutMs}ms`));
+        }, options.timeoutMs);
+      });
+
+      const generator = streamGenerator();
+
+      while (true) {
+        const result = await Promise.race([
+          generator.next(),
+          timeoutPromise
+        ]);
+
+        if (result.done) break;
+        yield result.value;
+      }
+    } else {
+      yield* streamGenerator();
+    }
+  }
+
+  private mapStopReason(reason: string | null): CompletionResult['stopReason'] {
+    switch (reason) {
+      case 'stop':
+        return 'end_turn';
+      case 'length':
+        return 'max_tokens';
+      default:
+        return 'error';
+    }
+  }
+}

package/src/llm/provider.ts

@@ -0,0 +1,60 @@
+export interface Message {
+  role: 'user' | 'assistant' | 'system';
+  content: string;
+}
+
+export interface CompletionOptions {
+  maxTokens?: number;
+  temperature?: number;
+  stopSequences?: string[];
+  /**
+   * Timeout in milliseconds for this completion request.
+   * If the LLM call doesn't complete within this time, it will be cancelled
+   * and a TimeoutError will be thrown.
+   */
+  timeoutMs?: number;
+}
+
+export interface CompletionResult {
+  content: string;
+  stopReason: 'end_turn' | 'max_tokens' | 'stop_sequence' | 'error';
+  usage: {
+    inputTokens: number;
+    outputTokens: number;
+  };
+}
+
+export interface LLMProvider {
+  name: string;
+  complete(messages: Message[], options?: CompletionOptions): Promise<CompletionResult>;
+  streamComplete?(messages: Message[], options?: CompletionOptions): AsyncIterable<string>;
+}
+
+export type ProviderType = 'anthropic' | 'openai';
+
+export interface ProviderConfig {
+  provider: ProviderType;
+  model: string;
+  maxTokens?: number;
+  temperature?: number;
+}
+
+export function getProviderApiKey(provider: ProviderType): string | undefined {
+  switch (provider) {
+    case 'anthropic':
+      return process.env.ANTHROPIC_API_KEY;
+    case 'openai':
+      return process.env.OPENAI_API_KEY;
+    default:
+      return undefined;
+  }
+}
+
+export function validateProviderConfig(config: ProviderConfig): void {
+  const apiKey = getProviderApiKey(config.provider);
+  if (!apiKey) {
+    throw new Error(
+      `Missing API key for ${config.provider}. Set ${config.provider === 'anthropic' ? 'ANTHROPIC_API_KEY' : 'OPENAI_API_KEY'} environment variable.`
+    );
+  }
+}

package/src/orchestrator/index.ts

@@ -0,0 +1,3 @@
+export * from './workflow.js';
+export { Scheduler, type SchedulerConfig } from './scheduler.js';
+export { Scaler, type ScalerConfig, type ScalingRecommendation } from './scaler.js';

package/src/orchestrator/scaler.ts

@@ -0,0 +1,201 @@
+import type { Database } from 'sql.js';
+import { getStoryPointsByTeam } from '../db/queries/stories.js';
+import { getAgentsByTeam, getTechLead, terminateAgent, type AgentRow } from '../db/queries/agents.js';
+import { getAllTeams, type TeamRow } from '../db/queries/teams.js';
+import { createLog } from '../db/queries/logs.js';
+import { killTmuxSession } from '../tmux/manager.js';
+import type { ScalingConfig } from '../config/schema.js';
+
+export interface ScalerConfig {
+  scaling: ScalingConfig;
+  rootDir: string;
+}
+
+export interface ScalingRecommendation {
+  teamId: string;
+  teamName: string;
+  currentSeniors: number;
+  recommendedSeniors: number;
+  action: 'scale_up' | 'scale_down' | 'none';
+  reason: string;
+}
+
+export class Scaler {
+  private db: Database;
+  private config: ScalerConfig;
+
+  constructor(db: Database, config: ScalerConfig) {
+    this.db = db;
+    this.config = config;
+  }
+
+  /**
+   * Analyze current workload and recommend scaling actions
+   */
+  analyzeScaling(): ScalingRecommendation[] {
+    const teams = getAllTeams(this.db);
+    const recommendations: ScalingRecommendation[] = [];
+
+    for (const team of teams) {
+      const recommendation = this.analyzeTeam(team);
+      recommendations.push(recommendation);
+    }
+
+    return recommendations;
+  }
+
+  private analyzeTeam(team: TeamRow): ScalingRecommendation {
+    const storyPoints = getStoryPointsByTeam(this.db, team.id);
+    const agents = getAgentsByTeam(this.db, team.id);
+    const activeSeniors = agents.filter(
+      a => a.type === 'senior' && a.status !== 'terminated'
+    );
+
+    const seniorCapacity = this.config.scaling.senior_capacity;
+    const recommendedSeniors = Math.max(1, Math.ceil(storyPoints / seniorCapacity));
+    const currentSeniors = activeSeniors.length;
+
+    let action: ScalingRecommendation['action'] = 'none';
+    let reason = '';
+
+    if (recommendedSeniors > currentSeniors) {
+      action = 'scale_up';
+      reason = `${storyPoints} story points exceeds capacity of ${currentSeniors} senior(s) (${currentSeniors * seniorCapacity} points)`;
+    } else if (recommendedSeniors < currentSeniors && currentSeniors > 1) {
+      action = 'scale_down';
+      reason = `Only ${storyPoints} story points, can be handled by ${recommendedSeniors} senior(s)`;
+    } else {
+      reason = `Current capacity is appropriate for ${storyPoints} story points`;
+    }
+
+    return {
+      teamId: team.id,
+      teamName: team.name,
+      currentSeniors,
+      recommendedSeniors,
+      action,
+      reason,
+    };
+  }
+
+  /**
+   * Scale down idle agents when workload decreases
+   */
+  async scaleDown(): Promise<number> {
+    const teams = getAllTeams(this.db);
+    let terminated = 0;
+
+    for (const team of teams) {
+      const storyPoints = getStoryPointsByTeam(this.db, team.id);
+      const agents = getAgentsByTeam(this.db, team.id);
+
+      // Only scale down if no active work
+      if (storyPoints > 0) continue;
+
+      // Find idle agents (except the first Senior)
+      const idleAgents = agents.filter(a =>
+        a.status === 'idle' &&
+        a.type !== 'tech_lead' &&
+        !a.current_story_id
+      );
+
+      // Keep at least one Senior
+      const seniorsToKeep = agents.filter(a => a.type === 'senior' && a.status !== 'terminated')[0];
+
+      for (const agent of idleAgents) {
+        if (agent.type === 'senior' && agent.id === seniorsToKeep?.id) {
+          continue; // Keep the primary Senior
+        }
+
+        await this.terminateAgent(agent);
+        terminated++;
+      }
+    }
+
+    return terminated;
+  }
+
+  private async terminateAgent(agent: AgentRow): Promise<void> {
+    // Kill tmux session if exists
+    if (agent.tmux_session) {
+      await killTmuxSession(agent.tmux_session);
+    }
+
+    // Remove worktree if exists
+    if (agent.worktree_path) {
+      try {
+        const { execSync } = await import('child_process');
+        const fullWorktreePath = `${this.config.rootDir}/${agent.worktree_path}`;
+        execSync(`git worktree remove "${fullWorktreePath}" --force`, {
+          cwd: this.config.rootDir,
+          stdio: 'pipe',
+        });
+      } catch (err) {
+        // Log error but don't throw - worktree might already be removed
+        console.error(`Warning: Failed to remove worktree: ${err instanceof Error ? err.message : 'Unknown error'}`);
+      }
+    }
+
+    // Mark as terminated
+    terminateAgent(this.db, agent.id);
+
+    // Log the event
+    createLog(this.db, {
+      agentId: agent.id,
+      eventType: 'AGENT_TERMINATED',
+      message: 'Scaled down due to reduced workload',
+    });
+  }
+
+  /**
+   * Get scaling statistics
+   */
+  getStatistics(): {
+    totalAgents: number;
+    activeAgents: number;
+    agentsByType: Record<string, number>;
+    teamCapacity: Record<string, { agents: number; storyPoints: number }>;
+  } {
+    const teams = getAllTeams(this.db);
+    const agentsByType: Record<string, number> = {};
+    const teamCapacity: Record<string, { agents: number; storyPoints: number }> = {};
+    let totalAgents = 0;
+    let activeAgents = 0;
+
+    for (const team of teams) {
+      const agents = getAgentsByTeam(this.db, team.id);
+      const storyPoints = getStoryPointsByTeam(this.db, team.id);
+
+      teamCapacity[team.name] = {
+        agents: agents.filter(a => a.status !== 'terminated').length,
+        storyPoints,
+      };
+
+      for (const agent of agents) {
+        if (agent.status === 'terminated') continue;
+        totalAgents++;
+        agentsByType[agent.type] = (agentsByType[agent.type] || 0) + 1;
+        if (agent.status === 'working') {
+          activeAgents++;
+        }
+      }
+    }
+
+    // Add Tech Lead
+    const techLead = getTechLead(this.db);
+    if (techLead && techLead.status !== 'terminated') {
+      totalAgents++;
+      agentsByType['tech_lead'] = 1;
+      if (techLead.status === 'working') {
+        activeAgents++;
+      }
+    }
+
+    return {
+      totalAgents,
+      activeAgents,
+      agentsByType,
+      teamCapacity,
+    };
+  }
+}

package/src/orchestrator/scheduler.test.ts

@@ -0,0 +1,288 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import type { Database } from 'sql.js';
+import initSqlJs from 'sql.js';
+import { Scheduler } from './scheduler.js';
+import { createStory, addStoryDependency, updateStory } from '../db/queries/stories.js';
+import { createTeam } from '../db/queries/teams.js';
+import type { StoryRow } from '../db/queries/stories.js';
+
+let db: Database;
+let scheduler: Scheduler;
+
+const mockConfig = {
+  scaling: {
+    junior_max_complexity: 3,
+    intermediate_max_complexity: 5,
+    senior_capacity: 50,
+  },
+  models: {
+    tech_lead: { provider: 'anthropic', model: 'claude-opus-4-20250514', max_tokens: 16000, temperature: 0.7, cli_tool: 'claude' },
+    senior: { provider: 'anthropic', model: 'claude-sonnet-4-20250514', max_tokens: 8000, temperature: 0.5, cli_tool: 'claude' },
+    intermediate: { provider: 'anthropic', model: 'claude-haiku-3-5-20241022', max_tokens: 4000, temperature: 0.3, cli_tool: 'claude' },
+    junior: { provider: 'openai', model: 'gpt-4o-mini', max_tokens: 4000, temperature: 0.2, cli_tool: 'claude' },
+    qa: { provider: 'anthropic', model: 'claude-sonnet-4-20250514', max_tokens: 8000, temperature: 0.2, cli_tool: 'claude' },
+  },
+  rootDir: '/tmp',
+};
+
+// Migration SQL to initialize database for tests
+const INITIAL_MIGRATION = `
+CREATE TABLE IF NOT EXISTS migrations (
+  id INTEGER PRIMARY KEY AUTOINCREMENT,
+  name TEXT NOT NULL UNIQUE,
+  applied_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS teams (
+    id TEXT PRIMARY KEY,
+    repo_url TEXT NOT NULL,
+    repo_path TEXT NOT NULL,
+    name TEXT NOT NULL,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS agents (
+    id TEXT PRIMARY KEY,
+    type TEXT NOT NULL CHECK (type IN ('tech_lead', 'senior', 'intermediate', 'junior', 'qa')),
+    team_id TEXT REFERENCES teams(id),
+    tmux_session TEXT,
+    model TEXT,
+    status TEXT DEFAULT 'idle' CHECK (status IN ('idle', 'working', 'blocked', 'terminated')),
+    current_story_id TEXT,
+    memory_state TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS stories (
+    id TEXT PRIMARY KEY,
+    requirement_id TEXT,
+    team_id TEXT REFERENCES teams(id),
+    title TEXT NOT NULL,
+    description TEXT NOT NULL,
+    acceptance_criteria TEXT,
+    complexity_score INTEGER CHECK (complexity_score BETWEEN 1 AND 13),
+    story_points INTEGER,
+    status TEXT DEFAULT 'draft' CHECK (status IN (
+        'draft',
+        'estimated',
+        'planned',
+        'in_progress',
+        'review',
+        'qa',
+        'qa_failed',
+        'pr_submitted',
+        'merged'
+    )),
+    assigned_agent_id TEXT REFERENCES agents(id),
+    branch_name TEXT,
+    pr_url TEXT,
+    created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE TABLE IF NOT EXISTS story_dependencies (
+    story_id TEXT REFERENCES stories(id),
+    depends_on_story_id TEXT REFERENCES stories(id),
+    PRIMARY KEY (story_id, depends_on_story_id)
+);
+`;
+
+beforeEach(async () => {
+  const SQL = await initSqlJs();
+  db = new SQL.Database();
+  db.run('PRAGMA foreign_keys = ON');
+  db.run(INITIAL_MIGRATION);
+  db.run("INSERT INTO migrations (name) VALUES ('001-initial.sql')");
+
+  scheduler = new Scheduler(db, mockConfig as any);
+});
+
+describe('Scheduler Topological Sort', () => {
+  it('should handle stories with no dependencies', () => {
+    const team = createTeam(db, { name: 'Test Team', repoUrl: 'https://github.com/test/repo', repoPath: 'test' });
+    const story1 = createStory(db, { teamId: team.id, title: 'Story 1', description: 'Test' });
+    const story2 = createStory(db, { teamId: team.id, title: 'Story 2', description: 'Test' });
+
+    // Mock the private method by accessing it through reflection
+    const sortMethod = (scheduler as any).topologicalSort;
+    const sorted = sortMethod.call(scheduler, [story1, story2]);
+
+    expect(sorted).not.toBeNull();
+    expect(sorted).toHaveLength(2);
+  });
+
+  it('should respect linear dependencies (A -> B -> C)', () => {
+    const team = createTeam(db, { name: 'Test Team', repoUrl: 'https://github.com/test/repo', repoPath: 'test' });
+    const storyA = createStory(db, { teamId: team.id, title: 'Story A', description: 'Test' });
+    const storyB = createStory(db, { teamId: team.id, title: 'Story B', description: 'Test' });
+    const storyC = createStory(db, { teamId: team.id, title: 'Story C', description: 'Test' });
+
+    // B depends on A, C depends on B
+    addStoryDependency(db, storyB.id, storyA.id);
+    addStoryDependency(db, storyC.id, storyB.id);
+
+    const sortMethod = (scheduler as any).topologicalSort;
+    const sorted = sortMethod.call(scheduler, [storyC, storyA, storyB]);
+
+    expect(sorted).not.toBeNull();
+    expect(sorted).toHaveLength(3);
+    // A should come first, then B, then C
+    const ids = sorted!.map((s: StoryRow) => s.id);
+    expect(ids.indexOf(storyA.id)).toBeLessThan(ids.indexOf(storyB.id));
+    expect(ids.indexOf(storyB.id)).toBeLessThan(ids.indexOf(storyC.id));
+  });
+
+  it('should respect diamond dependencies (A -> B, A -> C, B -> D, C -> D)', () => {
+    const team = createTeam(db, { name: 'Test Team', repoUrl: 'https://github.com/test/repo', repoPath: 'test' });
+    const storyA = createStory(db, { teamId: team.id, title: 'Story A', description: 'Test' });
+    const storyB = createStory(db, { teamId: team.id, title: 'Story B', description: 'Test' });
+    const storyC = createStory(db, { teamId: team.id, title: 'Story C', description: 'Test' });
+    const storyD = createStory(db, { teamId: team.id, title: 'Story D', description: 'Test' });
+
+    // B and C depend on A, D depends on both B and C
+    addStoryDependency(db, storyB.id, storyA.id);
+    addStoryDependency(db, storyC.id, storyA.id);
+    addStoryDependency(db, storyD.id, storyB.id);
+    addStoryDependency(db, storyD.id, storyC.id);
+
+    const sortMethod = (scheduler as any).topologicalSort;
+    const sorted = sortMethod.call(scheduler, [storyD, storyB, storyA, storyC]);
+
+    expect(sorted).not.toBeNull();
+    expect(sorted).toHaveLength(4);
+    const ids = sorted!.map((s: StoryRow) => s.id);
+
+    // A should come first
+    expect(ids.indexOf(storyA.id)).toBe(0);
+    // D should come last
+    expect(ids.indexOf(storyD.id)).toBe(3);
+    // B and C should come between A and D
+    expect(ids.indexOf(storyB.id)).toBeGreaterThan(ids.indexOf(storyA.id));
+    expect(ids.indexOf(storyC.id)).toBeGreaterThan(ids.indexOf(storyA.id));
+    expect(ids.indexOf(storyB.id)).toBeLessThan(ids.indexOf(storyD.id));
+    expect(ids.indexOf(storyC.id)).toBeLessThan(ids.indexOf(storyD.id));
+  });
+
+  it('should detect circular dependencies', () => {
+    const team = createTeam(db, { name: 'Test Team', repoUrl: 'https://github.com/test/repo', repoPath: 'test' });
+    const storyA = createStory(db, { teamId: team.id, title: 'Story A', description: 'Test' });
+    const storyB = createStory(db, { teamId: team.id, title: 'Story B', description: 'Test' });
+
+    // Create circular dependency: A -> B -> A
+    addStoryDependency(db, storyB.id, storyA.id);
+    addStoryDependency(db, storyA.id, storyB.id);
+
+    const sortMethod = (scheduler as any).topologicalSort;
+    const sorted = sortMethod.call(scheduler, [storyA, storyB]);
+
+    expect(sorted).toBeNull();
+  });
+});
+
+describe('Scheduler Dependency Satisfaction', () => {
+  it('should consider merged stories as satisfying dependencies', () => {
+    const team = createTeam(db, { name: 'Test Team', repoUrl: 'https://github.com/test/repo', repoPath: 'test' });
+    const depStory = createStory(db, { teamId: team.id, title: 'Dependency', description: 'Test' });
+    const mainStory = createStory(db, { teamId: team.id, title: 'Main Story', description: 'Test' });
+
+    addStoryDependency(db, mainStory.id, depStory.id);
+
+    // Initially, dependencies are not satisfied
+    let isSatisfied = (scheduler as any).areDependenciesSatisfied.call(scheduler, mainStory.id);
+    expect(isSatisfied).toBe(false);
+
+    // Mark dependency as merged
+    updateStory(db, depStory.id, { status: 'merged' });
+    isSatisfied = (scheduler as any).areDependenciesSatisfied.call(scheduler, mainStory.id);
+    expect(isSatisfied).toBe(true);
+  });
+
+  it('should consider in-progress stories as satisfying dependencies', () => {
+    const team = createTeam(db, { name: 'Test Team', repoUrl: 'https://github.com/test/repo', repoPath: 'test' });
+    const depStory = createStory(db, { teamId: team.id, title: 'Dependency', description: 'Test' });
+    const mainStory = createStory(db, { teamId: team.id, title: 'Main Story', description: 'Test' });
+
+    addStoryDependency(db, mainStory.id, depStory.id);
+
+    // Mark dependency as in_progress
+    updateStory(db, depStory.id, { status: 'in_progress' });
+    const isSatisfied = (scheduler as any).areDependenciesSatisfied.call(scheduler, mainStory.id);
+    expect(isSatisfied).toBe(true);
+  });
+
+  it('should not consider planned stories as satisfying dependencies', () => {
+    const team = createTeam(db, { name: 'Test Team', repoUrl: 'https://github.com/test/repo', repoPath: 'test' });
+    const depStory = createStory(db, { teamId: team.id, title: 'Dependency', description: 'Test' });
+    const mainStory = createStory(db, { teamId: team.id, title: 'Main Story', description: 'Test' });
+
+    addStoryDependency(db, mainStory.id, depStory.id);
+
+    // Update main story status to planned (default)
+    updateStory(db, mainStory.id, { status: 'planned' });
+
+    const isSatisfied = (scheduler as any).areDependenciesSatisfied.call(scheduler, mainStory.id);
+    expect(isSatisfied).toBe(false);
+  });
+
+  it('should handle multiple dependencies', () => {
+    const team = createTeam(db, { name: 'Test Team', repoUrl: 'https://github.com/test/repo', repoPath: 'test' });
+    const dep1 = createStory(db, { teamId: team.id, title: 'Dep 1', description: 'Test' });
+    const dep2 = createStory(db, { teamId: team.id, title: 'Dep 2', description: 'Test' });
+    const mainStory = createStory(db, { teamId: team.id, title: 'Main Story', description: 'Test' });
+
+    addStoryDependency(db, mainStory.id, dep1.id);
+    addStoryDependency(db, mainStory.id, dep2.id);
+
+    // Mark only first dependency as merged
+    updateStory(db, dep1.id, { status: 'merged' });
+    let isSatisfied = (scheduler as any).areDependenciesSatisfied.call(scheduler, mainStory.id);
+    expect(isSatisfied).toBe(false);
+
+    // Mark second dependency as merged too
+    updateStory(db, dep2.id, { status: 'merged' });
+    isSatisfied = (scheduler as any).areDependenciesSatisfied.call(scheduler, mainStory.id);
+    expect(isSatisfied).toBe(true);
+  });
+});
+
+describe('Scheduler Build Dependency Graph', () => {
+  it('should correctly build a dependency graph', () => {
+    const team = createTeam(db, { name: 'Test Team', repoUrl: 'https://github.com/test/repo', repoPath: 'test' });
+    const storyA = createStory(db, { teamId: team.id, title: 'Story A', description: 'Test' });
+    const storyB = createStory(db, { teamId: team.id, title: 'Story B', description: 'Test' });
+    const storyC = createStory(db, { teamId: team.id, title: 'Story C', description: 'Test' });
+
+    addStoryDependency(db, storyB.id, storyA.id);
+    addStoryDependency(db, storyC.id, storyA.id);
+
+    const graphMethod = (scheduler as any).buildDependencyGraph;
+    const graph = graphMethod.call(scheduler, [storyA, storyB, storyC]);
+
+    expect(graph.has(storyA.id)).toBe(true);
+    expect(graph.has(storyB.id)).toBe(true);
+    expect(graph.has(storyC.id)).toBe(true);
+
+    expect(graph.get(storyA.id)).toEqual(new Set());
+    expect(graph.get(storyB.id)).toEqual(new Set([storyA.id]));
+    expect(graph.get(storyC.id)).toEqual(new Set([storyA.id]));
+  });
+
+  it('should include only stories in the input list', () => {
+    const team = createTeam(db, { name: 'Test Team', repoUrl: 'https://github.com/test/repo', repoPath: 'test' });
+    const storyA = createStory(db, { teamId: team.id, title: 'Story A', description: 'Test' });
+    const storyB = createStory(db, { teamId: team.id, title: 'Story B', description: 'Test' });
+    const storyC = createStory(db, { teamId: team.id, title: 'Story C', description: 'Test' });
+
+    // B depends on A (A is not in the filter list)
+    addStoryDependency(db, storyB.id, storyA.id);
+
+    const graphMethod = (scheduler as any).buildDependencyGraph;
+    // Only include B and C in the graph
+    const graph = graphMethod.call(scheduler, [storyB, storyC]);
+
+    expect(graph.has(storyB.id)).toBe(true);
+    expect(graph.has(storyC.id)).toBe(true);
+    expect(graph.has(storyA.id)).toBe(false);
+  });
+});