opencroc 0.6.1 → 1.3.0

package/dist/index.d.ts

@@ -15,6 +15,10 @@ interface OpenCrocConfig {
     steps?: PipelineStep[];
     /** Self-healing configuration */
     selfHealing?: SelfHealingConfig;
+    /** Test execution hooks (setup/auth/teardown) */
+    execution?: ExecutionConfig;
+    /** Runtime infrastructure generation config */
+    runtime?: RuntimeConfig;
     /** Report configuration */
     report?: ReportConfig;
 }
@@ -33,12 +37,62 @@ interface PlaywrightOverrides {
     baseURL?: string;
     headless?: boolean;
     timeout?: number;
+    /** Number of parallel workers (default: 2, CI: 4) */
+    workers?: number;
+    /** Retry count on failure (default: 0, CI: 1) */
+    retries?: number;
+    /** Action timeout in ms (default: 10000) */
+    actionTimeout?: number;
+    /** Navigation timeout in ms */
+    navigationTimeout?: number;
+}
+interface RuntimeConfig {
+    /** Authentication strategy */
+    auth?: {
+        /** Login API URL for credential-based auth */
+        loginUrl?: string;
+        /** Credentials for automatic auth setup */
+        username?: string;
+        password?: string;
+        /** Storage state file path (default: playwright/.auth/user.json) */
+        storageStatePath?: string;
+    };
+    /** Database seed/cleanup configuration */
+    db?: {
+        /** Backend seed endpoint (e.g. /internal/e2e/seed) */
+        seedEndpoint?: string;
+        /** Backend cleanup endpoint (e.g. /internal/e2e/cleanup) */
+        cleanupEndpoint?: string;
+        /** SQL file to execute for seeding */
+        seedFile?: string;
+        /** SQL file to execute for cleanup */
+        cleanupFile?: string;
+    };
+    /** Test log management endpoint */
+    logEndpoint?: string;
+    /** Additional Playwright projects beyond the defaults */
+    extraProjects?: Array<{
+        name: string;
+        testMatch: string;
+        dependencies?: string[];
+        useAuth?: boolean;
+    }>;
 }
 interface SelfHealingConfig {
     enabled?: boolean;
     maxIterations?: number;
     mode?: 'config-only' | 'config-and-source';
 }
