@avi770/testteam 1.2.0 → 3.0.0

package/agents/__tests__/70-complexity-analyzer.test.ts

@@ -0,0 +1,177 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { ValidatedConfig } from '../../core/config';
+import type { Phase } from '../../core/types';
+
+function makeConfig(overrides: Partial<ValidatedConfig> = {}): ValidatedConfig {
+  return {
+    schemaVersion: 1, name: 'test',
+    projectRoot: '/fake/project',
+    auth: { loginUrl: '/login', credentials: { admin: { email: 'a@t.com', password: 's' } } },
+    modules: [{ id: 'dashboard', route: '/dashboard', sidebarIcon: true }],
+    environments: { alpha: { baseUrl: 'http://localhost:3000', seed: false } },
+    portals: [], breakpoints: [], integrations: [], workers: [], workflows: [],
+    accuracy: { enabled: false, decimalPrecision: 2, currencySymbol: '$', timezone: 'UTC' },
+    tenancy: { enabled: false, isolationField: 'firmId', testFirms: [] },
+    costBudget: { maxPerRun: 100, maxPerAgent: 10, alertThreshold: 0.8, onExceeded: 'abort' },
+    agentClassification: { blocking: [], advisory: [] },
+    thresholds: { unitCoverage: { lines: 80, functions: 80, branches: 80, statements: 80 }, lighthouse: { accessibility: 90, performance: 90, bestPractices: 90, seo: 90 }, apiResponseTime: 2000, bundleSizeLimit: 500000, maxConsoleErrors: 0 },
+    disabledAgents: [], disabledAgentSet: new Set<number>(),
+    ...overrides,
+  };
+}
+
+const fetchMock = vi.fn().mockResolvedValue({ ok: true, status: 200 });
+vi.stubGlobal('fetch', fetchMock);
+
+vi.mock('../../helpers/navigation', () => ({
+  login: vi.fn().mockResolvedValue(undefined),
+  waitForSectionLoad: vi.fn().mockResolvedValue(undefined),
+  navigateToSection: vi.fn().mockResolvedValue(undefined),
+  switchPortal: vi.fn().mockResolvedValue(undefined),
+}));
+
+const existsSyncMock = vi.fn();
+const readFileSyncMock = vi.fn();
+const readdirSyncMock = vi.fn();
+
+vi.mock('node:fs', () => ({
+  existsSync: (...args: unknown[]) => existsSyncMock(...args),
+  readFileSync: (...args: unknown[]) => readFileSyncMock(...args),
+  readdirSync: (...args: unknown[]) => readdirSyncMock(...args),
+}));
+
+const { ComplexityAnalyzerAgent } = await import('../70-complexity-analyzer');
+
+function createAgent(config: ValidatedConfig = makeConfig(), phase: Phase = 'beta') {
+  return new ComplexityAnalyzerAgent(config, phase, '/tmp/test-run');
+}
+
+describe('ComplexityAnalyzerAgent', () => {
+  beforeEach(() => {
+    existsSyncMock.mockReset().mockReturnValue(true);
+    readFileSyncMock.mockReset();
+    readdirSyncMock.mockReset();
+  });
+
+  it('has agentId 70 and correct name', () => {
+    const agent = createAgent();
+    expect(agent.agentId).toBe(70);
+    expect(agent.agentName).toBe('Complexity Analyzer');
+  });
+
+  it('reports no src dir', async () => {
+    existsSyncMock.mockReturnValue(false);
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('no-src-dir'));
+    expect(finding).toBeDefined();
+  });
+
+  it('reports files over 500 lines as low', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'big.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue(Array(600).fill('const x = 1;').join('\n'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('long-file'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('low');
+  });
+
+  it('reports files over 1000 lines as medium', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'huge.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue(Array(1100).fill('const x = 1;').join('\n'));
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('very-long-file'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('medium');
+  });
+
+  it('reports complex functions with >15 branches', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'complex.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    const branches = Array(20).fill('  if (x) { y++; }').join('\n');
+    readFileSyncMock.mockReturnValue(`function complexFn() {\n${branches}\n}`);
+    const agent = createAgent();
+    const result = await agent.run();
+    const finding = result.findings.find(f => f.id.includes('complex-function'));
+    expect(finding).toBeDefined();
+    expect(finding!.severity).toBe('medium');
+  });
+
+  it('no findings for simple code', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'simple.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue('function simple() {\n  return 1;\n}');
+    const agent = createAgent();
+    const result = await agent.run();
+    const complexFinding = result.findings.find(f => f.id.includes('complex-function'));
+    expect(complexFinding).toBeUndefined();
+  });
+
+  it('skips test files', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'app.test.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.status).toBeDefined();
+  });
+
+  it('limits complex function findings to 10', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'complex.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    const funcs = Array.from({ length: 15 }, (_, i) => {
+      const branches = Array(20).fill('  if (x) { y++; }').join('\n');
+      return `function fn${i}() {\n${branches}\n}`;
+    }).join('\n');
+    readFileSyncMock.mockReturnValue(funcs);
+    const agent = createAgent();
+    const result = await agent.run();
+    const complexFindings = result.findings.filter(f => f.id.match(/complex-function-\d+/));
+    expect(complexFindings.length).toBe(10);
+    const summary = result.findings.find(f => f.id.includes('complex-functions-summary'));
+    expect(summary).toBeDefined();
+  });
+
+  it('adds evidence with scan stats', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'app.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue('const x = 1;');
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.evidence.length).toBeGreaterThan(0);
+  });
+
+  it('recurses into subdirectories', async () => {
+    readdirSyncMock
+      .mockReturnValueOnce([
+        { name: 'sub', isFile: () => false, isDirectory: () => true },
+      ])
+      .mockReturnValueOnce([
+        { name: 'helper.ts', isFile: () => true, isDirectory: () => false },
+      ]);
+    readFileSyncMock.mockReturnValue('const x = 1;');
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.status).toBeDefined();
+  });
+
+  it('handles empty file', async () => {
+    readdirSyncMock.mockReturnValue([
+      { name: 'empty.ts', isFile: () => true, isDirectory: () => false },
+    ]);
+    readFileSyncMock.mockReturnValue('');
+    const agent = createAgent();
+    const result = await agent.run();
+    expect(result.status).toBeDefined();
+  });
+});

