@avi770/testteam 1.2.0

package/core/orchestrator.ts

@@ -0,0 +1,354 @@
+import type { Phase, AgentResult, PhaseGateResult, Finding } from './types';
+import type { ValidatedConfig } from './config';
+import type { BaseAgent } from '../agents/base-agent';
+import { runHealthChecks } from './health-check';
+import type { HealthCheck } from './health-check';
+import { initRunDirectory, writeAgentResult, writeFinding } from './evidence';
+import { classifyFinding } from './fix-loop';
+import { CostTracker } from './cost-tracker';
+import { evaluateGate } from './phase-gate';
+import { getLicenseTier } from './license';
+import type { LicenseTier } from './license';
+import { isAgentAvailable, getAgentTier } from '../agents/registry';
+import { agentGatedMessage, phaseGatedMessage, getAgentDisplayName } from './messages';
+import * as path from 'path';
+
+/** Agent IDs to dispatch per phase, in execution order. */
+const PHASE_DISPATCH: Record<Phase, readonly number[]> = {
+  alpha:   [1, 2, 23, 3, 4, 5],
+  beta:    [5, 6, 7, 8, 12, 13, 14, 15, 16, 18, 19, 21, 22],
+  uat:     [5, 6, 12, 13, 14, 15, 18, 19, 20, 21, 22, 17],
+  release: [10],
+};
+
+/**
+ * Agent IDs that are safe to run in parallel (read-only / non-destructive).
+ * Agents that write data (2, 3, 5, 16) must run sequentially.
+ */
+const PARALLEL_SAFE: ReadonlySet<number> = new Set([
+  6, 7, 8, 12, 13, 14, 15, 18, 19, 21, 22,
+]);
+
+/** Maximum number of fix-loop iterations per phase to prevent infinite heal/fix loops. */
+const MAX_FIX_LOOP_ITERATIONS = 3;
+
+export interface DispatchPlanEntry {
+  agentId: number;
+  status: 'scheduled' | 'disabled' | 'unregistered';
+}
+
+export interface PhaseRunResult {
+  gate: PhaseGateResult;
+  agentResults: Record<number, AgentResult>;
+  skippedAgents: number[];
+  costTracker: CostTracker;
+}
+
+/** Phases available per license tier. */
+const PHASE_ACCESS: Record<LicenseTier, ReadonlySet<Phase>> = {
+  free: new Set<Phase>(['alpha']),
+  pro: new Set<Phase>(['alpha', 'beta', 'uat', 'release']),
+  enterprise: new Set<Phase>(['alpha', 'beta', 'uat', 'release']),
+};
+
+/** Minimum tier required for non-free phases. */
+const PHASE_REQUIRED_TIER: Record<Phase, LicenseTier> = {
+  alpha: 'free',
+  beta: 'pro',
+  uat: 'pro',
+  release: 'pro',
+};
+
+export class Orchestrator {
+  private readonly config: ValidatedConfig;
+  private readonly agents: Map<number, BaseAgent> = new Map();
+  private readonly healthChecks: HealthCheck[] = [];
+  private runDir: string;
+
+  /**
+   * License tier resolver — injectable for testing.
+   * Defaults to `getLicenseTier()` from the license module.
+   */
+  _getLicenseTier: () => LicenseTier = () => getLicenseTier();
+
+  constructor(config: ValidatedConfig, runDir?: string) {
+    this.config = config;
+    this.runDir = runDir ?? path.join(process.cwd(), '.run', `run-${Date.now()}`);
+  }
+
+  /** Register an agent instance for a given agent ID. */
+  registerAgent(agentId: number, agent: BaseAgent): void {
+    this.agents.set(agentId, agent);
+  }
+
+  /** Register health checks to run before agent dispatch. */
+  registerHealthChecks(checks: HealthCheck[]): void {
+    this.healthChecks.push(...checks);
+  }
+
+  /** Return the dispatch plan for a phase without executing anything. */
+  dryRun(phase: Phase): DispatchPlanEntry[] {
+    const agentIds = PHASE_DISPATCH[phase];
+    return agentIds.map(agentId => {
+      if (this.config.disabledAgentSet.has(agentId)) {
+        return { agentId, status: 'disabled' as const };
+      }
+      if (!this.agents.has(agentId)) {
+        return { agentId, status: 'unregistered' as const };
+      }
+      return { agentId, status: 'scheduled' as const };
+    });
+  }
+
+  /** Execute all agents for the given phase, evaluate the gate, and return results. */
+  async runPhase(phase: Phase): Promise<PhaseRunResult> {
+    // Step 0: License-based phase gating
+    const currentTier = this._getLicenseTier();
+    if (!PHASE_ACCESS[currentTier].has(phase)) {
+      const requiredTier = PHASE_REQUIRED_TIER[phase];
+      const message = phaseGatedMessage(phase, requiredTier, currentTier);
+      console.warn(`[Orchestrator] ${message}`);
+
+      // Return empty result with a failed gate
+      const gate: PhaseGateResult = {
+        phase,
+        passed: false,
+        blockingResults: [],
+        advisoryResults: [],
+        failedBlockingAgents: [],
+        timestamp: new Date().toISOString(),
+      };
+      return {
+        gate,
+        agentResults: {},
+        skippedAgents: PHASE_DISPATCH[phase].slice(),
+        costTracker: new CostTracker({
+          maxPerRun: this.config.costBudget.maxPerRun,
+          maxPerAgent: this.config.costBudget.maxPerAgent,
+          alertThreshold: this.config.costBudget.alertThreshold,
+          onExceeded: this.config.costBudget.onExceeded,
+        }),
+      };
+    }
+
+    // Step 1: Health checks
+    if (this.healthChecks.length > 0) {
+      const healthSummary = await runHealthChecks({ checks: this.healthChecks });
+      if (!healthSummary.canProceed) {
+        const failedNames = healthSummary.results
+          .filter(r => r.required && !r.passed)
+          .map(r => r.name)
+          .join(', ');
+        throw new Error(`Health checks failed: ${failedNames}`);
+      }
+    }
+
+    // Step 2: Initialize run directory
+    await initRunDirectory(this.runDir);
+
+    // Step 3: Create cost tracker
+    const costTracker = new CostTracker({
+      maxPerRun: this.config.costBudget.maxPerRun,
+      maxPerAgent: this.config.costBudget.maxPerAgent,
+      alertThreshold: this.config.costBudget.alertThreshold,
+      onExceeded: this.config.costBudget.onExceeded,
+    });
+
+    // Step 4: Dispatch agents
+    const agentIds = PHASE_DISPATCH[phase];
+    const agentResults: Record<number, AgentResult> = {};
+    const skippedAgents: number[] = [];
+
+    let budgetExhausted = false;
+
+    // Build dispatch batches: consecutive parallel-safe agents form a batch;
+    // sequential agents are dispatched alone.
+    const batches: number[][] = [];
+    let currentBatch: number[] = [];
+
+    for (const agentId of agentIds) {
+      if (this.config.disabledAgentSet.has(agentId) || !this.agents.has(agentId)) {
+        // Flush current batch before skipping
+        if (currentBatch.length > 0) {
+          batches.push(currentBatch);
+          currentBatch = [];
+        }
+        skippedAgents.push(agentId);
+        continue;
+      }
+
+      // License-based agent gating
+      if (!isAgentAvailable(agentId, currentTier)) {
+        if (currentBatch.length > 0) {
+          batches.push(currentBatch);
+          currentBatch = [];
+        }
+        const agentName = getAgentDisplayName(agentId);
+        const requiredTier = getAgentTier(agentId);
+        const message = agentGatedMessage(agentId, agentName, requiredTier, currentTier);
+        console.warn(`[Orchestrator] ${message}`);
+
+        // Record a skipped result with an info finding
+        agentResults[agentId] = {
+          agentId,
+          agentName,
+          phase,
+          status: 'skipped',
+          startedAt: new Date().toISOString(),
+          completedAt: new Date().toISOString(),
+          durationMs: 0,
+          findings: [{
+            id: `license-gate-${agentId}`,
+            type: 'infra-issue',
+            severity: 'info',
+            agentId,
+            module: 'license',
+            description: message,
+          }],
+          evidence: [],
+          summary: message,
+        };
+        skippedAgents.push(agentId);
+        continue;
+      }
+
+      if (PARALLEL_SAFE.has(agentId)) {
+        currentBatch.push(agentId);
+      } else {
+        // Flush any accumulated parallel batch first
+        if (currentBatch.length > 0) {
+          batches.push(currentBatch);
+          currentBatch = [];
+        }
+        // Sequential agent: single-element batch
+        batches.push([agentId]);
+      }
+    }
+    // Flush remaining parallel batch
+    if (currentBatch.length > 0) {
+      batches.push(currentBatch);
+    }
+
+    for (const batch of batches) {
+      if (budgetExhausted) {
+        skippedAgents.push(...batch);
+        continue;
+      }
+
+      const runAgent = async (agentId: number): Promise<void> => {
+        const agent = this.agents.get(agentId)!;
+        const result = await agent.run();
+        agentResults[agentId] = result;
+
+        // Track cost (duration-based placeholder: $0.0001 per second)
+        costTracker.trackCost(String(agentId), (result.durationMs / 1000) * 0.0001);
+
+        // Write results to evidence directory
+        await writeAgentResult(this.runDir, agentId, result);
+      };
+
+      if (batch.length === 1) {
+        await runAgent(batch[0]);
+      } else {
+        await Promise.all(batch.map(runAgent));
+      }
+
+      // Enforce cost budget after each batch
+      const budgetCheck = costTracker.checkBudget();
+      if (budgetCheck.status === 'exceeded') {
+        const onExceeded = this.config.costBudget.onExceeded;
+        if (onExceeded === 'abort' || onExceeded === 'skip-remaining') {
+          budgetExhausted = true;
+        } else {
+          console.warn(
+            `[Orchestrator] Cost budget exceeded (total: $${budgetCheck.totalCost.toFixed(4)}) — continuing per alert-continue policy`,
+          );
+        }
+      }
+    }
+
+    // Step 5b: Run fix loop for cross-phase agents (Healer/Fixer)
+    await this.runFixLoop(agentResults, costTracker);
+
+    // Step 6: Evaluate the phase gate
+    const scheduledForPhase = new Set(PHASE_DISPATCH[phase]);
+    const gate = evaluateGate(
+      phase,
+      this.config.agentClassification,
+      agentResults,
+      this.config.disabledAgentSet,
+      scheduledForPhase,
+    );
+
+    return { gate, agentResults, skippedAgents, costTracker };
+  }
+
+  /**
+   * After all phase agents complete, classify findings and dispatch cross-phase
+   * agents on demand:
+   *   - Agent 9 (Healer) for test-bug findings
+   *   - Agent 11 (Fixer) for code-bug findings
+   *
+   * Iterates up to MAX_FIX_LOOP_ITERATIONS times to prevent infinite heal/fix loops.
+   */
+  private async runFixLoop(
+    agentResults: Record<number, AgentResult>,
+    costTracker: CostTracker,
+  ): Promise<void> {
+    for (let iteration = 0; iteration < MAX_FIX_LOOP_ITERATIONS; iteration++) {
+      const allFindings: Finding[] = Object.values(agentResults).flatMap(r => r.findings);
+      if (allFindings.length === 0) return;
+
+      // changedFiles is empty — we don't track VCS changes during a run
+      const changedFiles: string[] = [];
+
+      let hasTestBugs = false;
+      let hasCodeBugs = false;
+
+      for (const finding of allFindings) {
+        const findingType = classifyFinding(finding, changedFiles);
+        await writeFinding(this.runDir, { ...finding, type: findingType });
+
+        if (findingType === 'test-bug') {
+          hasTestBugs = true;
+        } else {
+          hasCodeBugs = true;
+        }
+      }
+
+      let dispatched = false;
+
+      // Dispatch Agent 9 (Healer) for test-bugs
+      if (hasTestBugs) {
+        const healer = this.agents.get(9);
+        if (healer && !this.config.disabledAgentSet.has(9)) {
+          const result = await healer.run();
+          agentResults[9] = result;
+          costTracker.trackCost('9', result.durationMs * 0.001);
+          await writeAgentResult(this.runDir, 9, result);
+          dispatched = true;
+        }
+      }
+
+      // Dispatch Agent 11 (Fixer) for code-bugs
+      if (hasCodeBugs) {
+        const fixer = this.agents.get(11);
+        if (fixer && !this.config.disabledAgentSet.has(11)) {
+          const result = await fixer.run();
+          agentResults[11] = result;
+          costTracker.trackCost('11', result.durationMs * 0.001);
+          await writeAgentResult(this.runDir, 11, result);
+          dispatched = true;
+        }
+      }
+
+      // If no agents were dispatched, no further iterations are needed
+      if (!dispatched) return;
+    }
+  }
+
+  /** Get the run directory path. */
+  getRunDir(): string {
+    return this.runDir;
+  }
+}