+type HookConfig = string | {
+    command: string;
+    args?: string[];
+    cwd?: string;
+};
+interface ExecutionConfig {
+    setupHook?: HookConfig;
+    authHook?: HookConfig;
+    teardownHook?: HookConfig;
+}
 interface ReportConfig {
     format?: ('html' | 'json' | 'markdown')[];
     outputDir?: string;
@@ -193,6 +247,264 @@ interface FixOutcome {
     fixedItems: string[];
     rolledBack: boolean;
 }
+type FixScope = 'config-only' | 'config-and-source';
+interface DialogLoopConfig {
+    maxIterations?: number;
+    pollIntervalMs?: number;
+    sameErrorThreshold?: number;
+    autoRerunOnFix?: boolean;
+}
+interface TestFailureInfo {
+    title: string;
+    error: string;
+    attribution?: AIAttributionResult;
+}
+interface IterationResult {
+    iteration: number;
+    totalTests: number;
+    passed: number;
+    failed: number;
+    failedTests: string[];
+    fixesApplied: string[];
+    durationMs: number;
+}
+interface DialogLoopSummary {
+    iterations: IterationResult[];
+    finalPassed: number;
+    finalFailed: number;
+    totalFixesApplied: number;
+    success: boolean;
+}
+interface ControlledFixOptions {
+    scope?: FixScope;
+    dryRun?: boolean;
+    verify?: boolean;
+    reportDir?: string;
+}
+interface ControlledFixOutcome {
+    success: boolean;
+    scope: FixScope;
+    fixedItems: string[];
+    rolledBack: boolean;
+    prUrl?: string;
+    error?: string;
+}
+interface AIAttributionResult {
+    testName: string;
+    rootCause: string;
+    category: 'frontend' | 'backend' | 'network' | 'environment' | 'test-script';
+    severity: 'critical' | 'high' | 'medium' | 'low';
+    fixSuggestion: {
+        description: string;
+        filePath: string;
+        codePatch: string;
+    };
+    confidence: number;
+}
+interface AutoFixPROptions {
+    branchPrefix?: string;
+    baseBranch?: string;
+    draftOnly?: boolean;
+}
+interface AutoFixPRResult {
+    prUrl: string;
+    branch: string;
+    patchFile: string;
+}
+type FailureCategory = 'backend-5xx' | 'mixed-5xx' | 'slow-api' | 'log-fail' | 'log-timeout' | 'frontend-load' | 'other';
+interface TestResultRecord {
+    title: string;
+    status: 'passed' | 'failed' | 'skipped' | 'timedOut';
+    duration: number;
+    error?: string;
+    logCompletion?: LogCompletionRecord;
+}
+interface LogCompletionRecord {
+    candidateCount: number;
+    succeeded: Array<{
+        method: string;
+        path: string;
+    }>;
+    failed: Array<{
+        method: string;
+        path: string;
+    }>;
+    timedOut: Array<{
+        method: string;
+        path: string;
+    }>;
+}
+interface FailureSummary {
+    totalFailed: number;
+    backend5xx: number;
+    mixed5xx: number;
+    slowApi: number;
+    logFail: number;
+    logTimeout: number;
+    frontendLoad: number;
+    other: number;
+}
+interface BackendDomainItem {
+    domain: string;
+    tests: string[];
+    endpoints: string[];
+}
+interface LogCompletionSummary {
+    totalCandidates: number;
+    succeeded: number;
+    failed: number;
+    timedOut: number;
+    matchRate: number;
+    effectiveRate: number;
+    timedOutTop5: Array<{
+        method: string;
+        path: string;
+        occurrences: number;
+    }>;
+}
+interface WorkorderItem {
+    index: number;
+    domain: string;
+    priority: 'P0' | 'P1' | 'P2';
+    tests: string[];
+    endpoints: string[];
+    objective: string;
+    acceptanceCriteria: string[];
+}
+interface TokenUsageEntry {
+    category: string;
+    model: string;
+    promptTokens: number;
+    completionTokens: number;
+    latencyMs: number;
+    estimatedCost: number;
+}
+interface TokenUsageSummary {
+    totalRequests: number;
+    totalTokens: number;
+    totalPromptTokens: number;
+    totalCompletionTokens: number;
+    totalEstimatedCost: number;
+    avgLatencyMs: number;
+    byCategory: Record<string, {
+        requests: number;
+        promptTokens: number;
+        completionTokens: number;
+        totalTokens: number;
+        estimatedCost: number;
+    }>;
+    byModel: Record<string, {
+        requests: number;
+        totalTokens: number;
+        estimatedCost: number;
+    }>;
+    budgetUsedPercent: number | null;
+    budgetExceeded: boolean;
+}
+interface ModuleTestConfig {
+    moduleName: string;
+    version: string;
+    generatedAt: string;
+    bodyTemplates: Record<string, Record<string, unknown>>;
+    paramRewrites: Record<string, Record<string, string>>;
+    idAliases: Array<{
+        pathPattern: string;
+        alias: string;
+    }>;
+    specialUrls: Record<string, string>;
+    seed: SeedStep[];
+}
+interface SeedStep {
+    step: number;
+    method: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    path: string;
+    body?: Record<string, unknown>;
+    captureAs?: string;
+    required: boolean;
+    dependsOn?: string[];
+    failureMessage?: string;
+}
+type ModuleConfigErrorType = 'missing-field' | 'invalid-type' | 'invalid-format' | 'interface-not-found' | 'field-missing' | 'type-mismatch' | 'dependency-cycle' | 'dependency-missing' | 'seed-order-invalid' | 'param-mapping-invalid' | 'compile-error' | 'unknown';
+interface ModuleConfigValidationError {
+    layer: 'schema' | 'semantic' | 'dryrun';
+    type: ModuleConfigErrorType;
+    path: string;
+    message: string;
+    suggestion?: string;
+}
+interface ModuleConfigValidationWarning {
+    layer: 'schema' | 'semantic' | 'dryrun';
+    path: string;
+    message: string;
+}
+interface LayerValidationResult {
+    passed: boolean;
+    layer: 'schema' | 'semantic' | 'dryrun';
+    errors: ModuleConfigValidationError[];
+    warnings: ModuleConfigValidationWarning[];
+}
+interface ModuleConfigValidationResult {
+    passed: boolean;
+    lastPassedLayer?: 'schema' | 'semantic' | 'dryrun';
+    failedAtLayer?: 'schema' | 'semantic' | 'dryrun';
+    schemaResult?: LayerValidationResult;
+    semanticResult?: LayerValidationResult;
+    dryrunResult?: LayerValidationResult;
+    errors: ModuleConfigValidationError[];
+    warnings: ModuleConfigValidationWarning[];
+}
+/** DTO (TypeScript interface) information */
+interface DTOInfo {
+    name: string;
+    sourcePath?: string;
+    fields: DTOFieldInfo[];
+    extends?: string;
+}
+interface DTOFieldInfo {
+    name: string;
+    type: string;
+    required: boolean;
+    enumValues?: string[];
+    isSystemField?: boolean;
+}
+/** express-validator rule */
+interface ValidatorRule {
+    field: string;
+    source: 'body' | 'param' | 'query';
+    rules: string[];
+}
+/** Module metadata from DTO scanning */
+interface ModuleMetadata {
+    moduleName: string;
+    dtos: DTOInfo[];
+    validatorRules: Map<string, ValidatorRule[]>;
+    timestamp: string;
+}
+interface ModuleConfigValidationContext {
+    endpoints: ApiEndpoint[];
+    dtos: DTOInfo[];
+}
+interface FixContext {
+    endpoints: ApiEndpoint[];
+    dtos: DTOInfo[];
+}
+interface FixHistoryEntry {
+    timestamp: string;
+    attempt: number;
+    errorType: string;
+    errorPath: string;
+    errorMessage: string;
+    fixerUsed: string;
+    changedKeys: string[];
+    validationPassedAfterFix: boolean;
+}
+interface FixResult {
+    success: boolean;
+    config: ModuleTestConfig;
+    totalAttempts: number;
+    history: FixHistoryEntry[];
+    remainingErrors: ModuleConfigValidationError[];
+}
 interface BackendAdapter {
     name: string;
     parseModels(dir: string): Promise<TableSchema[]>;
@@ -279,6 +591,37 @@ declare function buildClassToTableMap(modelDir: string): Map<string, string>;
 declare function classNameToTableName(className: string): string;
 declare function createAssociationParser(): AssociationParser;
 
+/**
+ * DTO / TypeScript Interface Parser
+ *
+ * Uses ts-morph to parse TypeScript interfaces from Service and Model files,
+ * extracting field info (name, type, required, enum values) and
+ * express-validator rules from Controller files.
+ */
+
+/**
+ * Parse DTOs (TypeScript interfaces) from Service and Model files.
+ *
+ * @param filePaths  Files to scan (Service / Model .ts files)
+ * @param options.dtoNamePatterns  Regex patterns to match DTO interface names
+ */
+declare function parseDTOs(filePaths: string[], options?: {
+    dtoNamePatterns?: RegExp[];
+}): DTOInfo[];
+/**
+ * Parse express-validator rules from Controller files.
+ *
+ * Scans router.get/post/put/delete calls for middleware arrays containing
+ * body('field').notEmpty(), param('field').isInt(), etc.
+ *
+ * @returns Map<routeKey, ValidatorRule[]>  routeKey = "METHOD /path"
+ */
+declare function parseValidatorRules(controllerPaths: string[]): Map<string, ValidatorRule[]>;
+/**
+ * Scan a module comprehensively, returning enhanced ModuleMetadata.
+ */
+declare function scanModuleMetadata(moduleName: string, servicePaths: string[], controllerPaths: string[], modelDir?: string): ModuleMetadata;
+
 interface TestCodeGenerator {
     generate(chains: TestChain[]): GeneratedTestFile[];
 }
@@ -325,11 +668,369 @@ interface ImpactReporter {
 }
 declare function createImpactReporter(): ImpactReporter;
 
+/**
+ * Chain Planner
+ *
+ * Rule-based test chain planning:
+ * - Groups endpoints by resource path
+ * - Applies chain templates (CRUD, nested, batch, status, error handling)
+ * - Uses greedy algorithm for optimal coverage selection
+ * - Detects shared setup steps
+ */
+
+interface ChainPlanner {
+    planForModule(moduleName: string, analysis: ApiChainAnalysisResult): ChainPlanResult;
+}
+declare function createChainPlanner(): ChainPlanner;
+interface LlmChainPlanner extends ChainPlanner {
+    planForModuleWithLLM(moduleName: string, analysis: ApiChainAnalysisResult, llmProvider: LlmProvider): Promise<ChainPlanResult>;
+}
+/**
+ * Create a chain planner with optional LLM constraint reasoning.
+ *
+ * The LLM is used to:
+ * 1. Infer business constraints that rule-based templates cannot detect
+ * 2. Prioritize chains based on domain understanding
+ * 3. Suggest additional edge-case chains
+ */
+declare function createLlmChainPlanner(): LlmChainPlanner;
+
 /**
  * Validate an OpenCroc configuration object.
  * Returns an array of ValidationErrors (empty = valid).
  */
 declare function validateConfig(config: Record<string, unknown>): ValidationError[];
+interface ValidateModuleConfigOptions {
+    stopOnFailure?: boolean;
+    skipLayers?: Array<'schema' | 'semantic' | 'dryrun'>;
+}
+declare function validateModuleConfig(config: unknown, context?: ModuleConfigValidationContext, options?: ValidateModuleConfigOptions): ModuleConfigValidationResult;
+declare function formatValidationResult(result: ModuleConfigValidationResult): string;
+
+/**
+ * Schema Validator — Layer 1 of three-layer module config validation.
+ * Checks structural integrity, field types, format conventions.
+ */
+
+declare function validateSchema(config: unknown): LayerValidationResult;
+
+/**
+ * Semantic Validator — Layer 2 of three-layer module config validation.
+ * Checks that config matches actual source code (routes, DTO fields, dependencies).
+ */
+
+declare function validateSemantic(config: ModuleTestConfig, context: ModuleConfigValidationContext): LayerValidationResult;
+
+/**
+ * Dry-run Validator — Layer 3 of three-layer module config validation.
+ * Generates temporary TypeScript code from config and runs ts-morph compile check.
+ */
+
+declare function validateDryrun(config: ModuleTestConfig, _context: ModuleConfigValidationContext): LayerValidationResult;
+
+/**
+ * AI Config Suggester — AI-driven module test config generation.
+ *
+ * Uses LlmProvider to analyze parsed API endpoints and generate:
+ * - bodyTemplates (request body for POST/PUT/PATCH endpoints)
+ * - paramRewrites (semantic parameter name mapping)
+ * - seed steps (data setup sequence with dependency ordering)
+ */
+
+interface GenerateConfigOptions {
+    moduleName: string;
+    endpoints: ApiEndpoint[];
+    llmProvider: LlmProvider;
+    /** Max validation+fix retries (default 3) */
+    maxRetries?: number;
+    /** Dry-run: don't write to disk */
+    dryRun?: boolean;
+    /** Validation context for semantic checking */
+    validationContext?: ModuleConfigValidationContext;
+}
+interface GenerateConfigResult {
+    success: boolean;
+    config?: ModuleTestConfig;
+    error?: string;
+    retries: number;
+}
+declare function recoverJSON(text: string): string;
+/**
+ * Generate a module test config using AI analysis of endpoints.
+ */
+declare function generateModuleConfig(options: GenerateConfigOptions): Promise<GenerateConfigResult>;
+/**
+ * Batch generate configs for multiple modules.
+ */
+declare function generateAllModuleConfigs(moduleNames: string[], endpoints: Map<string, ApiEndpoint[]>, llmProvider: LlmProvider, options?: Partial<GenerateConfigOptions>): Promise<Map<string, GenerateConfigResult>>;
+
+/**
+ * Enhanced AI Config Suggester — improved config generation with:
+ * - Richer prompts using DTO field info and validation rules
+ * - JSON recovery with fallback strategies
+ * - Retry with previous failure context
+ * - Three-layer validation integration
+ */
+
+interface EnhancedGenerateOptions {
+    moduleName: string;
+    endpoints: ApiEndpoint[];
+    llmProvider: LlmProvider;
+    /** DTO info for richer prompts */
+    dtos?: DTOInfo[];
+    /** Example config for few-shot learning */
+    exampleConfig?: ModuleTestConfig;
+    /** Temperature (default 0.1) */
+    temperature?: number;
+    /** Max retries per phase (default 3) */
+    maxRetries?: number;
+    /** Single call timeout in ms (default 30000) */
+    timeout?: number;
+    /** Dry-run: preview only */
+    dryRun?: boolean;
+}
+interface EnhancedGenerateResult {
+    success: boolean;
+    config?: ModuleTestConfig;
+    attempts: AttemptRecord$1[];
+    error?: string;
+}
+interface AttemptRecord$1 {
+    attempt: number;
+    phase: 'body' | 'param' | 'seed' | 'full';
+    rawResponse?: string;
+    parsedJson?: unknown;
+    error?: string;
+    durationMs: number;
+}
+/**
+ * Generate module test config with enhanced prompts and retry logic.
+ */
+declare function generateEnhancedConfig(options: EnhancedGenerateOptions): Promise<EnhancedGenerateResult>;
+
+/**
+ * Auto-Fixer — automatic config repair based on validation errors.
+ *
+ * Four fix strategies:
+ * 1. InterfacePathMismatchFixer: find the closest matching real route
+ * 2. MissingDtoFieldFixer: fill in missing required fields from DTO
+ * 3. SeedDependencyOrderFixer: topological sort of seed steps
+ * 4. ParamMappingFixer: regenerate paramRewrites from actual routes
+ */
+
+/**
+ * Run automatic fix loop on a module test config.
+ */
+declare function autoFix(config: ModuleTestConfig, initialErrors: ModuleConfigValidationError[], context: FixContext, validationContext?: ModuleConfigValidationContext, maxAttempts?: number): FixResult;
+
+/**
+ * Baseline Comparator — compare AI-generated test runs against hardcoded baselines.
+ *
+ * Workflow:
+ * 1. Parse Playwright JSON reports from both baseline and AI-config runs
+ * 2. Diff each test case: regression / improvement / unchanged / new / removed
+ * 3. Generate prompt optimization suggestions from failure patterns
+ * 4. Output formatted comparison report
+ */
+interface TestCaseResult {
+    title: string;
+    file: string;
+    suite: string;
+    status: 'passed' | 'failed' | 'skipped' | 'timedOut';
+    durationMs: number;
+    error?: string;
+}
+interface TestRunSummary {
+    label: string;
+    timestamp: string;
+    modules: string[];
+    total: number;
+    passed: number;
+    failed: number;
+    skipped: number;
+    timedOut: number;
+    passRate: number;
+    totalDurationMs: number;
+    avgDurationMs: number;
+    cases: TestCaseResult[];
+}
+interface CaseDiff {
+    title: string;
+    file: string;
+    change: 'regression' | 'improvement' | 'unchanged' | 'new' | 'removed';
+    baselineStatus: TestCaseResult['status'] | null;
+    aiConfigStatus: TestCaseResult['status'] | null;
+    durationDiffMs: number;
+    error?: string;
+}
+interface PromptOptimization {
+    category: 'seed-config' | 'body-template' | 'param-rewrite' | 'id-alias' | 'general';
+    issue: string;
+    suggestion: string;
+    relatedCases: string[];
+}
+interface ComparisonReport {
+    baseline: TestRunSummary;
+    aiConfig: TestRunSummary;
+    passRateDiff: number;
+    /** AI pass rate >= 85% of baseline */
+    meetsThreshold: boolean;
+    durationChangePercent: number;
+    /** Duration change within ±10% */
+    durationAcceptable: boolean;
+    diffs: CaseDiff[];
+    regressions: CaseDiff[];
+    improvements: CaseDiff[];
+    promptOptimizations: PromptOptimization[];
+}
+/**
+ * Parse a Playwright `--reporter=json` output into a TestRunSummary.
+ */
+declare function parsePlaywrightReport(reportJson: Record<string, unknown>, label: string, modules: string[]): TestRunSummary;
+/**
+ * Build a TestRunSummary from raw test case results.
+ */
+declare function buildTestRunSummary(label: string, modules: string[], cases: TestCaseResult[]): TestRunSummary;
+/**
+ * Compare two test runs and produce a detailed comparison report.
+ */
+declare function compareTestRuns(baseline: TestRunSummary, aiConfig: TestRunSummary): ComparisonReport;
+/**
+ * Format a ComparisonReport into human-readable text.
+ */
+declare function formatComparisonReport(report: ComparisonReport): string;
+
+/**
+ * Module Config Preset Loader
+ *
+ * Loads pre-generated module test configs (JSON) from a directory,
+ * validates them, and provides lookup by module name.
+ *
+ * This supports the 70 module configs migrated from dynamic-gen/module-configs/.
+ */
+
+interface PresetLoadResult {
+    configs: Map<string, ModuleTestConfig>;
+    errors: Array<{
+        file: string;
+        error: string;
+    }>;
+    totalLoaded: number;
+    totalFailed: number;
+}
+/**
+ * Load all module config presets from a directory.
+ *
+ * @param configDir - Path to directory containing *.json module configs
+ * @param options.validate - Run schema validation on each config (default: true)
+ * @returns Loaded configs indexed by moduleName
+ */
+declare function loadModulePresets(configDir: string, options?: {
+    validate?: boolean;
+}): PresetLoadResult;
+/**
+ * Get a single module config by name from a preset directory.
+ */
+declare function getModulePreset(configDir: string, moduleName: string): ModuleTestConfig | null;
+/**
+ * List all available module preset names from a directory.
+ */
+declare function listModulePresets(configDir: string): string[];
+
+/**
+ * Dialog Loop Runner — multi-iteration self-healing loop.
+ *
+ * Runs tests, parses results, applies controlled fixes, and reruns
+ * until all tests pass or the maximum iteration count is reached.
+ * Tracks error history to avoid infinite loops on recurring failures.
+ */
+
+interface TestRunner {
+    run(): Promise<{
+        stdout: string;
+        exitCode: number;
+    }>;
+}
+interface ResultParser {
+    parse(stdout: string): TestFailureInfo[];
+    countTotal(stdout: string): number;
+}
+interface FixApplier {
+    apply(failure: TestFailureInfo): Promise<ControlledFixOutcome>;
+}
+declare function createJsonResultParser(): ResultParser;
+interface DialogLoopOptions {
+    runner: TestRunner;
+    parser: ResultParser;
+    fixer: FixApplier;
+    config?: DialogLoopConfig;
+    onIteration?: (result: IterationResult) => void;
+}
+declare function runDialogLoop(options: DialogLoopOptions): Promise<DialogLoopSummary>;
+
+/**
+ * Controlled Fixer — two-phase fix engine with safety guarantees.
+ *
+ * Phase A (config-only): backup → validate → fix → dry-run → write → verify → cleanup.
+ * Phase B (config-and-source): generates a draft PR with the AI-suggested code patch.
+ *
+ * All mutations are reversible — failures trigger automatic rollback.
+ */
+
+interface ConfigValidator {
+    validate(configContent: string): {
+        passed: boolean;
+        errors: string[];
+    };
+}
+interface ConfigFixer {
+    fix(configContent: string, errors: string[]): {
+        success: boolean;
+        fixedContent: string;
+        fixedItems: string[];
+        remainingErrors: string[];
+    };
+}
+interface PRGenerator {
+    generate(attribution: AIAttributionResult): Promise<string>;
+}
+interface FsOps {
+    exists(path: string): boolean;
+    read(path: string): string;
+    write(path: string, content: string): void;
+    copy(src: string, dest: string): void;
+    remove(path: string): void;
+    mkdirp(dir: string): void;
+}
+interface ControlledFixerOptions {
+    configPath: string;
+    validator: ConfigValidator;
+    fixer: ConfigFixer;
+    prGenerator?: PRGenerator;
+    attribution?: AIAttributionResult;
+    fs?: FsOps;
+    options?: ControlledFixOptions;
+}
+declare function applyControlledFix(opts: ControlledFixerOptions): Promise<ControlledFixOutcome>;
+
+/**
+ * Auto-Fix PR Generator — creates draft PRs from AI attribution results.
+ *
+ * Flow: create branch → write patch → git apply → commit → push → gh pr create --draft.
+ * All PRs are draft-only as a safety invariant.
+ */
+
+interface GitExecutor {
+    exec(command: string, args: string[]): Promise<{
+        stdout: string;
+        exitCode: number;
+    }>;
+}
+interface PatchWriter {
+    write(path: string, content: string): Promise<void>;
+    mkdir(dir: string): Promise<void>;
+}
+declare function generateFixPR(attribution: AIAttributionResult, git: GitExecutor, patchWriter: PatchWriter, options?: AutoFixPROptions): Promise<AutoFixPRResult>;
 
 interface SelfHealingLoop {
     run(testResultsDir: string): Promise<SelfHealingResult>;
@@ -374,7 +1075,7 @@ declare function createLlmProvider(config: LlmConfig): LlmProvider;
 /**
  * Token usage tracker — accumulates tokens across multiple LLM calls.
  */
-interface TokenTracker {
+interface TokenTracker$1 {
     track(text: string): void;
     trackChat(messages: Array<{
         role: string;
@@ -383,7 +1084,7 @@ interface TokenTracker {
     total: number;
     reset(): void;
 }
-declare function createTokenTracker(provider: LlmProvider): TokenTracker;
+declare function createTokenTracker(provider: LlmProvider): TokenTracker$1;
 /**
  * System prompts for different LLM use cases in OpenCroc.
  */
@@ -516,6 +1217,57 @@ declare function listCiPlatforms(): string[];
  */
 declare function generateCiTemplate(platform: string, opts?: CiTemplateOptions): string;
 
+/**
+ * Checklist Reporter — generates backend fix checklists from test results.
+ *
+ * Groups failures by API domain, lists affected tests and endpoints,
+ * and produces both structured data and Markdown output.
+ */
+
+declare function classifyFailure(error?: string): FailureCategory;
+declare function buildFailureSummary(records: TestResultRecord[]): FailureSummary;
+declare function aggregateLogCompletion(records: TestResultRecord[]): LogCompletionSummary;
+declare function parseApiDomain(urlStr: string): string | null;
+declare function buildBackendChecklist(records: TestResultRecord[]): BackendDomainItem[];
+declare function renderChecklistMarkdown(items: BackendDomainItem[], summary: FailureSummary, logSummary?: LogCompletionSummary): string;
+
+/**
+ * Workorder Reporter — auto-generates prioritized backend work orders.
+ *
+ * Priority rules:
+ *   - P0: ≥3 affected tests OR log completion rate < 90%
+ *   - P1: 2 affected tests
+ *   - P2: 1 affected test
+ *
+ * Each workorder includes objective, affected scope, and acceptance criteria.
+ */
+
+interface BuildWorkordersOptions {
+    checklist: BackendDomainItem[];
+    summary: FailureSummary;
+    logSummary?: LogCompletionSummary;
+    logRateThreshold?: number;
+}
+declare function buildWorkorders(opts: BuildWorkordersOptions): WorkorderItem[];
+declare function renderWorkordersMarkdown(workorders: WorkorderItem[], summary: FailureSummary, logSummary?: LogCompletionSummary): string;
+
+/**
+ * Token Usage Reporter — tracks and reports LLM token consumption.
+ *
+ * Aggregates usage entries by category and model, computes costs,
+ * tracks budget utilization, and renders both structured data and Markdown.
+ */
+
+declare class TokenTracker {
+    private entries;
+    private budget;
+    setBudget(maxTokens: number): void;
+    record(entry: TokenUsageEntry): void;
+    reset(): void;
+    getSummary(): TokenUsageSummary;
+}
+declare function renderTokenReportMarkdown(summary: TokenUsageSummary): string;
+
 interface ReportOutput {
     format: 'html' | 'json' | 'markdown';
     content: string;
@@ -611,4 +1363,437 @@ declare function generateExtensionManifest(): Record<string, unknown>;
  */
 declare function generateExtensionEntrypoint(): string;
 
-export { type ApiChainAnalysisResult, type ApiDependency, type ApiEndpoint, type BackendAdapter, type ChainFailureResult, type ChainPlanResult, type DashboardData, type DashboardOutput, type DirectedAcyclicGraph, type ERDiagramResult, type FieldSchema, type FixOutcome, type ForeignKeyRelation, type GeneratedTestFile, type ImpactReport, type IndexSchema, type LlmProvider, type ModuleDefinition, type OpenCrocConfig, type OpenCrocPlugin, type PipelineRunResult, type PluginRegistry, type ReportOutput, type ResolvedConfig, type RouteEntry, SYSTEM_PROMPTS, type SelfHealingResult, type TableSchema, type TestChain, type TestStep, COMMANDS as VSCODE_COMMANDS, type ValidationError, analyzeFailureWithLLM, buildClassToTableMap, buildDashboardDataFromPipeline, buildDashboardDataFromReportJson, buildGraph, buildModuleTree, buildStatusTree, categorizeFailure, classNameToTableName, createAdapter, createApiChainAnalyzer, createAssociationParser, createControllerParser, createDrizzleAdapter, createERDiagramGenerator, createImpactReporter, createLlmProvider, createMockDataGenerator, createModelParser, createOllamaProvider, createOpenAIProvider, createPipeline, createPluginRegistry, createPrismaAdapter, createSelfHealingLoop, createSequelizeAdapter, createTestCodeGenerator, createTokenTracker, createTypeORMAdapter, defineConfig, definePlugin, detectAdapter, detectCycles, generateCiTemplate, generateExtensionEntrypoint, generateExtensionManifest, generateGitHubActionsTemplate, generateGitLabCITemplate, generateHtmlReport, generateJsonReport, generateMarkdownReport, generateReports, generateVisualDashboard, generateVisualDashboardHtml, inferDependencies, inferRelatedTables, listCiPlatforms, parseAssociationFile, parseControllerDirectory, parseControllerFile, parseDrizzleDirectory, parseDrizzleFile, parseModelFile, parseModuleModels, resolveAdapter, topologicalSort, validateConfig };
+/**
+ * Generate playwright.config.ts content based on OpenCroc config.
+ */
+declare function generatePlaywrightConfig(config: OpenCrocConfig): string;
+
+/**
+ * Generate global-setup.ts content for Playwright.
+ * Handles backend readiness probe, seed endpoint call, and log cleanup.
+ */
+declare function generateGlobalSetup(config: OpenCrocConfig): string;
+
+/**
+ * Generate global-teardown.ts content for Playwright.
+ * Handles cleanup endpoint call and optional SQL cleanup.
+ */
+declare function generateGlobalTeardown(config: OpenCrocConfig): string;
+
+/**
+ * Generate auth.setup.ts content for Playwright.
+ * Creates an authentication setup project that stores state for reuse.
+ */
+declare function generateAuthSetup(config: OpenCrocConfig): string;
+
+/**
+ * Resilient HTTP fetch with exponential backoff retry.
+ * Framework-level utility — no Playwright dependency required.
+ */
+interface AttemptRecord {
+    attempt: number;
+    status: number;
+    url: string;
+    method: string;
+    latencyMs: number;
+    error?: string;
+}
+interface ResilientFetchOptions {
+    /** HTTP method */
+    method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'PATCH';
+    /** Request body (will be JSON-stringified if object) */
+    body?: string | Record<string, unknown>;
+    /** Request headers */
+    headers?: Record<string, string>;
+    /** Max retry count (default: 3) */
+    maxRetries?: number;
+    /** Base delay in ms for exponential backoff (default: 1000) */
+    baseDelayMs?: number;
+    /** Per-request timeout in ms (default: 10000) */
+    timeoutMs?: number;
+    /** If true, throw on final failure; if false, return error result (default: false) */
+    throwOnFailure?: boolean;
+}
+interface ResilientFetchResult {
+    ok: boolean;
+    status: number;
+    data: unknown;
+    attempts: AttemptRecord[];
+}
+/**
+ * Make an HTTP request with automatic retry and exponential backoff.
+ *
+ * Retries on: network errors, 408, 429, 5xx.
+ * Does NOT retry on: 4xx (except 408/429).
+ */
+declare function resilientFetch(url: string, options?: ResilientFetchOptions): Promise<ResilientFetchResult>;
+/**
+ * Wait for a backend to become healthy by polling a health endpoint.
+ */
+declare function waitForBackend(baseUrl: string, options?: {
+    timeoutMs?: number;
+    intervalMs?: number;
+    healthPath?: string;
+}): Promise<void>;
+
+/**
+ * Playwright network request/response monitor.
+ * Attaches to a Page and records API calls, errors, and response times.
+ */
+interface NetworkError {
+    url: string;
+    status: number;
+    method: string;
+    responseBody: string;
+    requestPayload?: string;
+    timestamp: string;
+    pageUrl: string;
+}
+interface ApiRecord {
+    url: string;
+    status: number;
+    method: string;
+    durationMs: number;
+    timestamp: string;
+    pageUrl: string;
+}
+interface NetworkMonitorOptions {
+    /** URL pattern to track (default: '/api/') */
+    apiPattern?: string;
+    /** Whether to capture response bodies for errors (default: true) */
+    captureErrorBody?: boolean;
+}
+/** Minimal Playwright Page interface — avoids hard dependency on @playwright/test */
+interface PlaywrightPage {
+    url(): string;
+    on(event: 'request', handler: (req: PlaywrightRequest) => void): void;
+    on(event: 'response', handler: (res: PlaywrightResponse) => void): void;
+}
+interface PlaywrightRequest {
+    url(): string;
+    method(): string;
+    postData(): string | null;
+}
+interface PlaywrightResponse {
+    url(): string;
+    status(): number;
+    request(): PlaywrightRequest;
+    text(): Promise<string>;
+}
+declare class NetworkMonitor {
+    private errors;
+    private records;
+    private requestStarts;
+    private readonly apiPattern;
+    private readonly captureErrorBody;
+    constructor(options?: NetworkMonitorOptions);
+    /**
+     * Attach the monitor to a Playwright Page.
+     * Call this once per page — typically in a test fixture or beforeEach.
+     */
+    attach(page: PlaywrightPage): void;
+    /** All captured API records. */
+    getRecords(): ApiRecord[];
+    /** All captured network errors (status >= 400). */
+    getErrors(): NetworkError[];
+    /** API calls slower than the given threshold. */
+    getSlowRequests(thresholdMs: number): ApiRecord[];
+    /** 5xx server errors. */
+    get5xxErrors(): NetworkError[];
+    /** 4xx client errors. */
+    get4xxErrors(): NetworkError[];
+    /** Whether any network errors have been captured. */
+    hasErrors(): boolean;
+    /** Reset all captured data. */
+    clear(): void;
+}
+
+/**
+ * Dynamic route parameter resolver.
+ * Extracts path parameters by matching URL templates against actual hrefs.
+ * Framework-level utility — no app-specific dependencies.
+ */
+interface ResolvedRoute {
+    /** Original path template (e.g. '/users/:id/detail') */
+    originalPath: string;
+    /** Resolved path with actual values (e.g. '/users/42/detail') */
+    resolvedPath: string;
+    /** Extracted parameter map (e.g. { id: '42' }) */
+    params: Record<string, string>;
+    /** How the parameters were resolved */
+    resolveMethod: 'href-extraction' | 'seed-data' | 'text-extraction';
+}
+/**
+ * Extract parameter names from a path template.
+ * @example extractParamNames('/users/:id/posts/:postId') → ['id', 'postId']
+ */
+declare function extractParamNames(pathTemplate: string): string[];
+/**
+ * Extract parameter values by matching a URL template against an actual href.
+ * Returns null if the href doesn't match the template structure.
+ *
+ * @example
+ * extractParamsFromHref('/users/:id/detail', '/users/42/detail')
+ * // → { id: '42' }
+ */
+declare function extractParamsFromHref(pathTemplate: string, href: string): Record<string, string> | null;
+/**
+ * Build a concrete path from a template and parameter values.
+ *
+ * @example
+ * buildPath('/users/:id/posts/:postId', { id: '42', postId: '7' })
+ * // → '/users/42/posts/7'
+ */
+declare function buildPath(pathTemplate: string, params: Record<string, string>): string;
+/**
+ * Try to extract an ID-like value from a text string.
+ * Matches numeric IDs and UUIDs.
+ */
+declare function extractIdFromText(text: string): string | null;
+/**
+ * Resolve dynamic route parameters from a seed data map.
+ *
+ * @param pathTemplate - URL template with :params
+ * @param seedData - Map of route keys to param objects
+ * @param routeKey - Optional explicit key; defaults to normalized path
+ */
+declare function resolveFromSeedData(pathTemplate: string, seedData: Record<string, Record<string, string>>, routeKey?: string): ResolvedRoute | null;
+
+/**
+ * Log-driven API completion detection.
+ *
+ * Polls a backend log endpoint to verify that API requests have fully completed
+ * (not just returned HTTP 200, but the backend has finished all processing).
+ * This closes the gap between "HTTP response received" and "backend actually done".
+ */
+interface CandidateApiRequest {
+    /** Backend-assigned request ID (if available) */
+    requestId?: string;
+    /** HTTP method */
+    method: string;
+    /** API path (e.g. /api/users) */
+    path: string;
+    /** Full URL */
+    url: string;
+}
+interface LogCompletionResult {
+    /** Total candidates being tracked */
+    candidateCount: number;
+    /** Requests confirmed completed successfully */
+    succeeded: CandidateApiRequest[];
+    /** Requests confirmed completed with failure */
+    failed: Array<{
+        request: CandidateApiRequest;
+        reason: string;
+    }>;
+    /** Requests that never got a completion log within timeout */
+    timedOut: CandidateApiRequest[];
+    /** Number of poll iterations performed */
+    pollCount: number;
+    /** Total elapsed ms */
+    elapsedMs: number;
+}
+interface LogEntry {
+    /** Backend-assigned request ID */
+    requestId?: string;
+    /** HTTP method */
+    method?: string;
+    /** API path */
+    apiPath?: string;
+    /** Event phase: 'start' | 'end' */
+    eventPhase?: string;
+    /** Event status: 'success' | 'fail' */
+    eventStatus?: string;
+    /** HTTP status code */
+    status?: number;
+    /** Nested metadata (some backends put fields here) */
+    meta?: Record<string, unknown>;
+}
+interface LogPollerOptions {
+    /** Function that fetches end-phase logs from the backend. Return parsed log entries. */
+    fetchLogs: () => Promise<LogEntry[]>;
+    /** Timeout in ms (default: 25000) */
+    timeoutMs?: number;
+    /** Initial poll delay in ms (default: 200) */
+    initialDelayMs?: number;
+    /** Max poll delay in ms (default: 2000) */
+    maxDelayMs?: number;
+}
+interface ApiResponseRecord {
+    url: string;
+    method: string;
+    requestId?: string;
+}
+/**
+ * Select candidate API requests from network-captured responses.
+ * Deduplicates by requestId or method+path.
+ */
+declare function selectCandidates(responses: ApiResponseRecord[], maxCount?: number): CandidateApiRequest[];
+/**
+ * Select candidates from start-phase log entries.
+ */
+declare function selectCandidatesFromLogs(logs: LogEntry[], maxCount?: number): CandidateApiRequest[];
+/**
+ * Merge multiple candidate lists, deduplicating by key.
+ */
+declare function mergeCandidates(...groups: CandidateApiRequest[][]): CandidateApiRequest[];
+/**
+ * Poll backend logs until all candidate API requests have completion entries,
+ * or the timeout is reached.
+ *
+ * @example
+ * ```ts
+ * const result = await waitForLogCompletion(candidates, {
+ *   fetchLogs: async () => {
+ *     const resp = await fetch(`${origin}/internal/test-logs?eventPhase=end&since=${since}`);
+ *     const body = await resp.json();
+ *     return body.data ?? [];
+ *   },
+ *   timeoutMs: 20_000,
+ * });
+ * ```
+ */
+declare function waitForLogCompletion(candidates: CandidateApiRequest[], options: LogPollerOptions): Promise<LogCompletionResult>;
+
+/**
+ * Critical API rules engine.
+ *
+ * Define per-endpoint validation rules with performance thresholds and
+ * behavior flags. Evaluate captured API records against rules to surface
+ * violations (slow responses, unexpected empty data, fatal timeouts).
+ */
+interface CriticalApiRule {
+    /** Route path this rule applies to (e.g. '/users/list') */
+    routePath: string;
+    /** Human-readable name */
+    name: string;
+    /** URL substring to match against captured API URLs */
+    urlIncludes: string;
+    /** HTTP method filter (optional; matches all if omitted) */
+    method?: string;
+    /** Whether an empty/null response body is acceptable (default: false) */
+    allowEmpty?: boolean;
+    /** Response time warning threshold in ms */
+    warnMs?: number;
+    /** Response time fatal threshold in ms */
+    fatalMs?: number;
+}
+interface ApiRuleViolation {
+    rule: CriticalApiRule;
+    /** 'warn' for exceeded warnMs, 'fatal' for exceeded fatalMs, 'empty' for unexpected empty response */
+    severity: 'warn' | 'fatal' | 'empty';
+    /** Actual duration in ms (for timing violations) */
+    actualMs?: number;
+    /** Description of the violation */
+    message: string;
+}
+interface ApiRecordForRules {
+    url: string;
+    method: string;
+    durationMs: number;
+    /** Response body (for empty checks) */
+    responseBody?: string | null;
+}
+/**
+ * Create a rules engine that evaluates API records against a set of critical rules.
+ */
+declare function createRulesEngine(rules: CriticalApiRule[]): {
+    /** Get all rules. */
+    getRules(): CriticalApiRule[];
+    /** Get rules matching a specific route path. */
+    getRulesByRoute(routePath: string): CriticalApiRule[];
+    /** Get rules matching a specific URL. */
+    getRulesByUrl(url: string): CriticalApiRule[];
+    /**
+     * Evaluate a single API record against all matching rules.
+     * Returns violations (empty array if all rules pass).
+     */
+    evaluate(record: ApiRecordForRules): ApiRuleViolation[];
+    /**
+     * Evaluate multiple API records and return all violations.
+     */
+    evaluateAll(records: ApiRecordForRules[]): ApiRuleViolation[];
+    /**
+     * Summary: group violations by severity.
+     */
+    summarize(violations: ApiRuleViolation[]): {
+        fatal: number;
+        warn: number;
+        empty: number;
+    };
+};
+
+/**
+ * Full orchestration engine: generate → execute → analyze → heal → report.
+ *
+ * Runs a multi-phase pipeline with per-phase tracking, failure detection,
+ * token budget management, and structured result reporting.
+ */
+
+type PhaseStatus = 'success' | 'warn' | 'error' | 'skipped';
+interface PhaseResult<T = unknown> {
+    phase: string;
+    status: PhaseStatus;
+    output?: T;
+    error?: string;
+    durationMs: number;
+}
+interface OrchestrationOptions {
+    /** Which phases to run (default: all) */
+    phases?: OrchestrationPhase[];
+    /** Enable self-healing phase (default: false) */
+    selfHeal?: boolean;
+    /** Max self-healing iterations */
+    maxHealIterations?: number;
+    /** Report formats to generate */
+    reportFormats?: ('html' | 'json' | 'markdown')[];
+    /** Run Playwright in headed mode */
+    headed?: boolean;
+    /** Module filter */
+    module?: string;
+    /** LLM token budget (0 = unlimited) */
+    tokenBudget?: number;
+    /** Abort on phase error (default: false — continue where possible) */
+    abortOnError?: boolean;
+}
+type OrchestrationPhase = 'generate' | 'execute' | 'analyze' | 'heal' | 'report';
+interface ExecutionMetrics {
+    passed: number;
+    failed: number;
+    skipped: number;
+    timedOut: number;
+}
+interface OrchestrationSummary {
+    overallStatus: 'success' | 'partial-fail' | 'fatal-fail';
+    phases: PhaseResult[];
+    totalDurationMs: number;
+    modules: string[];
+    executionMetrics?: ExecutionMetrics;
+    reports?: ReportOutput[];
+    healingResult?: SelfHealingResult;
+    recommendation?: string;
+}
+declare function createOrchestrator(config: OpenCrocConfig, options?: OrchestrationOptions): {
+    run(): Promise<OrchestrationSummary>;
+};
+
+/**
+ * Orchestration summary reporter.
+ * Writes phase-by-phase JSON and a human-readable console summary.
+ */
+
+interface OrchestrationReportOptions {
+    outputDir: string;
+    module?: string;
+}
+/**
+ * Write the orchestration summary to a JSON file.
+ * Returns the written file path.
+ */
+declare function writeOrchestrationSummary(summary: OrchestrationSummary, options: OrchestrationReportOptions): string;
+/**
+ * Print a human-readable console summary.
+ */
+declare function printOrchestrationSummary(summary: OrchestrationSummary): string[];
+
+export { type AIAttributionResult, type ApiChainAnalysisResult, type ApiDependency, type ApiEndpoint, type ApiRecord, type ApiRecordForRules, type ApiRuleViolation, type AttemptRecord, type AutoFixPROptions, type AutoFixPRResult, type BackendAdapter, type BackendDomainItem, type BuildWorkordersOptions, type CandidateApiRequest, type ChainFailureResult, type ChainPlanResult, type ConfigFixer, type ConfigValidator, type ControlledFixOptions, type ControlledFixOutcome, type ControlledFixerOptions, type CriticalApiRule, type DTOFieldInfo, type DTOInfo, type DashboardData, type DashboardOutput, type DialogLoopConfig, type DialogLoopOptions, type DialogLoopSummary, type DirectedAcyclicGraph, type ERDiagramResult, type ExecutionConfig, type ExecutionMetrics, type FailureCategory, type FailureSummary, type FieldSchema, type FixApplier, type FixContext, type FixHistoryEntry, type FixOutcome, type FixResult, type FixScope, type ForeignKeyRelation, type FsOps, type GeneratedTestFile, type GitExecutor, type HookConfig, type ImpactReport, type IndexSchema, type IterationResult, type LayerValidationResult, type LlmProvider, type LogCompletionRecord, type LogCompletionResult, type LogCompletionSummary, type LogEntry, type LogPollerOptions, type ModuleConfigErrorType, type ModuleConfigValidationContext, type ModuleConfigValidationError, type ModuleConfigValidationResult, type ModuleConfigValidationWarning, type ModuleDefinition, type ModuleMetadata, type ModuleTestConfig, type NetworkError, NetworkMonitor, type NetworkMonitorOptions, type OpenCrocConfig, type OpenCrocPlugin, type OrchestrationOptions, type OrchestrationPhase, type OrchestrationReportOptions, type OrchestrationSummary, type PRGenerator, type PatchWriter, type PhaseResult, type PhaseStatus, type PipelineRunResult, type PluginRegistry, type ReportOutput, type ResilientFetchOptions, type ResilientFetchResult, type ResolvedConfig, type ResolvedRoute, type ResultParser, type RouteEntry, type RuntimeConfig, SYSTEM_PROMPTS, type SeedStep, type SelfHealingResult, type TableSchema, type TestChain, type TestFailureInfo, type TestResultRecord, type TestRunner, type TestStep, TokenTracker, type TokenUsageEntry, type TokenUsageSummary, COMMANDS as VSCODE_COMMANDS, type ValidationError, type ValidatorRule, type WorkorderItem, aggregateLogCompletion, analyzeFailureWithLLM, applyControlledFix, autoFix, buildBackendChecklist, buildClassToTableMap, buildDashboardDataFromPipeline, buildDashboardDataFromReportJson, buildFailureSummary, buildGraph, buildModuleTree, buildPath, buildStatusTree, buildTestRunSummary, buildWorkorders, categorizeFailure, classNameToTableName, classifyFailure, compareTestRuns, createAdapter, createApiChainAnalyzer, createAssociationParser, createChainPlanner, createControllerParser, createDrizzleAdapter, createERDiagramGenerator, createImpactReporter, createJsonResultParser, createLlmChainPlanner, createLlmProvider, createMockDataGenerator, createModelParser, createOllamaProvider, createOpenAIProvider, createOrchestrator, createPipeline, createPluginRegistry, createPrismaAdapter, createRulesEngine, createSelfHealingLoop, createSequelizeAdapter, createTestCodeGenerator, createTokenTracker, createTypeORMAdapter, defineConfig, definePlugin, detectAdapter, detectCycles, extractIdFromText, extractParamNames, extractParamsFromHref, formatComparisonReport, formatValidationResult, generateAllModuleConfigs, generateAuthSetup, generateCiTemplate, generateEnhancedConfig, generateExtensionEntrypoint, generateExtensionManifest, generateFixPR, generateGitHubActionsTemplate, generateGitLabCITemplate, generateGlobalSetup, generateGlobalTeardown, generateHtmlReport, generateJsonReport, generateMarkdownReport, generateModuleConfig, generatePlaywrightConfig, generateReports, generateVisualDashboard, generateVisualDashboardHtml, getModulePreset, inferDependencies, inferRelatedTables, listCiPlatforms, listModulePresets, loadModulePresets, mergeCandidates, parseApiDomain, parseAssociationFile, parseControllerDirectory, parseControllerFile, parseDTOs, parseDrizzleDirectory, parseDrizzleFile, parseModelFile, parseModuleModels, parsePlaywrightReport, parseValidatorRules, printOrchestrationSummary, recoverJSON, renderChecklistMarkdown, renderTokenReportMarkdown, renderWorkordersMarkdown, resilientFetch, resolveAdapter, resolveFromSeedData, runDialogLoop, scanModuleMetadata, selectCandidates, selectCandidatesFromLogs, topologicalSort, validateConfig, validateDryrun, validateModuleConfig, validateSchema, validateSemantic, waitForBackend, waitForLogCompletion, writeOrchestrationSummary };