package/agents/__tests__/registry.test.ts

@@ -7,8 +7,8 @@ import {
 } from '../registry';
 
 describe('AGENT_TIERS', () => {
-  it('should contain exactly 23 agents', () => {
-    expect(Object.keys(AGENT_TIERS)).toHaveLength(23);
+  it('should contain exactly 70 agents', () => {
+    expect(Object.keys(AGENT_TIERS)).toHaveLength(70);
   });
 
   it('should have 8 free-tier agents', () => {
@@ -16,14 +16,14 @@ describe('AGENT_TIERS', () => {
     expect(freeAgents).toHaveLength(8);
   });
 
-  it('should have 9 pro-tier agents', () => {
+  it('should have 26 pro-tier agents', () => {
     const proAgents = Object.entries(AGENT_TIERS).filter(([, t]) => t === 'pro');
-    expect(proAgents).toHaveLength(9);
+    expect(proAgents).toHaveLength(26);
   });
 
-  it('should have 6 enterprise-tier agents', () => {
+  it('should have 36 enterprise-tier agents', () => {
     const entAgents = Object.entries(AGENT_TIERS).filter(([, t]) => t === 'enterprise');
-    expect(entAgents).toHaveLength(6);
+    expect(entAgents).toHaveLength(36);
   });
 
   it('should classify known agents correctly', () => {
@@ -52,8 +52,8 @@ describe('getAgentTier', () => {
 
 describe('isAgentAvailable', () => {
   const freeAgents = [1, 2, 3, 4, 5, 9, 10, 11];
-  const proAgents = [6, 7, 8, 12, 13, 15, 21, 22, 23];
-  const enterpriseAgents = [14, 16, 17, 18, 19, 20];
+  const proAgents = [6, 7, 8, 12, 13, 15, 21, 22, 23, 24, 25, 26, 27, 28, 29, 31, 32, 33, 37, 38, 46, 48, 62, 68, 69, 70];
+  const enterpriseAgents = [14, 16, 17, 18, 19, 20, 30, 34, 35, 36, 39, 40, 41, 42, 43, 44, 45, 47, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 63, 64, 65, 66, 67];
 
   describe('free license', () => {
     it('should allow free-tier agents', () => {
@@ -113,10 +113,10 @@ describe('isAgentAvailable', () => {
 // ---------------------------------------------------------------------------
 
 describe('registerAllAgents', () => {
-  // We need to test that registerAllAgents creates 23 agents and registers them all.
+  // We need to test that registerAllAgents creates 70 agents and registers them all.
   // We mock the orchestrator's registerAgent method.
 
-  it('registers all 23 agents with the orchestrator', async () => {
+  it('registers all 70 agents with the orchestrator', async () => {
     // We need to dynamically import to avoid circular dependencies with mocked modules
     // Instead, test the function signature by checking it registers the right count
     const { registerAllAgents } = await import('../registry');
@@ -158,13 +158,13 @@ describe('registerAllAgents', () => {
       '/tmp/run',
     );
 
-    expect(mockOrchestrator.registerAgent).toHaveBeenCalledTimes(23);
+    expect(mockOrchestrator.registerAgent).toHaveBeenCalledTimes(70);
 
-    // Verify agent IDs 1-23 are all registered
+    // Verify agent IDs 1-70 are all registered
     const registeredIds = mockOrchestrator.registerAgent.mock.calls.map(
       (call: unknown[]) => call[0],
     );
-    for (let i = 1; i <= 23; i++) {
+    for (let i = 1; i <= 70; i++) {
       expect(registeredIds).toContain(i);
     }
   });

package/agents/base-agent.ts

@@ -1,11 +1,13 @@
 import type { AgentResult, Finding, Phase, EvidenceItem } from '../core/types';
 import type { ValidatedConfig } from '../core/config';
+import type { TotalRecallClient } from '../clients/total-recall';
 
 export abstract class BaseAgent {
   constructor(
     protected readonly config: ValidatedConfig,
     protected readonly phase: Phase,
     protected readonly runDir: string,
+    protected readonly totalRecall?: TotalRecallClient,
   ) {}
 
   abstract readonly agentId: number;
@@ -16,6 +18,12 @@ export abstract class BaseAgent {
     try {
       await this.preFlight();
       const findings = await this.execute();
+
+      // Store findings in Total Recall if available (fire-and-forget)
+      if (this.totalRecall && findings.length > 0) {
+        await this.totalRecall.storeFindings(this.agentId, this.agentName, findings).catch(() => {});
+      }
+
       const completedAt = new Date().toISOString();
       return {
         agentId: this.agentId,

package/agents/registry.ts

@@ -1,6 +1,7 @@
 import type { ValidatedConfig } from '../core/config';
 import type { Phase } from '../core/types';
 import type { Orchestrator } from '../core/orchestrator';
+import type { TotalRecallClient } from '../clients/total-recall';
 
 /** License tier type used for agent gating */
 export type LicenseTier = 'free' | 'pro' | 'enterprise';
@@ -8,8 +9,8 @@ export type LicenseTier = 'free' | 'pro' | 'enterprise';
 /**
  * Maps each agent number to its license tier.
  * - free (8 agents): core testing pipeline
- * - pro (9 agents): advanced testing capabilities
- * - enterprise (6 agents): full platform auditing
+ * - pro (26 agents): advanced testing capabilities
+ * - enterprise (36 agents): full platform auditing
  */
 export const AGENT_TIERS: Record<number, LicenseTier> = {
   /* ── Free tier (8) ── */
@@ -22,7 +23,7 @@ export const AGENT_TIERS: Record<number, LicenseTier> = {
   10: 'free',  // Reporter
   11: 'free',  // Fixer
 
-  /* ── Pro tier (9) ── */
+  /* ── Pro tier (26) ── */
   6: 'pro',    // API Exerciser
   7: 'pro',    // Security Scout
   8: 'pro',    // A11y Guardian
@@ -32,14 +33,61 @@ export const AGENT_TIERS: Record<number, LicenseTier> = {
   21: 'pro',   // State & Session Tester
   22: 'pro',   // Email Notification Verifier
   23: 'pro',   // Migration Tester
+  24: 'pro',   // Signup & Onboarding Tester
+  25: 'pro',   // CRUD Flow Tester
+  26: 'pro',   // Form Validator
+  27: 'pro',   // Search & Filter Tester
+  28: 'pro',   // Navigation & Routing Tester
+  29: 'pro',   // Responsive Interaction Tester
+  31: 'pro',   // Load Tester
+  32: 'pro',   // Memory Leak Detector
+  33: 'pro',   // Bundle Analyzer
+  37: 'pro',   // Dependency Scanner
+  38: 'pro',   // Secrets Scanner
+  46: 'pro',   // SEO Auditor
+  48: 'pro',   // Lighthouse Auditor
+  62: 'pro',   // Env Config Validator
+  68: 'pro',   // Dead Code Detector
+  69: 'pro',   // Type Safety Auditor
+  70: 'pro',   // Complexity Analyzer
 
-  /* ── Enterprise tier (6) ── */
+  /* ── Enterprise tier (36) ── */
   14: 'enterprise', // Data Integrity Auditor
   16: 'enterprise', // Chaos Agent
   17: 'enterprise', // Documentation Validator
   18: 'enterprise', // Integration Watchdog
   19: 'enterprise', // Tenant Isolation Auditor
   20: 'enterprise', // Workflow Completion Tester
+  30: 'enterprise', // Multi-User Scenario Tester
+  34: 'enterprise', // XSS Scanner
+  35: 'enterprise', // CSRF Tester
+  36: 'enterprise', // Auth Fuzzer
+  39: 'enterprise', // API Contract Tester
+  40: 'enterprise', // Rate Limit Tester
+  41: 'enterprise', // API Pagination Tester
+  42: 'enterprise', // GraphQL Tester
+  43: 'enterprise', // Data Consistency Checker
+  44: 'enterprise', // Backup Recovery Tester
+  45: 'enterprise', // Data Privacy Scanner
+  47: 'enterprise', // Social Preview Tester
+  49: 'enterprise', // i18n Tester
+  50: 'enterprise', // Timezone Tester
+  51: 'enterprise', // Error Recovery Tester
+  52: 'enterprise', // Offline Mode Tester
+  53: 'enterprise', // Graceful Degradation Tester
+  54: 'enterprise', // WebSocket Tester
+  55: 'enterprise', // Realtime Sync Tester
+  56: 'enterprise', // File Upload Tester
+  57: 'enterprise', // Export Tester
+  58: 'enterprise', // Payment Flow Tester
+  59: 'enterprise', // SSL/TLS Auditor
+  60: 'enterprise', // DNS/CDN Tester
+  61: 'enterprise', // Docker Health Checker
+  63: 'enterprise', // Log Quality Auditor
+  64: 'enterprise', // Analytics Tracker Tester
+  65: 'enterprise', // GDPR Compliance Tester
+  66: 'enterprise', // SOC2 Control Validator
+  67: 'enterprise', // WCAG AAA Tester
 };
 
 /** Returns the tier classification for a given agent number. */
@@ -91,9 +139,56 @@ import { WorkflowCompletionTesterAgent } from './20-workflow-completion-tester';
 import { StateSessionTesterAgent } from './21-state-session-tester';
 import { EmailNotificationVerifierAgent } from './22-email-notification-verifier';
 import { MigrationTesterAgent } from './23-migration-tester';
+import { CrudFlowTesterAgent } from './25-crud-flow-tester';
+import { FormValidatorAgent } from './26-form-validator';
+import { SignupOnboardingTesterAgent } from './24-signup-onboarding-tester';
+import { NavigationRoutingTesterAgent } from './28-navigation-routing-tester';
+import { SearchFilterTesterAgent } from './27-search-filter-tester';
+import { ResponsiveInteractionTesterAgent } from './29-responsive-interaction-tester';
+import { MultiUserScenarioTesterAgent } from './30-multi-user-scenario-tester';
+import { LoadTesterAgent } from './31-load-tester';
+import { MemoryLeakDetectorAgent } from './32-memory-leak-detector';
+import { BundleAnalyzerAgent } from './33-bundle-analyzer';
+import { XssScannerAgent } from './34-xss-scanner';
+import { CsrfTesterAgent } from './35-csrf-tester';
+import { AuthFuzzerAgent } from './36-auth-fuzzer';
+import { DependencyScannerAgent } from './37-dependency-scanner';
+import { SecretsScannerAgent } from './38-secrets-scanner';
+import { ApiContractTesterAgent } from './39-api-contract-tester';
+import { RateLimitTesterAgent } from './40-rate-limit-tester';
+import { ApiPaginationTesterAgent } from './41-api-pagination-tester';
+import { GraphqlTesterAgent } from './42-graphql-tester';
+import { DataConsistencyCheckerAgent } from './43-data-consistency-checker';
+import { BackupRecoveryTesterAgent } from './44-backup-recovery-tester';
+import { DataPrivacyScannerAgent } from './45-data-privacy-scanner';
+import { SeoAuditorAgent } from './46-seo-auditor';
+import { SocialPreviewTesterAgent } from './47-social-preview-tester';
+import { LighthouseAuditorAgent } from './48-lighthouse-auditor';
+import { I18nTesterAgent } from './49-i18n-tester';
+import { TimezoneTesterAgent } from './50-timezone-tester';
+import { ErrorRecoveryTesterAgent } from './51-error-recovery-tester';
+import { OfflineModeTesterAgent } from './52-offline-mode-tester';
+import { GracefulDegradationTesterAgent } from './53-graceful-degradation-tester';
+import { WebSocketTesterAgent } from './54-websocket-tester';
+import { RealtimeSyncTesterAgent } from './55-realtime-sync-tester';
+import { FileUploadTesterAgent } from './56-file-upload-tester';
+import { ExportTesterAgent } from './57-export-tester';
+import { PaymentFlowTesterAgent } from './58-payment-flow-tester';
+import { SslTlsAuditorAgent } from './59-ssl-tls-auditor';
+import { DnsCdnTesterAgent } from './60-dns-cdn-tester';
+import { DockerHealthCheckerAgent } from './61-docker-health-checker';
+import { EnvConfigValidatorAgent } from './62-env-config-validator';
+import { LogQualityAuditorAgent } from './63-log-quality-auditor';
+import { AnalyticsTrackerTesterAgent } from './64-analytics-tracker-tester';
+import { GdprComplianceTesterAgent } from './65-gdpr-compliance-tester';
+import { Soc2ControlValidatorAgent } from './66-soc2-control-validator';
+import { WcagAaaTesterAgent } from './67-wcag-aaa-tester';
+import { DeadCodeDetectorAgent } from './68-dead-code-detector';
+import { TypeSafetyAuditorAgent } from './69-type-safety-auditor';
+import { ComplexityAnalyzerAgent } from './70-complexity-analyzer';
 
 /**
- * Register all 23 agents with the orchestrator.
+ * Register all 70 agents with the orchestrator.
  * Each agent is instantiated with the validated config, phase, and run directory.
  * Since agents may run in different phases, we register them for all phases
  * and the orchestrator handles dispatching only the ones needed per phase.
@@ -103,31 +198,79 @@ export function registerAllAgents(
   config: ValidatedConfig,
   phase: Phase,
   runDir: string,
+  totalRecall?: TotalRecallClient,
 ): void {
   const agents = [
-    new AnalystAgent(config, phase, runDir),
-    new SeedArchitectAgent(config, phase, runDir),
-    new TestGeneratorAgent(config, phase, runDir),
-    new UnitRunnerAgent(config, phase, runDir),
-    new BrowserCrawlerAgent(config, phase, runDir),
-    new ApiExerciserAgent(config, phase, runDir),
-    new SecurityScoutAgent(config, phase, runDir),
-    new A11yGuardianAgent(config, phase, runDir),
-    new HealerAgent(config, phase, runDir),
-    new ReporterAgent(config, phase, runDir),
-    new FixerAgent(config, phase, runDir),
-    new UxInspectorAgent(config, phase, runDir),
-    new PerformanceProfilerAgent(config, phase, runDir),
-    new DataIntegrityAuditorAgent(config, phase, runDir),
-    new RegressionSentinelAgent(config, phase, runDir),
-    new ChaosAgent(config, phase, runDir),
-    new DocumentationValidatorAgent(config, phase, runDir),
-    new IntegrationWatchdogAgent(config, phase, runDir),
-    new TenantIsolationAuditorAgent(config, phase, runDir),
-    new WorkflowCompletionTesterAgent(config, phase, runDir),
-    new StateSessionTesterAgent(config, phase, runDir),
-    new EmailNotificationVerifierAgent(config, phase, runDir),
-    new MigrationTesterAgent(config, phase, runDir),
+    new AnalystAgent(config, phase, runDir, totalRecall),
+    new SeedArchitectAgent(config, phase, runDir, totalRecall),
+    new TestGeneratorAgent(config, phase, runDir, totalRecall),
+    new UnitRunnerAgent(config, phase, runDir, totalRecall),
+    new BrowserCrawlerAgent(config, phase, runDir, totalRecall),
+    new ApiExerciserAgent(config, phase, runDir, totalRecall),
+    new SecurityScoutAgent(config, phase, runDir, totalRecall),
+    new A11yGuardianAgent(config, phase, runDir, totalRecall),
+    new HealerAgent(config, phase, runDir, totalRecall),
+    new ReporterAgent(config, phase, runDir, totalRecall),
+    new FixerAgent(config, phase, runDir, totalRecall),
+    new UxInspectorAgent(config, phase, runDir, totalRecall),
+    new PerformanceProfilerAgent(config, phase, runDir, totalRecall),
+    new DataIntegrityAuditorAgent(config, phase, runDir, totalRecall),
+    new RegressionSentinelAgent(config, phase, runDir, totalRecall),
+    new ChaosAgent(config, phase, runDir, totalRecall),
+    new DocumentationValidatorAgent(config, phase, runDir, totalRecall),
+    new IntegrationWatchdogAgent(config, phase, runDir, totalRecall),
+    new TenantIsolationAuditorAgent(config, phase, runDir, totalRecall),
+    new WorkflowCompletionTesterAgent(config, phase, runDir, totalRecall),
+    new StateSessionTesterAgent(config, phase, runDir, totalRecall),
+    new EmailNotificationVerifierAgent(config, phase, runDir, totalRecall),
+    new MigrationTesterAgent(config, phase, runDir, totalRecall),
+    new SignupOnboardingTesterAgent(config, phase, runDir, totalRecall),
+    new CrudFlowTesterAgent(config, phase, runDir, totalRecall),
+    new FormValidatorAgent(config, phase, runDir, totalRecall),
+    new SearchFilterTesterAgent(config, phase, runDir, totalRecall),
+    new NavigationRoutingTesterAgent(config, phase, runDir, totalRecall),
+    new ResponsiveInteractionTesterAgent(config, phase, runDir, totalRecall),
+    new MultiUserScenarioTesterAgent(config, phase, runDir, totalRecall),
+    new LoadTesterAgent(config, phase, runDir, totalRecall),
+    new MemoryLeakDetectorAgent(config, phase, runDir, totalRecall),
+    new BundleAnalyzerAgent(config, phase, runDir, totalRecall),
+    new XssScannerAgent(config, phase, runDir, totalRecall),
+    new CsrfTesterAgent(config, phase, runDir, totalRecall),
+    new AuthFuzzerAgent(config, phase, runDir, totalRecall),
+    new DependencyScannerAgent(config, phase, runDir, totalRecall),
+    new SecretsScannerAgent(config, phase, runDir, totalRecall),
+    new ApiContractTesterAgent(config, phase, runDir, totalRecall),
+    new RateLimitTesterAgent(config, phase, runDir, totalRecall),
+    new ApiPaginationTesterAgent(config, phase, runDir, totalRecall),
+    new GraphqlTesterAgent(config, phase, runDir, totalRecall),
+    new DataConsistencyCheckerAgent(config, phase, runDir, totalRecall),
+    new BackupRecoveryTesterAgent(config, phase, runDir, totalRecall),
+    new DataPrivacyScannerAgent(config, phase, runDir, totalRecall),
+    new SeoAuditorAgent(config, phase, runDir, totalRecall),
+    new SocialPreviewTesterAgent(config, phase, runDir, totalRecall),
+    new LighthouseAuditorAgent(config, phase, runDir, totalRecall),
+    new I18nTesterAgent(config, phase, runDir, totalRecall),
+    new TimezoneTesterAgent(config, phase, runDir, totalRecall),
+    new ErrorRecoveryTesterAgent(config, phase, runDir, totalRecall),
+    new OfflineModeTesterAgent(config, phase, runDir, totalRecall),
+    new GracefulDegradationTesterAgent(config, phase, runDir, totalRecall),
+    new WebSocketTesterAgent(config, phase, runDir, totalRecall),
+    new RealtimeSyncTesterAgent(config, phase, runDir, totalRecall),
+    new FileUploadTesterAgent(config, phase, runDir, totalRecall),
+    new ExportTesterAgent(config, phase, runDir, totalRecall),
+    new PaymentFlowTesterAgent(config, phase, runDir, totalRecall),
+    new SslTlsAuditorAgent(config, phase, runDir, totalRecall),
+    new DnsCdnTesterAgent(config, phase, runDir, totalRecall),
+    new DockerHealthCheckerAgent(config, phase, runDir, totalRecall),
+    new EnvConfigValidatorAgent(config, phase, runDir, totalRecall),
+    new LogQualityAuditorAgent(config, phase, runDir, totalRecall),
+    new AnalyticsTrackerTesterAgent(config, phase, runDir, totalRecall),
+    new GdprComplianceTesterAgent(config, phase, runDir, totalRecall),
+    new Soc2ControlValidatorAgent(config, phase, runDir, totalRecall),
+    new WcagAaaTesterAgent(config, phase, runDir, totalRecall),
+    new DeadCodeDetectorAgent(config, phase, runDir, totalRecall),
+    new TypeSafetyAuditorAgent(config, phase, runDir, totalRecall),
+    new ComplexityAnalyzerAgent(config, phase, runDir, totalRecall),
   ];
 
   for (const agent of agents) {

package/core/__tests__/integration.test.ts

@@ -169,20 +169,20 @@ describe('Sample Platform — TestTeam Integration', () => {
   });
 
   describe('Orchestrator.dryRun with sample config', () => {
-    it('returns agent IDs [1, 2, 23, 3, 4, 5] for alpha phase', () => {
+    it('returns agent IDs [1, 2, 23, 24, 3, 4, 5, 37, 38, 62, 68, 69, 70] for alpha phase', () => {
       const validated = validateConfig(sampleConfig);
       const orchestrator = new Orchestrator(validated);
       const plan = orchestrator.dryRun('alpha');
 
-      expect(plan.map(e => e.agentId)).toEqual([1, 2, 23, 3, 4, 5]);
+      expect(plan.map(e => e.agentId)).toEqual([1, 2, 23, 24, 3, 4, 5, 37, 38, 62, 68, 69, 70]);
     });
 
-    it('returns agent IDs [5, 6, 7, 8, 12, 13, 14, 15, 16, 18, 19, 21, 22] for beta phase', () => {
+    it('returns all 59 agent IDs for beta phase', () => {
       const validated = validateConfig(sampleConfig);
       const orchestrator = new Orchestrator(validated);
       const plan = orchestrator.dryRun('beta');
 
-      expect(plan.map(e => e.agentId)).toEqual([5, 6, 7, 8, 12, 13, 14, 15, 16, 18, 19, 21, 22]);
+      expect(plan.map(e => e.agentId)).toEqual([5, 6, 7, 8, 12, 13, 14, 15, 16, 18, 19, 21, 22, 25, 26, 27, 28, 29, 30, 31, 32, 33, 34, 35, 36, 37, 38, 39, 40, 41, 42, 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 58, 59, 60, 61, 62, 63, 64, 65, 66, 67, 68, 69, 70]);
     });
 
     it('marks all alpha agents as unregistered when no agents are registered', () => {