package/core/phase-gate.ts

@@ -0,0 +1,55 @@
+import type { Phase, AgentResult, PhaseGateResult } from './types';
+import type { AgentClassificationConfig } from './config';
+
+export function evaluateGate(
+  phase: Phase,
+  classification: AgentClassificationConfig,
+  results: Record<number, AgentResult>,
+  disabledAgents: Set<number> = new Set(),
+  scheduledAgents: Set<number> = new Set(),
+): PhaseGateResult {
+  const failedBlockingAgents: number[] = [];
+  const blockingResults: AgentResult[] = [];
+  const advisoryResults: AgentResult[] = [];
+
+  for (const agentId of classification.blocking) {
+    if (disabledAgents.has(agentId)) {
+      continue;
+    }
+
+    // Only evaluate agents that were actually scheduled for this phase
+    if (scheduledAgents.size > 0 && !scheduledAgents.has(agentId)) {
+      continue;
+    }
+
+    const result = results[agentId];
+
+    if (result === undefined || result.status === 'failed') {
+      failedBlockingAgents.push(agentId);
+    }
+
+    if (result !== undefined) {
+      blockingResults.push(result);
+    }
+  }
+
+  for (const agentId of classification.advisory) {
+    if (disabledAgents.has(agentId)) {
+      continue;
+    }
+
+    const result = results[agentId];
+    if (result !== undefined) {
+      advisoryResults.push(result);
+    }
+  }
+
+  return {
+    phase,
+    passed: failedBlockingAgents.length === 0,
+    blockingResults,
+    advisoryResults,
+    failedBlockingAgents,
+    timestamp: new Date().toISOString(),
+  };
+}